def defineStyle(self):
""" Defines the initial style for the widget """
self.setWindowTitle('Properties')
self.setColumnCount(2)
self.setRowCount(0)
self.setGeometry(QtCore.QRect(0, 0, 400, 500))
self.setColumnWidth(0, 124)
self.setColumnWidth(1, 254)
headerItem = QtGui.QTableWidgetItem()
headerItem.setText(
QtGui.QApplication.translate("PLCTabWidget", "Property Name", None,
QtGui.QApplication.UnicodeUTF8))
self.setHorizontalHeaderItem(0, headerItem)
headerItem1 = QtGui.QTableWidgetItem()
headerItem1.setText(
QtGui.QApplication.translate("PLCTabWidget", "Value", None,
QtGui.QApplication.UnicodeUTF8))
self.setHorizontalHeaderItem(1, headerItem1)
hh = self.horizontalHeader()
if hh.length() > 0:
try:
hh.setSectionResizeMode(hh.ResizeToContents)
except AttributeError: # PyQt4
hh.setResizeMode(hh.ResizeToContents)
def build_diff_table(self, data):
self.comp._wi.tableWidget.clear()
cols=7
self.comp._wi.tableWidget.setColumnCount(cols)
self.comp._wi.tableWidget.setHorizontalHeaderLabels(["Attribute Name", "RV1", "WV1", "RV2", "WV2", "diff1", "diff2"])
self.comp._wi.tableWidget.setGeometry(QtCore.QRect(20, 190, 500, 400))
if data:
rows=len(data)
self.comp._wi.tableWidget.setRowCount(rows)
for row in range(0, rows):
for col in range(0, cols):
item=QtGui.QTableWidgetItem("%s" % data[row][col])
if (data[row][col]==None or data[row][col]=='None'):
item=QtGui.QTableWidgetItem("%s" %"X")
item.setTextColor(QtGui.QColor(255,0,0))
if row%2==0:
item.setBackgroundColor(QtGui.QColor(225,225,225))
if (col==5 or col==6) and (data[row][col]!=0) and (data[row][col]!='None') and (data[row][col]!=None):
item.setBackgroundColor(QtGui.QColor(45,150,255))
elif (col==1 or col==2):
if (data[row][col]>data[row][col+2]):
item.setBackgroundColor(QtGui.QColor(255,0,0))
elif(data[row][col]<data[row][col+2]):
item.setBackgroundColor(QtGui.QColor(255,255,0))
elif (col==3 or col==4):
if (data[row][col]>data[row][col-2]):
item.setBackgroundColor(QtGui.QColor(255,0,0))
elif (data[row][col]<data[row][col-2]):
item.setBackgroundColor(QtGui.QColor(255,255,0))
self.comp._wi.tableWidget.setItem(row,col,item)
else:
self.comp._wi.tableWidget.setRowCount(1)
item=QtGui.QTableWidgetItem("%s" % QtCore.QString('No Data!'))
self.comp._wi.tableWidget.setItem(0, 0, item)
self.comp._wi.tableWidget.resizeColumnsToContents()
def __init__(self, parent=None, designMode=False):
TaurusWidget.__init__(self, parent=None, designMode=designMode)
self.loadUi(filename="selectsignal.ui")
self.signalComboBox = SignalComboBox(self)
self.signalComboBox.setGeometry(QtCore.QRect(70, 50, 161, 27))
self.signalComboBox.setObjectName("SignalcomboBox")
self.signalComboBox.currentIndexChanged['QString'].connect(
self.onSignalChanged)
self.doorName = None
self.door_device = None
registerExtensions()
def defineStyle(self):
""" Defines the initial style for the widget """
self.setWindowTitle('Properties')
self.setColumnCount(2)
self.setRowCount(0)
self.setGeometry(QtCore.QRect(0, 0, 400, 500))
self.setColumnWidth(0, 124)
self.setColumnWidth(1, 254)
headerItem = QtGui.QTableWidgetItem()
headerItem.setText(
QtGui.QApplication.translate("PLCTabWidget", "Property Name", None,
QtGui.QApplication.UnicodeUTF8))
self.setHorizontalHeaderItem(0, headerItem)
headerItem1 = QtGui.QTableWidgetItem()
headerItem1.setText(
QtGui.QApplication.translate("PLCTabWidget", "Value", None,
QtGui.QApplication.UnicodeUTF8))
self.setHorizontalHeaderItem(1, headerItem1)
self.horizontalHeader().setResizeMode(
QtGui.QHeaderView.ResizeToContents) # .Stretch)
def setModel(self, model):
if model is not None:
self.device = taurus.Device(model)
self.pseudo_motor_names = []
for motor in self.device.hklpseudomotorlist:
self.pseudo_motor_names.append(motor.split(' ')[0])
self.h_device_name = self.pseudo_motor_names[0]
self.h_device = taurus.Device(self.h_device_name)
self.k_device_name = self.pseudo_motor_names[1]
self.k_device = taurus.Device(self.k_device_name)
self.l_device_name = self.pseudo_motor_names[2]
self.l_device = taurus.Device(self.l_device_name)
# Set model to hkl components
hmodel = self.h_device_name + "/Position"
self._ui.taurusValueLineH.setModel(hmodel)
self._ui.taurusLabelValueH.setModel(hmodel)
kmodel = self.k_device_name + "/Position"
self._ui.taurusValueLineK.setModel(kmodel)
self._ui.taurusLabelValueK.setModel(kmodel)
lmodel = self.l_device_name + "/Position"
self._ui.taurusValueLineL.setModel(lmodel)
self._ui.taurusLabelValueL.setModel(lmodel)
# Add dynamically the angle widgets
motor_list = self.device.motorlist
self.motor_names = []
self.motor_devices = []
for motor in self.device.motorlist:
self.motor_names.append(motor.split(' ')[0])
self.motor_devices.append(
taurus.Device(self.motor_names[len(self.motor_names) - 1]))
self.nb_motors = len(motor_list)
angles_labels = []
self.angles_names = []
angles_taurus_label = []
angles_taurus_input = []
gap_x = 650 / self.nb_motors
try:
self.angles_names = self.device.motorroles
except: # Only for compatibility
if self.nb_motors == 4:
self.angles_names.append("omega")
self.angles_names.append("chi")
self.angles_names.append("phi")
self.angles_names.append("theta")
elif self.nb_motors == 6:
self.angles_names.append("mu")
self.angles_names.append("th")
self.angles_names.append("chi")
self.angles_names.append("phi")
self.angles_names.append("gamma")
self.angles_names.append("delta")
for i in range(0, self.nb_motors):
angles_labels.append(QtGui.QLabel(self))
angles_labels[i].setGeometry(
QtCore.QRect(150 + gap_x * i, 40, 71, 17))
angles_labels[i].setLayoutDirection(QtCore.Qt.RightToLeft)
alname = "angleslabel" + str(i)
angles_labels[i].setObjectName(alname)
angles_labels[i].setText(
QtGui.QApplication.translate("HKLScan", self.angles_names[i],
None,
QtGui.QApplication.UnicodeUTF8))
angles_taurus_label.append(TaurusLabel(self))
angles_taurus_label[i].setGeometry(
QtCore.QRect(150 + gap_x * i, 70, 81, 19))
atlname = "anglestauruslabel" + str(i)
angles_taurus_label[i].setObjectName(atlname)
angles_taurus_label[i].setModel(self.motor_names[i] + "/Position")
angles_taurus_input.append(TaurusValueLineEdit(self))
angles_taurus_input[i].setGeometry(
QtCore.QRect(145 + gap_x * i, 100, 91, 27))
atlname = "anglestaurusinput" + str(i)
angles_taurus_input[i].setObjectName(atlname)
angles_taurus_input[i].setModel(self.motor_names[i] + "/Position")
# Set model to engine and modes
enginemodel = model + '/engine'
self._ui.taurusLabelEngine.setModel(enginemodel)
enginemodemodel = model + '/enginemode'
self._ui.taurusLabelEngineMode.setModel(enginemodemodel)
self.enginemodescombobox = EngineModesComboBox(self)
self.enginemodescombobox.setGeometry(QtCore.QRect(150, 315, 221, 27))
self.enginemodescombobox.setObjectName("enginemodeslist")
self.enginemodescombobox.loadEngineModeNames(self.device.hklmodelist)
self.connect(self.enginemodescombobox,
Qt.SIGNAL("currentIndexChanged(QString)"),
self.onModeChanged)
# Add dynamically the scan buttons, range inputs and 'to max' buttons
scan_buttons = []
self.range_inputs = []
self.tomax_buttons = [
] # The text will be change when the max. is computed
exec_functions = [
self.exec_scan1, self.exec_scan2, self.exec_scan3, self.exec_scan4,
self.exec_scan5, self.exec_scan6
]
tomax_functions = [
self.tomax_scan1, self.tomax_scan2, self.tomax_scan3,
self.tomax_scan4, self.tomax_scan5, self.tomax_scan6
]
gap_x = 650 / self.nb_motors
for i in range(0, self.nb_motors):
scan_buttons.append(QtGui.QPushButton(self))
scan_buttons[i].setGeometry(
QtCore.QRect(150 + gap_x * i, 405, 100, 26))
wname = "scanbutton" + str(i)
scan_buttons[i].setObjectName(wname)
scan_buttons[i].setText(
QtGui.QApplication.translate("DiffractometerAlignment",
self.angles_names[i], None,
QtGui.QApplication.UnicodeUTF8))
self.connect(scan_buttons[i], Qt.SIGNAL("clicked()"),
exec_functions[i])
self.range_inputs.append(QtGui.QLineEdit(self))
self.range_inputs[i].setGeometry(
QtCore.QRect(150 + gap_x * i, 440, 100, 26))
self.range_inputs[i].setLayoutDirection(QtCore.Qt.RightToLeft)
wname = "rangeinput" + str(i)
self.range_inputs[i].setObjectName(wname)
self.tomax_buttons.append(QtGui.QPushButton(self))
self.tomax_buttons[i].setGeometry(
QtCore.QRect(150 + gap_x * i, 475, 100, 26))
wname = "tomaxbutton" + str(i)
self.tomax_buttons[i].setObjectName(wname)
self.tomax_buttons[i].setText(
QtGui.QApplication.translate("DiffractometerAlignment", 'n.n.',
None,
QtGui.QApplication.UnicodeUTF8))
self.connect(self.tomax_buttons[i], Qt.SIGNAL("clicked()"),
tomax_functions[i])
def setModel(self, model):
self.model = model
if model is not None:
self.device = taurus.Device(model)
self.update_values()
uxmodel = model + "/ux"
self._ui.taurusuxvalue.setModel(uxmodel)
self._ui.taurusuxeditvalue.setModel(uxmodel)
uymodel = model + "/uy"
self._ui.taurusuyvalue.setModel(uymodel)
self._ui.taurusuyeditvalue.setModel(uymodel)
uzmodel = model + "/uz"
self._ui.taurusuzvalue.setModel(uzmodel)
self._ui.taurusuzeditvalue.setModel(uzmodel)
amodel = model + "/a"
self._ui.taurusalatticevalue.setModel(amodel)
self._ui.taurusalatticeeditvalue.setModel(amodel)
bmodel = model + "/b"
self._ui.taurusblatticevalue.setModel(bmodel)
self._ui.taurusblatticeeditvalue.setModel(bmodel)
cmodel = model + "/c"
self._ui.taurusclatticevalue.setModel(cmodel)
self._ui.taurusclatticeeditvalue.setModel(cmodel)
alphamodel = model + "/alpha"
self._ui.taurusalphalatticevalue.setModel(alphamodel)
self._ui.taurusalphalatticeeditvalue.setModel(alphamodel)
betamodel = model + "/beta"
self._ui.taurusbetalatticevalue.setModel(betamodel)
self._ui.taurusbetalatticeeditvalue.setModel(betamodel)
gammamodel = model + "/gamma"
self._ui.taurusgammalatticevalue.setModel(gammamodel)
self._ui.taurusgammalatticeeditvalue.setModel(gammamodel)
psirefhmodel = model + "/psirefh"
self._ui.taurusvalue_psirefh.setModel(psirefhmodel)
self._ui.tauruseditvalue_psirefh.setModel(psirefhmodel)
psirefkmodel = model + "/psirefk"
self._ui.taurusvalue_psirefk.setModel(psirefkmodel)
self._ui.tauruseditvalue_psirefk.setModel(psirefkmodel)
psireflmodel = model + "/psirefl"
self._ui.taurusvalue_psirefl.setModel(psireflmodel)
self._ui.tauruseditvalue_psirefl.setModel(psireflmodel)
wavelengthmodel = model + "/wavelength"
self._ui.tauruswavelengthvalue.setModel(wavelengthmodel)
# Set model to engine and modes
enginemodel = model + '/engine'
self._ui.taurusLabelEngine.setModel(enginemodel)
self.enginescombobox = PrivateComboBox(self)
self.enginescombobox.setGeometry(QtCore.QRect(130, 460, 221, 27))
self.enginescombobox.setObjectName("engineslist")
self.enginescombobox.loadItems(self.device.enginelist)
self.enginescombobox.currentIndexChanged['QString'].connect(
self.onEngineChanged)
enginemodemodel = model + '/enginemode'
self._ui.taurusLabelEngineMode.setModel(enginemodemodel)
self.enginemodescombobox = PrivateComboBox(self)
self.enginemodescombobox.setGeometry(QtCore.QRect(130, 500, 221, 27))
self.enginemodescombobox.setObjectName("enginemodeslist")
self.enginemodescombobox.loadItems(self.device.enginemodelist)
self.enginemodescombobox.currentIndexChanged['QString'].connect(
self.onModeChanged)
# Set model to crystal
crystalmodel = model + '/crystal'
self._ui.taurusLabelCrystal.setModel(crystalmodel)
self.crystalscombobox = PrivateComboBox(self)
self.crystalscombobox.setGeometry(QtCore.QRect(130, 540, 221, 27))
self.crystalscombobox.setObjectName("crystallist")
self.crystalscombobox.loadItems(self.device.crystallist)
self.crystalscombobox.currentIndexChanged['QString'].connect(
self.onCrystalChanged)
def reflections_list_window(self):
reflections = self.device.reflectionlist
nb_ref = 0
xindex = 20
xh = 70
xk = 150
xl = 230
xrelevance = 330
xaffinement = 380
xangle1 = 430
xangle2 = 510
xangle3 = 590
xangle4 = 670
xangle5 = 750
xangle6 = 830
yhkl = 100
w = ReflectionsList()
self.taurusValueIndex = []
self.taurusValueH = []
self.taurusValueK = []
self.taurusValueL = []
self.taurusValueRelevance = []
self.taurusValueAffinement = []
self.taurusValueAngle1 = []
self.taurusValueAngle2 = []
self.taurusValueAngle3 = []
self.taurusValueAngle4 = []
self.taurusValueAngle5 = []
self.taurusValueAngle6 = []
if reflections is not None:
for ref in reflections:
if nb_ref == 0:
self.rl_label1_7 = QtGui.QLabel(w)
self.rl_label1_7.setGeometry(
QtCore.QRect(xangle1 + 20, 70, 51, 20))
self.rl_label1_7.setObjectName("rl_label1_7")
# self.testlabel.setLayoutDirection(QtCore.Qt.RightToLeft)
self.rl_label1_8 = QtGui.QLabel(w)
self.rl_label1_8.setGeometry(
QtCore.QRect(xangle2 + 20, 70, 71, 20))
self.rl_label1_8.setObjectName("rl_label1_8")
# self.testlabel.setLayoutDirection(QtCore.Qt.RightToLeft)
self.rl_label1_9 = QtGui.QLabel(w)
self.rl_label1_9.setGeometry(
QtCore.QRect(xangle3 + 20, 70, 41, 20))
self.rl_label1_9.setObjectName("rl_label1_9")
self.rl_label1_10 = QtGui.QLabel(w)
self.rl_label1_10.setGeometry(
QtCore.QRect(xangle4 + 20, 70, 41, 20))
self.rl_label1_10.setObjectName("rl_label1_10")
try:
self.angle_names = self.device.motorroles
except: # Only for compatibility
if self.nb_motors == 4:
self.angles_names.append("omega")
self.angles_names.append("chi")
self.angles_names.append("phi")
self.angles_names.append("theta")
elif self.nb_motors == 6:
self.angles_names.append("mu")
self.angles_names.append("th")
self.angles_names.append("chi")
self.angles_names.append("phi")
self.angles_names.append("gamma")
self.angles_names.append("delta")
# 4circles diffractometer
if len(ref) == 10:
self.rl_label1_7.setText(QtGui.QApplication.translate(
"Form", self.angle_names[0], None))
self.rl_label1_8.setText(QtGui.QApplication.translate(
"Form", self.angle_names[1], None))
self.rl_label1_9.setText(QtGui.QApplication.translate(
"Form", self.angle_names[2], None))
self.rl_label1_10.setText(QtGui.QApplication.translate(
"Form", self.angle_names[3], None))
# 6 circles diffractometer
elif len(ref) == 12:
self.rl_label1_11 = QtGui.QLabel(w)
self.rl_label1_11.setGeometry(
QtCore.QRect(xangle5 + 20, 70, 71, 20))
self.rl_label1_11.setObjectName("rl_label1_11")
self.rl_label1_12 = QtGui.QLabel(w)
self.rl_label1_12.setGeometry(
QtCore.QRect(xangle6 + 20, 70, 41, 20))
self.rl_label1_12.setObjectName("rl_label1_12")
self.rl_label1_7.setText(QtGui.QApplication.translate(
"Form", self.angle_names[0], None))
self.rl_label1_8.setText(QtGui.QApplication.translate(
"Form", self.angle_names[1], None))
self.rl_label1_9.setText(QtGui.QApplication.translate(
"Form", self.angle_names[2], None))
self.rl_label1_10.setText(QtGui.QApplication.translate(
"Form", self.angle_names[3], None))
self.rl_label1_11.setText(QtGui.QApplication.translate(
"Form", self.angle_names[4], None))
self.rl_label1_12.setText(QtGui.QApplication.translate(
"Form", self.angle_names[5], None))
self.taurusValueIndex.append(TaurusValueLineEdit(w))
self.taurusValueIndex[nb_ref].setGeometry(
QtCore.QRect(xindex, 100 + 30 * (nb_ref), 41, 27))
self.taurusValueIndex[nb_ref].setReadOnly(True)
indexname = "taurusValueIndex" + str(nb_ref + 2)
self.taurusValueIndex[nb_ref].setObjectName(indexname)
self.taurusValueIndex[nb_ref].setValue(int(ref[0]))
self.taurusValueH.append(TaurusValueLineEdit(w))
self.taurusValueH[nb_ref].setGeometry(
QtCore.QRect(xh, 100 + 30 * (nb_ref), 81, 27))
self.taurusValueH[nb_ref].setReadOnly(True)
hname = "taurusValueH" + str(nb_ref + 2)
self.taurusValueH[nb_ref].setObjectName(hname)
self.taurusValueH[nb_ref].setValue("%10.4f" % ref[1])
self.taurusValueK.append(TaurusValueLineEdit(w))
self.taurusValueK[nb_ref].setGeometry(
QtCore.QRect(xk, 100 + 30 * (nb_ref), 81, 27))
self.taurusValueK[nb_ref].setReadOnly(True)
kname = "taurusValueK" + str(nb_ref + 2)
self.taurusValueK[nb_ref].setObjectName(kname)
self.taurusValueK[nb_ref].setValue("%10.4f" % ref[2])
self.taurusValueL.append(TaurusValueLineEdit(w))
self.taurusValueL[nb_ref].setGeometry(
QtCore.QRect(xl, 100 + 30 * (nb_ref), 81, 27))
self.taurusValueL[nb_ref].setReadOnly(True)
lname = "taurusValueL" + str(nb_ref + 2)
self.taurusValueL[nb_ref].setObjectName(lname)
self.taurusValueL[nb_ref].setValue("%10.4f" % ref[3])
self.taurusValueRelevance.append(TaurusValueLineEdit(w))
self.taurusValueRelevance[nb_ref].setGeometry(
QtCore.QRect(xrelevance, 100 + 30 * (nb_ref), 41, 27))
self.taurusValueRelevance[nb_ref].setReadOnly(True)
relevancename = "taurusValueRelevance" + str(nb_ref + 2)
self.taurusValueRelevance[nb_ref].setObjectName(relevancename)
self.taurusValueRelevance[nb_ref].setValue(int(ref[4]))
self.taurusValueAffinement.append(TaurusValueLineEdit(w))
self.taurusValueAffinement[nb_ref].setGeometry(
QtCore.QRect(xaffinement, 100 + 30 * (nb_ref), 41, 27))
self.taurusValueAffinement[nb_ref].setReadOnly(True)
affinementname = "taurusValueAffinement" + str(nb_ref + 2)
self.taurusValueAffinement[
nb_ref].setObjectName(affinementname)
self.taurusValueAffinement[nb_ref].setValue(int(ref[5]))
self.taurusValueAngle1.append(TaurusValueLineEdit(w))
self.taurusValueAngle1[nb_ref].setGeometry(
QtCore.QRect(xangle1, 100 + 30 * (nb_ref), 81, 27))
self.taurusValueAngle1[nb_ref].setReadOnly(True)
angle1name = "taurusValueAngle1" + str(nb_ref + 2)
self.taurusValueAngle1[nb_ref].setObjectName(angle1name)
self.taurusValueAngle1[nb_ref].setValue("%10.4f" % ref[6])
self.taurusValueAngle2.append(TaurusValueLineEdit(w))
self.taurusValueAngle2[nb_ref].setGeometry(
QtCore.QRect(xangle2, 100 + 30 * (nb_ref), 81, 27))
self.taurusValueAngle2[nb_ref].setReadOnly(True)
angle2name = "taurusValueAngle2" + str(nb_ref + 2)
self.taurusValueAngle2[nb_ref].setObjectName(angle2name)
self.taurusValueAngle2[nb_ref].setValue("%10.4f" % ref[7])
self.taurusValueAngle3.append(TaurusValueLineEdit(w))
self.taurusValueAngle3[nb_ref].setGeometry(
QtCore.QRect(xangle3, 100 + 30 * (nb_ref), 81, 27))
self.taurusValueAngle3[nb_ref].setReadOnly(True)
angle3name = "taurusValueAngle3" + str(nb_ref + 2)
self.taurusValueAngle3[nb_ref].setObjectName(angle3name)
self.taurusValueAngle3[nb_ref].setValue("%10.4f" % ref[8])
self.taurusValueAngle4.append(TaurusValueLineEdit(w))
self.taurusValueAngle4[nb_ref].setGeometry(
QtCore.QRect(xangle4, 100 + 30 * (nb_ref), 81, 27))
self.taurusValueAngle4[nb_ref].setReadOnly(True)
angle4name = "taurusValueAngle4" + str(nb_ref + 2)
self.taurusValueAngle4[nb_ref].setObjectName(angle4name)
self.taurusValueAngle4[nb_ref].setValue("%10.4f" % ref[9])
if len(ref) == 12:
self.taurusValueAngle5.append(TaurusValueLineEdit(w))
self.taurusValueAngle5[nb_ref].setGeometry(
QtCore.QRect(xangle5, 100 + 30 * (nb_ref), 81, 27))
self.taurusValueAngle5[nb_ref].setReadOnly(True)
angle5name = "taurusValueAngle5" + str(nb_ref + 2)
self.taurusValueAngle5[nb_ref].setObjectName(angle5name)
self.taurusValueAngle5[nb_ref].setValue("%10.4f" % ref[10])
self.taurusValueAngle6.append(TaurusValueLineEdit(w))
self.taurusValueAngle6[nb_ref].setGeometry(
QtCore.QRect(xangle6, 100 + 30 * (nb_ref), 81, 27))
self.taurusValueAngle6[nb_ref].setReadOnly(True)
angle6name = "taurusValueAngle6" + str(nb_ref + 2)
self.taurusValueAngle6[nb_ref].setObjectName(angle6name)
self.taurusValueAngle6[nb_ref].setValue("%10.4f" % ref[11])
nb_ref = nb_ref + 1
w.resize(930, 100 + nb_ref * 50)
else:
self.rl_label_nor = QtGui.QLabel(w)
self.rl_label_nor.setGeometry(
QtCore.QRect(xangle1 - 50, 110, 300, 20))
font = QtGui.QFont()
font.setPointSize(12)
font.setWeight(75)
font.setBold(True)
self.rl_label_nor.setFont(font)
self.rl_label_nor.setObjectName("rl_label_nor")
self.rl_label_nor.setText(QtGui.QApplication.translate(
"Form", "NO REFLECTIONS", None))
w.show()
w.show()
def setModel(self, model):
if model is not None:
self.device = taurus.Device(model)
self.pseudo_motor_names = []
for motor in self.device.hklpseudomotorlist:
self.pseudo_motor_names.append(motor.split(' ')[0])
self.h_device_name = self.pseudo_motor_names[0]
self.h_device = taurus.Device(self.h_device_name)
self.k_device_name = self.pseudo_motor_names[1]
self.k_device = taurus.Device(self.k_device_name)
self.l_device_name = self.pseudo_motor_names[2]
self.l_device = taurus.Device(self.l_device_name)
# Add dynamically the angle widgets
motor_list = self.device.motorlist
motor_names = []
for motor in self.device.motorlist:
motor_names.append(motor.split(' ')[0])
self.nb_motors = len(motor_list)
angles_labels = []
angles_names = []
angles_taurus_label = []
gap_x = 800 / self.nb_motors
try:
angles_names = self.device.motorroles
except: # Only for compatibility
if self.nb_motors == 4:
angles_names.append("omega")
angles_names.append("chi")
angles_names.append("phi")
angles_names.append("theta")
elif self.nb_motors == 6:
angles_names.append("mu")
angles_names.append("th")
angles_names.append("chi")
angles_names.append("phi")
angles_names.append("gamma")
angles_names.append("delta")
for i in range(0, self.nb_motors):
angles_labels.append(QtGui.QLabel(self))
angles_labels[i].setGeometry(
QtCore.QRect(50 + gap_x * i, 290, 51, 17))
alname = "angleslabel" + str(i)
angles_labels[i].setObjectName(alname)
angles_labels[i].setText(
QtGui.QApplication.translate("HKLScan", angles_names[i], None,
QtGui.QApplication.UnicodeUTF8))
angles_taurus_label.append(TaurusLabel(self))
angles_taurus_label[i].setGeometry(
QtCore.QRect(50 + gap_x * i, 320, 81, 19))
atlname = "anglestauruslabel" + str(i)
angles_taurus_label[i].setObjectName(atlname)
angles_taurus_label[i].setModel(motor_names[i] + "/Position")
# Set model to hkl display
hmodel = self.h_device_name + "/Position"
self._ui.taurusValueLineH.setModel(hmodel)
self._ui.taurusLabelValueH.setModel(hmodel)
kmodel = self.k_device_name + "/Position"
self._ui.taurusValueLineK.setModel(kmodel)
self._ui.taurusLabelValueK.setModel(kmodel)
lmodel = self.l_device_name + "/Position"
self._ui.taurusValueLineL.setModel(lmodel)
self._ui.taurusLabelValueL.setModel(lmodel)
# Set model to engine and modes
enginemodel = model + '/engine'
self._ui.taurusLabelEngine.setModel(enginemodel)
enginemodemodel = model + '/enginemode'
self._ui.taurusLabelEngineMode.setModel(enginemodemodel)
self.enginemodescombobox = EngineModesComboBox(self)
self.enginemodescombobox.setGeometry(QtCore.QRect(150, 445, 221, 27))
self.enginemodescombobox.setObjectName("enginemodeslist")
self.enginemodescombobox.loadEngineModeNames(self.device.hklmodelist)
self.connect(self.enginemodescombobox,
Qt.SIGNAL("currentIndexChanged(QString)"),
self.onModeChanged)
def display_angles(self):
xangle = []
for i in range(0, 6):
xangle.append(40 + i * 100)
yhkl = 50
tr = self.device.selectedtrajectory
w = DisplayScanAngles()
angles_labels = []
angles_names = []
if self.nb_motors == 4:
angles_names.append("omega")
angles_names.append("chi")
angles_names.append("phi")
angles_names.append("theta")
elif self.nb_motors == 6:
angles_names.append("mu")
angles_names.append("th")
angles_names.append("chi")
angles_names.append("phi")
angles_names.append("gamma")
angles_names.append("delta")
dsa_label = []
for i in range(0, self.nb_motors):
dsa_label.append(QtGui.QLabel(w))
dsa_label[i].setGeometry(QtCore.QRect(xangle[i], yhkl, 51, 20))
label_name = "dsa_label_" + str(i)
dsa_label[i].setObjectName(label_name)
dsa_label[i].setText(
QtGui.QApplication.translate("Form", angles_names[i], None,
QtGui.QApplication.UnicodeUTF8))
start_hkl = []
stop_hkl = []
missed_values = 0
# TODO: This code will raise exception if one of the line edits is empty.
# But not all dimensions (H & K & L) are obligatory. One could try
# to display angles of just 1 or 2 dimensional scan.
try:
start_hkl.append(float(self._ui.lineEditStartH.text()))
start_hkl.append(float(self._ui.lineEditStartK.text()))
start_hkl.append(float(self._ui.lineEditStartL.text()))
stop_hkl.append(float(self._ui.lineEditStopH.text()))
stop_hkl.append(float(self._ui.lineEditStopK.text()))
stop_hkl.append(float(self._ui.lineEditStopL.text()))
nb_points = int(self._ui.LineEditNbpoints.text())
except:
nb_points = -1
missed_values = 1
increment_hkl = []
if nb_points > 0:
for i in range(0, 3):
increment_hkl.append((stop_hkl[i] - start_hkl[i]) / nb_points)
taurusValueAngle = []
for i in range(0, nb_points + 1):
hkl_temp = []
for j in range(0, 3):
hkl_temp.append(start_hkl[j] + i * increment_hkl[j])
no_trajectories = 0
try:
self.device.write_attribute("computetrajectoriessim", hkl_temp)
except:
no_trajectories = 1
if not no_trajectories:
angles_list = self.device.trajectorylist[tr]
taurusValueAngle.append([])
for iangle in range(0, self.nb_motors):
taurusValueAngle[i].append(TaurusValueLineEdit(w))
taurusValueAngle[i][iangle].setGeometry(
QtCore.QRect(xangle[iangle], yhkl + 30 * (i + 1), 80,
27))
taurusValueAngle[i][iangle].setReadOnly(True)
tva_name = "taurusValueAngle" + str(i) + "_" + str(iangle)
taurusValueAngle[i][iangle].setObjectName(tva_name)
taurusValueAngle[i][iangle].setValue("%10.4f" %
angles_list[iangle])
else:
taurusValueAngle.append(TaurusValueLineEdit(w))
taurusValueAngle[i].setGeometry(
QtCore.QRect(xangle[0], yhkl + 30 * (i + 1),
self.nb_motors * 120, 27))
taurusValueAngle[i].setReadOnly(True)
tva_name = "taurusValueAngle" + str(i)
taurusValueAngle[i].setObjectName(tva_name)
taurusValueAngle[i].setValue(
"... No angle solution for hkl values ..."
)
# TODO: not all dimensions (H & K & L) are obligatory. One could try
# to display angles of just 1 or 2 dimensional scan.
if nb_points == -1:
nb_points = 0
taurusValueAngle.append(TaurusValueLineEdit(w))
taurusValueAngle[0].setGeometry(
QtCore.QRect(xangle[0], yhkl + 30, self.nb_motors * 120, 27))
taurusValueAngle[0].setReadOnly(True)
tva_name = "taurusValueAngle"
taurusValueAngle[0].setObjectName(tva_name)
taurusValueAngle[0].setValue(
"... No scan parameters filled. Fill them in the main window ..."
)
w.resize(self.nb_motors * 140, 120 + nb_points * 40)
w.show()
w.show()
def setModel(self, model):
if model is not None:
self.device = taurus.Device(model)
xhkl = []
xangles = []
xlabels = []
for i in range(0, 6):
xhkl.append(70 + 80 * i)
xangles.append(310 + 80 * i)
xlabels.append(340 + 90 * i)
ybasis = 20
reflections = self.device.reflectionlist
angle_names = []
self.angle_labels = []
self.hkl_values = []
self.angle_values = []
self.index_values = []
# Find number of real motors
self.nb_angles = len(self.device.motorlist)
if reflections is not None:
self.nb_reflections = len(reflections)
else:
self.nb_reflections = 0
try:
angle_names = self.device.motorroles
except: # Only for compatibility
if self.nb_angles == 4:
angle_names.append("omega")
angle_names.append("chi")
angle_names.append("phi")
angle_names.append("tth")
elif self.nb_angles == 6:
angle_names.append("mu")
angle_names.append("th")
angle_names.append("chi")
angle_names.append("phi")
angle_names.append("gamma")
angle_names.append("delta")
for jref in range(0, 10):
self.index_values.append(QtGui.QLineEdit(self))
self.index_values[jref].setLayoutDirection(QtCore.Qt.RightToLeft)
self.index_values[jref].setGeometry(
QtCore.QRect(20, ybasis + 30 * (jref + 1), 51, 27))
object_name = "indexvalue" + str(jref)
self.index_values[jref].setObjectName(object_name)
for i in range(0, 3):
self.hkl_values.append([])
for jref in range(0, 10):
self.hkl_values[i].append(QtGui.QLineEdit(self))
self.hkl_values[i][jref].setLayoutDirection(
QtCore.Qt.RightToLeft)
self.hkl_values[i][jref].setGeometry(
QtCore.QRect(xhkl[i], ybasis + 30 * (jref + 1), 81, 27))
object_name = "hklvalue" + str(i) + "_" + str(jref)
self.hkl_values[i][jref].setObjectName(object_name)
for i in range(0, self.nb_angles):
self.angle_labels.append(QtGui.QLabel(self))
self.angle_labels[i].setGeometry(
QtCore.QRect(xangles[i], ybasis, 70, 20))
self.angle_labels[i].setLayoutDirection(QtCore.Qt.RightToLeft)
object_name = "anglelabel" + str(i)
self.angle_labels[i].setObjectName(object_name)
self.angle_labels[i].setText(
QtGui.QApplication.translate("Form", angle_names[i], None,
QtGui.QApplication.UnicodeUTF8))
self.angle_values.append([])
for jref in range(0, 10):
self.angle_values[i].append(QtGui.QLineEdit(self))
self.angle_values[i][jref].setLayoutDirection(
QtCore.Qt.RightToLeft)
self.angle_values[i][jref].setGeometry(
QtCore.QRect(xangles[i], ybasis + 30 * (jref + 1), 81, 27))
object_name = "anglevalue" + str(i) + "_" + str(jref)
self.angle_values[i][jref].setObjectName(object_name)
for jref in range(0, self.nb_reflections):
ref = reflections[jref]
# Fill index
self.index_values[jref].setText(str(jref))
# Fill hkl values
for i in range(0, 3):
self.hkl_values[i][jref].setText(
("%12.4f" % ref[i + 1]).strip())
# Fill the angle values
for i in range(0, self.nb_angles):
self.angle_values[i][jref].setText(
("%12.4f" % ref[i + 6]).strip())
