Source code for PyMca5.PyMcaGui.physics.xrf.ConcentrationsWidget

#/*##########################################################################
#
# The PyMca X-Ray Fluorescence Toolkit
#
# Copyright (c) 2004-2014 European Synchrotron Radiation Facility
#
# This file is part of the PyMca X-ray Fluorescence Toolkit developed at
# the ESRF by the Software group.
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
#############################################################################*/
__author__ = "V. Armando Sole - ESRF Data Analysis"
__contact__ = "sole@esrf.fr"
__license__ = "MIT"
__copyright__ = "European Synchrotron Radiation Facility, Grenoble, France"
import sys
from PyMca5.PyMcaGui import PyMcaQt as qt

if hasattr(qt, 'QString'):
    QString = qt.QString
else:
    QString = str

QTVERSION = qt.qVersion()

XRFMC_FLAG = False
if QTVERSION > '4.0.0':
    XRFMC_FLAG = True

QTable = qt.QTableWidget

from PyMca5.PyMcaPhysics.xrf import ConcentrationsTool
from PyMca5.PyMcaPhysics.xrf import Elements
import time
DEBUG = 0
if DEBUG:
    print("ConcentrationsWidget is in debug mode")


[docs]class Concentrations(qt.QWidget): sigConcentrationsSignal = qt.pyqtSignal(object) sigClosed = qt.pyqtSignal() def __init__(self, parent=None, name="Concentrations"): qt.QWidget.__init__(self, parent) self.setWindowTitle(name) self.build() self.setParameters = self.concentrationsWidget.setParameters self.getParameters = self.concentrationsWidget.getParameters self.setTimeFactor = self.concentrationsWidget.setTimeFactor self.__lastVar = None self.__lastKw = None
[docs] def build(self): layout = qt.QVBoxLayout(self) layout.setContentsMargins(0, 0, 0, 0) layout.setSpacing(0) self.concentrationsTool = ConcentrationsTool.ConcentrationsTool() self.concentrationsWidget = ConcentrationsWidget(self) self.concentrationsTable = ConcentrationsTable(self) layout.addWidget(self.concentrationsWidget) layout.addWidget(self.concentrationsTable) layout.setStretchFactor(self.concentrationsWidget, 0) layout.setStretchFactor(self.concentrationsTable, 1) self.concentrationsWidget.sigConcentrationsWidgetSignal.connect( \ self.mySlot) self.concentrationsTool.configure( self.concentrationsWidget.getParameters()) self.__connected = True
[docs] def mySlot(self, ddict=None): if ddict is None: ddict = {} if not self.__connected: return try: # try to avoid multiple triggering on Mac OS self.__connected = False self.concentrationsTable.setFocus() app = qt.QApplication.instance() app.processEvents() finally: self.__connected = True if ddict['event'] == 'updated': self.concentrationsTool.configure(ddict) if self.__lastKw is not None: addInfo = False if 'addinfo' in self.__lastKw: if self.__lastKw['addinfo']: addInfo = True try: if addInfo: concentrations, info = self.processFitResult(*self.__lastVar, **self.__lastKw) else: concentrations = self.processFitResult(*self.__lastVar, **self.__lastKw) ddict['concentrations'] = concentrations except: self.__lastKw = None raise self.mySignal(ddict)
[docs] def mySignal(self, ddict=None): if ddict is None: ddict = {} self.sigConcentrationsSignal.emit(ddict)
[docs] def processFitResult(self, *var, **kw): self.__lastVar = var self.__lastKw = kw addInfo = False if 'addinfo' in kw: if kw['addinfo']: addInfo = True if DEBUG: if addInfo: ddict, info = self.concentrationsTool.processFitResult(*var, **kw) self.concentrationsTable.fillFromResult(ddict) return ddict, info else: ddict = self.concentrationsTool.processFitResult(*var, **kw) self.concentrationsTable.fillFromResult(ddict) return ddict try: threadResult = self._submitThread(*var, **kw) if type(threadResult) == type((1,)): if len(threadResult): if threadResult[0] == "Exception": raise Exception(threadResult[1], threadResult[2]) if addInfo: ddict, info = threadResult self.concentrationsTable.fillFromResult(ddict) return ddict, info else: ddict = threadResult self.concentrationsTable.fillFromResult(ddict) return ddict except: self.__lastKw = None self.concentrationsTable.setRowCount(0) msg = qt.QMessageBox(self) msg.setIcon(qt.QMessageBox.Critical) msg.setText("%s" % sys.exc_info()[1]) msg.exec_()
[docs] def closeEvent(self, event): qt.QWidget.closeEvent(self, event) ddict = {} ddict['event'] = 'closed' self.sigClosed.emit(ddict)
def _submitThread(self, *var, **kw): message = "Calculating concentrations" sthread = SimpleThread(self.concentrationsTool.processFitResult, *var, **kw) sthread.start() msg = qt.QDialog(self, qt.Qt.FramelessWindowHint) msg.setModal(0) msg.setWindowTitle("Please Wait") layout = qt.QHBoxLayout(msg) layout.setContentsMargins(0, 0, 0, 0) layout.setSpacing(0) l1 = qt.QLabel(msg) l1.setFixedWidth(l1.fontMetrics().width('##')) l2 = qt.QLabel(msg) l2.setText("%s" % message) l3 = qt.QLabel(msg) l3.setFixedWidth(l3.fontMetrics().width('##')) layout.addWidget(l1) layout.addWidget(l2) layout.addWidget(l3) msg.show() qApp = qt.QApplication.instance() qApp.processEvents() i = 0 ticks = ['-', '\\', "|", "/", "-", "\\", '|', '/'] while (sthread.isRunning()): i = (i + 1) % 8 l1.setText(ticks[i]) l3.setText(" " + ticks[i]) qApp = qt.QApplication.instance() qApp.processEvents() time.sleep(1) msg.close() result = sthread._result del sthread self.raise_() return result
[docs]class SimpleThread(qt.QThread): def __init__(self, function, *var, **kw): if kw is None: kw = {} qt.QThread.__init__(self) self._function = function self._var = var self._kw = kw self._result = None
[docs] def run(self): if DEBUG: self._result = self._function(*self._var, **self._kw) else: try: self._result = self._function(*self._var, **self._kw) except: self._result = ("Exception",) + sys.exc_info()
[docs]class ConcentrationsWidget(qt.QWidget): sigConcentrationsWidgetSignal = qt.pyqtSignal(object) def __init__(self, parent=None, name="Concentrations"): qt.QWidget.__init__(self, parent) self.setWindowTitle(name) self._liveTime = None self.build() ddict = {} ddict['usematrix'] = 0 ddict['useattenuators'] = 1 ddict['usexrfmc'] = 0 ddict['flux'] = 1.0E10 ddict['time'] = 1.0 ddict['useautotime'] = 0 ddict['area'] = 30.0 ddict['distance'] = 10.0 ddict['reference'] = "Auto" ddict['mmolarflag'] = 0 self.setParameters(ddict)
[docs] def build(self): layout = qt.QVBoxLayout(self) layout.setContentsMargins(0, 0, 0, 0) layout.setSpacing(0) buttonGroup = qt.QGroupBox(self) buttonGroup.layout = qt.QVBoxLayout(buttonGroup) buttonGroup.layout.setContentsMargins(0, 0, 0, 0) buttonGroup.layout.setSpacing(0) layout.addWidget(buttonGroup) self.fluxCheckBox = qt.QCheckBox(buttonGroup) self.fluxCheckBox.setText("From fundamental parameters") wf = qt.QWidget(buttonGroup) wf.layout = qt.QHBoxLayout(wf) wf.layout.setContentsMargins(0, 0, 0, 0) wf.layout.setSpacing(0) wf.layout.addWidget(qt.HorizontalSpacer(wf)) self.fundamentalWidget = FundamentalWidget(wf) wf.layout.addWidget(self.fundamentalWidget) wf.layout.addWidget(qt.HorizontalSpacer(wf)) self.matrixCheckBox = qt.QCheckBox(buttonGroup) self.matrixCheckBox.setText("From matrix composition") self.fluxCheckBox.setChecked(True) wm = qt.QWidget(buttonGroup) wm.layout = qt.QHBoxLayout(wm) wm.layout.setContentsMargins(0, 0, 0, 0) wm.layout.setSpacing(0) wm.layout.addWidget(qt.HorizontalSpacer(wm)) referenceLabel = qt.QLabel(wm) wm.layout.addWidget(referenceLabel) referenceLabel.setText("Matrix Reference Element:") #self.referenceCombo=MyQComboBox(wm) #self.referenceCombo=qt.QComboBox(wm) #self.referenceCombo.setEditable(True) #self.referenceCombo.insertItem('Auto') self.referenceLine = MyQLineEdit(wm) wm.layout.addWidget(self.referenceLine) self.referenceLine.setFixedWidth( self.referenceLine.fontMetrics().width('#######')) wm.layout.addWidget(qt.HorizontalSpacer(wm)) self.referenceLine.sigMyQLineEditSignal.connect( \ self._referenceLineSlot) buttonGroup.layout.addWidget(self.fluxCheckBox) buttonGroup.layout.addWidget(wf) buttonGroup.layout.addWidget(self.matrixCheckBox) buttonGroup.layout.addWidget(wm) #self.fundamentalWidget.setEnabled(False) self.attenuatorsCheckBox = qt.QCheckBox(self) self.attenuatorsCheckBox.setText("Consider attenuators in calculations") self.attenuatorsCheckBox.setDisabled(True) #Multilayer secondary excitation self.secondaryCheckBox = qt.QCheckBox(self) self.secondaryCheckBox.setText("Consider secondary excitation") self.tertiaryCheckBox = qt.QCheckBox(self) self.tertiaryCheckBox.setText("Consider tertiary excitation") layout.addWidget(self.attenuatorsCheckBox) layout.addWidget(self.secondaryCheckBox) layout.addWidget(self.tertiaryCheckBox) #XRFMC secondary excitation if XRFMC_FLAG: self.xrfmcCheckBox = qt.QCheckBox(self) self.xrfmcCheckBox.setText("use Monte Carlo code to correct higher order excitations") layout.addWidget( self.xrfmcCheckBox) #mM checkbox self.mMolarCheckBox = qt.QCheckBox(self) self.mMolarCheckBox.setText("Elemental mM concentrations (assuming 1 l of solution is 1000 * matrix_density grams)") layout.addWidget(self.mMolarCheckBox) layout.addWidget(qt.VerticalSpacer(self)) buttonGroup.show() self.fluxCheckBox.clicked.connect(self._fluxCheckBoxSlot) self.matrixCheckBox.clicked.connect(self.checkBoxSlot) self.attenuatorsCheckBox.clicked.connect(self.checkBoxSlot) self.secondaryCheckBox.clicked.connect(self._secondaryCheckBoxSlot) self.tertiaryCheckBox.clicked.connect(self._tertiaryCheckBoxSlot) if XRFMC_FLAG: self.xrfmcCheckBox.clicked.connect(self._xrfmcCheckBoxSlot) self.mMolarCheckBox.clicked.connect(self.checkBoxSlot) self.fundamentalWidget.flux.sigMyQLineEditSignal.connect( \ self._mySignal) self.fundamentalWidget.area.sigMyQLineEditSignal.connect( \ self._mySignal) self.fundamentalWidget.time.sigMyQLineEditSignal.connect( \ self._mySignal) self.fundamentalWidget.distance.sigMyQLineEditSignal.connect( \ self._mySignal) self.fundamentalWidget.autoTimeCheckBox.clicked.connect( \ self.__autoTimeSlot)
def __autoTimeSlot(self): return self._autoTimeSlot() def _autoTimeSlot(self, signal=True): if self.fundamentalWidget.autoTimeCheckBox.isChecked(): if self._liveTime is None: self.fundamentalWidget.autoTimeCheckBox.setChecked(False) self.fundamentalWidget.time.setEnabled(True) else: self.fundamentalWidget.time.setText("%.6g" % self._liveTime) self.fundamentalWidget.time.setEnabled(False) if signal: self._mySignal() else: self.fundamentalWidget.time.setEnabled(True)
[docs] def setTimeFactor(self, factor=None, signal=False): self._liveTime = factor if factor is None: self.fundamentalWidget.autoTimeCheckBox.setChecked(False) self.fundamentalWidget.time.setEnabled(True) else: # act according to the settings self._autoTimeSlot(signal=signal)
def _fluxCheckBoxSlot(self): if self.fluxCheckBox.isChecked(): self.matrixCheckBox.setChecked(False) else: self.matrixCheckBox.setChecked(True) self.checkBoxSlot() def _secondaryCheckBoxSlot(self): if self.secondaryCheckBox.isChecked(): if XRFMC_FLAG: self.xrfmcCheckBox.setChecked(False) self.tertiaryCheckBox.setChecked(False) self.checkBoxSlot() def _tertiaryCheckBoxSlot(self): if self.tertiaryCheckBox.isChecked(): if XRFMC_FLAG: self.xrfmcCheckBox.setChecked(False) self.secondaryCheckBox.setChecked(False) self.checkBoxSlot() def _xrfmcCheckBoxSlot(self): if self.xrfmcCheckBox.isChecked(): self.secondaryCheckBox.setChecked(False) self.checkBoxSlot()
[docs] def checkBoxSlot(self): if self.matrixCheckBox.isChecked(): self.fundamentalWidget.setInputDisabled(True) self.referenceLine.setEnabled(True) self.fluxCheckBox.setChecked(False) else: self.fundamentalWidget.setInputDisabled(False) self.referenceLine.setEnabled(False) self.fluxCheckBox.setChecked(True) self._mySignal()
def _referenceLineSlot(self, ddict): if ddict['event'] == "returnPressed": current = str(self.referenceLine.text()) current = current.replace(' ', '') if (current == '') or (current.upper() == 'AUTO'): pass elif len(current) == 2: current = current.upper()[0] + current.lower()[1] elif len(current) == 1: current = current.upper()[0] else: self.referenceLine.setText('Auto') msg = qt.QMessageBox(self.referenceLine) msg.setIcon(qt.QMessageBox.Critical) msg.setText("Invalid Element %s" % current) msg.exec_() self.referenceLine.setFocus() return if (current == '') or (current.upper() == 'AUTO'): self.referenceLine.setText('Auto') self._mySignal() elif not Elements.isValidFormula(current): self.referenceLine.setText('Auto') msg = qt.QMessageBox(self.referenceLine) msg.setIcon(qt.QMessageBox.Critical) msg.setText("Invalid Element %s" % current) msg.exec_() self.referenceLine.setFocus() else: self.referenceLine.setText(current) self._mySignal() def _mySignal(self, dummy=None): ddict = self.getParameters() ddict['event'] = 'updated' self.sigConcentrationsWidgetSignal.emit(ddict)
[docs] def getParameters(self): ddict = {} if self.matrixCheckBox.isChecked(): ddict['usematrix'] = 1 else: ddict['usematrix'] = 0 if self.attenuatorsCheckBox.isChecked(): ddict['useattenuators'] = 1 else: ddict['useattenuators'] = 0 if self.tertiaryCheckBox.isChecked(): ddict['usemultilayersecondary'] = 2 elif self.secondaryCheckBox.isChecked(): ddict['usemultilayersecondary'] = 1 else: ddict['usemultilayersecondary'] = 0 ddict['usexrfmc'] = 0 if XRFMC_FLAG: if self.xrfmcCheckBox.isChecked(): ddict['usexrfmc'] = 1 if self.mMolarCheckBox.isChecked(): ddict['mmolarflag'] = 1 else: ddict['mmolarflag'] = 0 ddict['flux'] = float(str(self.fundamentalWidget.flux.text())) ddict['time'] = float(str(self.fundamentalWidget.time.text())) ddict['area'] = float(str(self.fundamentalWidget.area.text())) ddict['distance'] = float(str(self.fundamentalWidget.distance.text())) #ddict['reference'] = str(self.referenceCombo.currentText()) ddict['reference'] = str(self.referenceLine.text()) if self.fundamentalWidget.autoTimeCheckBox.isChecked(): ddict['useautotime'] = 1 if self._liveTime is None: #ddict["useautotime"] = 0 #self.fundamentalWidget.autoTimeCheckBox.setChecked(False) msg = qt.QMessageBox(self) msg.setIcon(qt.QMessageBox.Critical) msg.setText("Cannot use automatic concentrations time setting!!!") msg.exec_() else: ddict['time'] = float(self._liveTime) else: ddict['useautotime'] = 0 return ddict
[docs] def setParameters(self, ddict, signal=None): if signal is None: signal = True if 'usemultilayersecondary' in ddict: if ddict['usemultilayersecondary']: if ddict['usemultilayersecondary'] == 2: self.tertiaryCheckBox.setChecked(True) self.secondaryCheckBox.setChecked(False) else: self.tertiaryCheckBox.setChecked(False) self.secondaryCheckBox.setChecked(True) else: self.secondaryCheckBox.setChecked(False) self.tertiaryCheckBox.setChecked(False) else: self.secondaryCheckBox.setChecked(False) self.tertiaryCheckBox.setChecked(False) if XRFMC_FLAG: if 'usexrfmc' in ddict: if ddict['usexrfmc']: self.xrfmcCheckBox.setChecked(True) else: self.xrfmcCheckBox.setChecked(False) if 'mmolarflag' in ddict: if ddict['mmolarflag']: self.mMolarCheckBox.setChecked(True) else: self.mMolarCheckBox.setChecked(False) else: self.mMolarCheckBox.setChecked(False) usematrix = ddict.get('usematrix', False) if usematrix: self.fluxCheckBox.setChecked(False) self.matrixCheckBox.setChecked(True) else: self.fluxCheckBox.setChecked(True) self.matrixCheckBox.setChecked(False) ddict['useattenuators'] = 1 if ddict['useattenuators']: self.attenuatorsCheckBox.setChecked(True) else: self.attenuatorsCheckBox.setChecked(False) if 'reference' in ddict: #self.referenceCombo.setCurrentText(QString(ddict['reference'])) self.referenceLine.setText(QString(ddict['reference'])) else: #self.referenceCombo.setCurrentText(QString("Auto")) self.referenceLine.setText(QString("Auto")) self.fundamentalWidget.flux.setText("%.6g" % ddict['flux']) self.fundamentalWidget.area.setText("%.6g" % ddict['area']) self.fundamentalWidget.distance.setText("%.6g" % ddict['distance']) if ddict['time'] is not None: self.fundamentalWidget.time.setText("%.6g" % ddict['time']) autotime = ddict.get("useautotime", False) if autotime: self.fundamentalWidget.autoTimeCheckBox.setChecked(True) if self._liveTime is not None: self.fundamentalWidget.time.setText("%.6g" % self._liveTime) else: self.fundamentalWidget.autoTimeCheckBox.setChecked(False) if self.matrixCheckBox.isChecked(): self.fundamentalWidget.setInputDisabled(True) self.referenceLine.setEnabled(True) else: self.fundamentalWidget.setInputDisabled(False) self.referenceLine.setEnabled(False) if signal: self._mySignal()
[docs] def setReferenceOptions(self, options=None): if options is None: options = ['Auto'] old = self.referenceCombo.currentText() if 'Auto' not in options: options = ['Auto'] + options self.referenceCombo.clear() self.referenceCombo.insertStrList(options) if old in options: self.referenceCombo.setCurrentText(old) else: self.referenceCombo.setCurrentText('Auto')
[docs]class FundamentalWidget(qt.QWidget): def __init__(self, parent=None, name=""): qt.QWidget.__init__(self, parent) self.build()
[docs] def build(self, spacing=2): layout = qt.QHBoxLayout(self) layout.setContentsMargins(0, 0, 0, 0) layout.setSpacing(spacing) #column 0 c0 = qt.QWidget(self) c0.layout = qt.QVBoxLayout(c0) c0.layout.setContentsMargins(0, 0, 0, 0) c0.layout.setSpacing(spacing) c0l0 = qt.QLabel(c0) c0l0.setText("Flux (photons/s)") c0l1 = qt.QLabel(c0) c0l1.setText("Active Area (cm2)") c0.layout.addWidget(c0l0) c0.layout.addWidget(c0l1) #column 1 c1 = qt.QWidget(self) c1.layout = qt.QVBoxLayout(c1) c1.layout.setContentsMargins(0, 0, 0, 0) c1.layout.setSpacing(spacing) self.flux = MyQLineEdit(c1) self.flux.setValidator(qt.QDoubleValidator(self.flux)) self.area = MyQLineEdit(c1) self.area.setValidator(qt.QDoubleValidator(self.area)) c1.layout.addWidget(self.flux) c1.layout.addWidget(self.area) #column 2 c2 = qt.QWidget(self) c2.layout = qt.QVBoxLayout(c2) c2.layout.setContentsMargins(0, 0, 0, 0) c2.layout.setSpacing(spacing) c2l0 = qt.QLabel(c2) c2l0.setText("x time(seconds)") c2l1 = qt.QLabel(c2) c2l1.setText("distance (cm)") c2.layout.addWidget(c2l0) c2.layout.addWidget(c2l1) #column 3 c3 = qt.QWidget(self) c3.layout = qt.QGridLayout(c3) c3.layout.setContentsMargins(0, 0, 0, 0) c3.layout.setSpacing(spacing) self.time = MyQLineEdit(c3) self.time.setValidator(qt.QDoubleValidator(self.time)) self.autoTimeCheckBox = qt.QCheckBox(c3) self.autoTimeCheckBox.setText("Use Automatic Factor") self.autoTimeCheckBox.setChecked(False) self.autoTimeCheckBox.setToolTip("Attempt to read from the incoming data generating an error if factor not present") self.distance = MyQLineEdit(c3) self.distance.setValidator(qt.QDoubleValidator(self.distance)) c3.layout.addWidget(self.time, 0, 0) c3.layout.addWidget(self.autoTimeCheckBox, 0, 1) c3.layout.addWidget(self.distance, 1, 0) layout.addWidget(c0) layout.addWidget(c1) layout.addWidget(c2) layout.addWidget(c3)
[docs] def setInputDisabled(self, a=None): if a is None: a = True if a: self.flux.setEnabled(False) self.time.setEnabled(False) self.area.setEnabled(False) self.distance.setEnabled(False) else: self.flux.setEnabled(True) self.time.setEnabled(True) self.area.setEnabled(True) self.distance.setEnabled(True)
[docs]class ConcentrationsTable(QTable): def __init__(self, parent=None, **kw): QTable.__init__(self, parent) if 'labels' in kw: self.labels = [] for label in kw['labels']: self.labels.append(label) else: self.labels = ['Element', 'Group', 'Fit Area', 'Mass fraction'] self.setColumnCount(len(self.labels)) self.setRowCount(1) for i in range(len(self.labels)): item = self.horizontalHeaderItem(i) if item is None: item = qt.QTableWidgetItem(self.labels[i], qt.QTableWidgetItem.Type) self.setHorizontalHeaderItem(i, item) self.resizeColumnToContents(i)
[docs] def fillFromResult(self, result): if 'mmolar' in result: mmolarflag = True else: mmolarflag = False groupsList = result['groups'] nrows = len(groupsList) if nrows != self.rowCount(): self.setRowCount(nrows) if mmolarflag: self.labels = ['Element', 'Group', 'Fit Area', 'Sigma Area', 'mM concentration'] else: self.labels = ['Element', 'Group', 'Fit Area', 'Sigma Area', 'Mass fraction'] if 'layerlist' in result: for label in result['layerlist']: self.labels += [label] self.setColumnCount(len(self.labels)) for i in range(len(self.labels)): item = self.horizontalHeaderItem(i) if item is None: item = qt.QTableWidgetItem(self.labels[i], qt.QTableWidgetItem.Type) item.setText(self.labels[i]) self.setHorizontalHeaderItem(i, item) line = 0 for group in groupsList: element, group0 = group.split() # transitions = group0 + " xrays" fitarea = QString("%.6e" % (result['fitarea'][group])) sigmaarea = QString("%.2e" % (result['sigmaarea'][group])) area = QString("%.6e" % (result['area'][group])) if result['mass fraction'][group] < 0.0: fraction = QString("Unknown") else: if mmolarflag: fraction = QString("%.4g" % (result['mmolar'][group])) else: fraction = QString("%.4g" % (result['mass fraction'][group])) if line % 2: color = qt.QColor(255, 250, 205) else: color = qt.QColor('white') if 'Expected Area' in self.labels: fields = [element, group0, fitarea, sigmaarea, area, fraction] else: fields = [element, group0, fitarea, sigmaarea, fraction] if 'layerlist' in result: for layer in result['layerlist']: if result[layer]['mass fraction'][group] < 0.0: fraction = QString("Unknown") else: if mmolarflag: fraction = QString("%.4g" % (result[layer]['mmolar'][group])) else: fraction = QString("%.4g" % (result[layer]['mass fraction'][group])) fields += [fraction] col = 0 for field in fields: item = self.item(line, col) if item is None: item = qt.QTableWidgetItem(field, qt.QTableWidgetItem.Type) self.setItem(line, col, item) else: item.setText(field) item.setBackgroundColor(color) item.setFlags(qt.Qt.ItemIsSelectable | qt.Qt.ItemIsEnabled) col += 1 line += 1 for i in range(self.columnCount()): if (i > 1) and (i < 5): self.resizeColumnToContents(i)
[docs] def getHtmlText(self): lemon = ("#%x%x%x" % (255, 250, 205)).upper() white = "#FFFFFF" hcolor = ("#%x%x%x" % (230, 240, 249)).upper() text = "" text += ("<nobr>") text += ("<table>") text += ("<tr>") for l in range(self.columnCount()): text += ('<td align="left" bgcolor="%s"><b>' % hcolor) item = self.horizontalHeaderItem(l) text += str(item.text()) text += ("</b></td>") text += ("</tr>") #text+=( str(QString("</br>")) for r in range(self.rowCount()): text += ("<tr>") if r % 2: color = white b = "<b>" else: b = "<b>" color = lemon for c in range(self.columnCount()): moretext = "" item = self.item(r, c) if item is not None: moretext = str(item.text()) if len(moretext): finalcolor = color else: finalcolor = white if c < 2: text += ('<td align="left" bgcolor="%s">%s' % (finalcolor, b)) else: text += ('<td align="right" bgcolor="%s">%s' % (finalcolor, b)) text += moretext if len(b): text += ("</td>") else: text += ("</b></td>") moretext = "" item = self.item(r, 0) if item is not None: moretext = str(item.text()) if len(moretext): text += ("</b>") text += ("</tr>") text += ("\n") text += ("</table>") text += ("</nobr>") return text
[docs]class MyQLineEdit(qt.QLineEdit): sigMyQLineEditSignal = qt.pyqtSignal(object) def __init__(self, parent=None, name=None): qt.QLineEdit.__init__(self, parent) self.editingFinished[()].connect(self._mySignal) #TODO: Focus in to set yellow color, focus out to set white color def _mySignal(self): ddict = {} ddict['event'] = "returnPressed" self.sigMyQLineEditSignal.emit(ddict)
[docs]class MyQComboBox(qt.QComboBox): def __init__(self, parent=None, name=None, fl=0): qt.QComboBox.__init__(self, parent) self.setEditable(True) self._lineEdit = MyQLineEdit() self.setLineEdit(self._lineEdit) self._lineEdit.sigMyQLineEditSignal.connect(self._mySlot) def _mySlot(self, ddict): if ddict['event'] == "returnPressed": current = str(self.currentText()) current = current.replace(' ', '') if (current == '') or (current.upper() == 'AUTO'): pass elif len(current) == 2: current = current.upper()[0] + current.lower()[1] elif len(current) == 1: current = current.upper()[0] else: msg = qt.QMessageBox(self._lineEdit) msg.setIcon(qt.QMessageBox.Critical) msg.setText("Invalid Element %s" % current) msg.exec_() self._lineEdit.setFocus() if not Elements.isValidFormula(current): msg = qt.QMessageBox(self._lineEdit) msg.setIcon(qt.QMessageBox.Critical) msg.setText("Invalid Element %s" % current) msg.exec_() self._lineEdit.setFocus() else: self.setCurrentText(current)
if __name__ == "__main__": import getopt import copy # import sys # from PyMca5 import ConcentrationsTool from PyMca5.PyMcaIO import ConfigDict if len(sys.argv) > 1: options = '' longoptions = ['flux=', 'time=', 'area=', 'distance=', 'attenuators=', 'usematrix='] opts, args = getopt.getopt( sys.argv[1:], options, longoptions) app = qt.QApplication([]) app.lastWindowClosed.connect(app.quit) demo = Concentrations() config = demo.getParameters() for opt, arg in opts: if opt in ('--flux'): config['flux'] = float(arg) elif opt in ('--area'): config['area'] = float(arg) elif opt in ('--time'): config['time'] = float(arg) elif opt in ('--distance'): config['distance'] = float(arg) elif opt in ('--attenuators'): config['useattenuators'] = int(float(arg)) elif opt in ('--usematrix'): config['usematrix'] = int(float(arg)) demo.setParameters(config) filelist = args for file in filelist: d = ConfigDict.ConfigDict() d.read(file) for material in d['result']['config']['materials'].keys(): Elements.Material[material] = copy.deepcopy(d['result']['config']['materials'][material]) demo.processFitResult(fitresult=d, elementsfrommatrix=False) demo.show() app.exec_() else: print("Usage:") print("ConcentrationsWidget.py [--flux=xxxx --area=xxxx] fitresultfile")