class BoundaryConditionsCoalInletView(QWidget, Ui_BoundaryConditionsCoalInletForm):
def __init__(self, parent):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_BoundaryConditionsCoalInletForm.__init__(self)
self.setupUi(self)
def setup(self, case):
"""
Setup the widget
"""
self.__case = case
self.__boundary = None
self.__case.undoStopGlobal()
# Connections
self.connect(self.comboBoxTypeInlet,
SIGNAL("activated(const QString&)"),
self.__slotInletType)
self.connect(self.comboBoxVelocity,
SIGNAL("activated(const QString&)"),
self.__slotChoiceVelocity)
self.connect(self.lineEditVelocity,
SIGNAL("textChanged(const QString &)"),
self.__slotVelocityValue)
self.connect(self.lineEditTemperature,
SIGNAL("textChanged(const QString &)"),
self.__slotTemperature)
self.connect(self.spinBoxOxydantNumber,
SIGNAL("valueChanged(int)"),
self.__slotOxydantNumber)
self.connect(self.comboBoxDirection,
SIGNAL("activated(const QString&)"),
self.__slotChoiceDirection)
self.connect(self.lineEditDirectionX,
SIGNAL("textChanged(const QString &)"),
self.__slotDirX)
self.connect(self.lineEditDirectionY,
SIGNAL("textChanged(const QString &)"),
self.__slotDirY)
self.connect(self.lineEditDirectionZ,
SIGNAL("textChanged(const QString &)"),
self.__slotDirZ)
# Combo models
self.modelTypeInlet = ComboModel(self.comboBoxTypeInlet, 2, 1)
self.modelTypeInlet.addItem(self.tr("only oxydant"), 'oxydantFlow')
self.modelTypeInlet.addItem(self.tr("oxydant and coal"), 'coalFlow')
self.modelVelocity = ComboModel(self.comboBoxVelocity, 4, 1)
self.modelVelocity.addItem(self.tr("norm"), 'norm')
self.modelVelocity.addItem(self.tr("mass flow rate"), 'flow1')
self.modelVelocity.addItem(self.tr("norm (user law)"), 'norm_formula')
self.modelVelocity.addItem(self.tr("mass flow rate (user law)"), 'flow1_formula')
self.modelDirection = ComboModel(self.comboBoxDirection, 3, 1)
self.modelDirection.addItem(self.tr("normal to the inlet"), 'normal')
self.modelDirection.addItem(self.tr("specified coordinates"), 'coordinates')
self.modelDirection.addItem(self.tr("user profile"), 'formula')
# Validators
validatorVelocity = DoubleValidator(self.lineEditVelocity)
validatorX = DoubleValidator(self.lineEditDirectionX)
validatorY = DoubleValidator(self.lineEditDirectionY)
validatorZ = DoubleValidator(self.lineEditDirectionZ)
validatorTemp = DoubleValidator(self.lineEditTemperature, min=0.)
# Apply validators
self.lineEditVelocity.setValidator(validatorVelocity)
self.lineEditDirectionX.setValidator(validatorX)
self.lineEditDirectionY.setValidator(validatorY)
self.lineEditDirectionZ.setValidator(validatorZ)
self.lineEditTemperature.setValidator(validatorTemp)
self.connect(self.pushButtonVelocityFormula,
SIGNAL("clicked()"),
self.__slotVelocityFormula)
self.connect(self.pushButtonDirectionFormula,
SIGNAL("clicked()"),
self.__slotDirectionFormula)
# Useful information about coals, classes, and ratios
mdl = CoalCombustion.CoalCombustionModel(self.__case)
if mdl.getCoalCombustionModel() != "off":
self.__coalNumber = mdl.getCoalNumber()
self.__coalClassesNumber = []
for coal in range(0, self.__coalNumber):
self.__coalClassesNumber.append(mdl.getClassNumber(str(coal+1)))
self.__maxOxydantNumber = mdl.getOxidantNumber()
else:
self.__coalNumber = 0
self.__coalClassesNumber = [0]
self.__maxOxydantNumber = 1
self.__ratio = self.__coalNumber*[0]
for i in range(0, self.__coalNumber):
self.__ratio[i] = self.__coalClassesNumber[i]*[0]
# Coal table
self.__modelCoal = StandardItemModelCoal(self.__case)
self.tableViewCoal.setModel(self.__modelCoal)
delegateValue = ValueDelegate(self.tableViewCoal)
self.tableViewCoal.setItemDelegateForColumn(1, delegateValue)
self.tableViewCoal.setItemDelegateForColumn(2, delegateValue)
# Coal mass ratio table
self.__modelCoalMass = StandardItemModelCoalMass(self.__case,
self.__coalNumber,
self.__coalClassesNumber)
self.tableViewCoalMass.setModel(self.__modelCoalMass)
delegateValueMass = ValueDelegate(self.tableViewCoalMass)
for c in range(self.__modelCoalMass.columnCount()):
self.tableViewCoalMass.setItemDelegateForColumn(c, delegateValueMass)
self.__case.undoStartGlobal()
def showWidget(self, b):
"""
Show the widget
"""
label = b.getLabel()
self.__boundary = Boundary('coal_inlet', label, self.__case)
# Initialize velocity
choice = self.__boundary.getVelocityChoice()
self.modelVelocity.setItem(str_model=choice)
self.__updateLabel()
if choice[-7:] == "formula":
self.pushButtonVelocityFormula.setEnabled(True)
self.lineEditVelocity.setEnabled(False)
else:
self.pushButtonVelocityFormula.setEnabled(False)
self.lineEditVelocity.setEnabled(True)
v = self.__boundary.getVelocity()
self.lineEditVelocity.setText(str(v))
# Initialize oxydant and temperature
self.spinBoxOxydantNumber.setMaximum(self.__maxOxydantNumber)
o = self.__boundary.getOxydantNumber()
self.spinBoxOxydantNumber.setValue(o)
t = self.__boundary.getOxydantTemperature()
self.lineEditTemperature.setText(str(t))
# Initialize direction
choice = self.__boundary.getDirectionChoice()
self.modelDirection.setItem(str_model=choice)
text = self.modelDirection.dicoM2V[choice]
if choice == "formula":
self.pushButtonDirectionFormula.setEnabled(True)
self.frameDirectionCoordinates.hide()
elif choice == "coordinates":
self.pushButtonDirectionFormula.setEnabled(False)
self.frameDirectionCoordinates.show()
v = self.__boundary.getDirection('direction_x')
self.lineEditDirectionX.setText(str(v))
v = self.__boundary.getDirection('direction_y')
self.lineEditDirectionY.setText(str(v))
v = self.__boundary.getDirection('direction_z')
self.lineEditDirectionZ.setText(str(v))
elif choice == "normal":
self.pushButtonDirectionFormula.setEnabled(False)
self.frameDirectionCoordinates.hide()
log.debug("showWidget:inlet type: %s " % self.__boundary.getInletType())
if self.__boundary.getInletType() == "coalFlow":
self.modelTypeInlet.setItem(str_model="coalFlow")
self.groupBoxCoal.show()
self.groupBoxCoalMass.show()
self.__updateTables()
self.__boundary.setInletType("coalFlow")
else:
self.__boundary.setInletType("oxydantFlow")
self.modelTypeInlet.setItem(str_model="oxydantFlow")
self.groupBoxCoal.hide()
self.groupBoxCoalMass.hide()
self.show()
def hideWidget(self):
"""
Hide all
"""
self.hide()
def __updateTables(self):
"""
Insert rows in the two QTableView.
"""
# clean the QTableView
self.__modelCoal.deleteAll()
self.__modelCoalMass.deleteAll()
label = self.__boundary.getLabel()
self.__modelCoalMass.setBoundaryFromLabel(label)
self.__modelCoal.setBoundaryFromLabel(label)
# fill the flow and temperature of the coal
for coal in range(0, self.__coalNumber):
self.__modelCoal.insertItem(self.tr("Coal ") + " " + str(coal+1),
self.__boundary.getCoalFlow(coal),
self.__boundary.getCoalTemperature(coal))
# fill the ratio of mass for each class for each coal
for coal in range(0, self.__coalNumber) :
lastValue = 0.
for coalClass in range(0, self.__coalClassesNumber[coal]-1):
lst = self.__boundary.getCoalRatios(coal)
lastValue += lst[coalClass]
self.__ratio[coal][coalClass] = lst[coalClass]
# last class is computed in order to assure that sum is egal to 100%
coalClass = self.__coalClassesNumber[coal]-1
lastValue = 100 - lastValue
self.__ratio[coal][coalClass] = lastValue
self.__modelCoalMass.setRatio(self.__ratio)
@pyqtSignature("const QString&")
def __slotChoiceVelocity(self, text):
"""
Private slot.
Input the velocity boundary type choice (norm, ).
@type text: C{QString}
@param text: velocity boundary type choice.
"""
c = self.modelVelocity.dicoV2M[str(text)]
log.debug("slotChoiceVelocity: %s " % c)
self.__boundary.setVelocityChoice(c)
if c[-7:] == "formula":
self.pushButtonVelocityFormula.setEnabled(True)
setGreenColor(self.pushButtonVelocityFormula, True)
self.lineEditVelocity.setEnabled(False)
self.lineEditVelocity.setText("")
else:
self.pushButtonVelocityFormula.setEnabled(False)
setGreenColor(self.pushButtonVelocityFormula, False)
self.lineEditVelocity.setEnabled(True)
v = self.__boundary.getVelocity()
self.lineEditVelocity.setText(str(v))
self.__updateLabel()
def __updateLabel(self):
"""
Update the unit for the velocity specification.
"""
c = self.__boundary.getVelocityChoice()
if c in ('norm', 'norm_formula'):
self.labelUnitVelocity.setText(str('m/s'))
elif c in ('flow1', 'flow1_formula'):
self.labelUnitVelocity.setText(str('kg/s'))
elif c in ('flow2', 'flow2_formula'):
self.labelUnitVelocity.setText(str('m<sup>3</sup>/s'))
@pyqtSignature("const QString&")
def __slotVelocityValue(self, text):
"""
Private slot.
New value associated to the velocity boundary type.
@type text: C{QString}
@param text: value
"""
if self.sender().validator().state == QValidator.Acceptable:
v = from_qvariant(text, float)
self.__boundary.setVelocity(v)
@pyqtSignature("")
def __slotVelocityFormula(self):
"""
"""
exp = self.__boundary.getVelocity()
c = self.__boundary.getVelocityChoice()
if c == 'norm_formula':
exa = "u_norm = 1.0;"
req = [('u_norm', 'Norm of the velocity')]
elif c == 'flow1_formula':
exa = "q_m = 1.0;"
req = [('q_m', 'mass flow rate')]
elif c == 'flow2_formula':
exa = "q_v = 1.0;"
req = [('q_v', 'volumic flow rate')]
sym = [('x', "X face's gravity center"),
('y', "Y face's gravity center"),
('z', "Z face's gravity center"),
('dt', 'time step'),
('t', 'current time'),
('iter', 'number of iteration')]
dialog = QMeiEditorView(self,
check_syntax = self.__case['package'].get_check_syntax(),
expression = exp,
required = req,
symbols = sym,
examples = exa)
if dialog.exec_():
result = dialog.get_result()
log.debug("slotFormulaVelocity -> %s" % str(result))
self.__boundary.setVelocity(result)
setGreenColor(self.pushButtonVelocityFormula, False)
@pyqtSignature("const QString&")
def __slotChoiceDirection(self, text):
"""
Input the direction type choice.
"""
c = self.modelDirection.dicoV2M[str(text)]
log.debug("slotChoiceVelocity: %s " % c)
self.__boundary.setDirectionChoice(c)
if c == "formula":
self.pushButtonDirectionFormula.setEnabled(True)
setGreenColor(self.pushButtonDirectionFormula, True)
self.frameDirectionCoordinates.hide()
elif c == "coordinates":
self.pushButtonDirectionFormula.setEnabled(False)
setGreenColor(self.pushButtonDirectionFormula, False)
self.frameDirectionCoordinates.show()
v = self.__boundary.getDirection('direction_x')
self.lineEditDirectionX.setText(str(v))
v = self.__boundary.getDirection('direction_y')
self.lineEditDirectionY.setText(str(v))
v = self.__boundary.getDirection('direction_z')
self.lineEditDirectionZ.setText(str(v))
elif c == "normal":
self.pushButtonDirectionFormula.setEnabled(False)
setGreenColor(self.pushButtonDirectionFormula, False)
self.frameDirectionCoordinates.hide()
@pyqtSignature("const QString&")
def __slotDirX(self, text):
"""
INPUT value into direction of inlet flow
"""
if self.sender().validator().state == QValidator.Acceptable:
value = from_qvariant(text, float)
self.__boundary.setDirection('direction_x', value)
@pyqtSignature("const QString&")
def __slotDirY(self, text):
"""
INPUT value into direction of inlet flow
"""
if self.sender().validator().state == QValidator.Acceptable:
value = from_qvariant(text, float)
self.__boundary.setDirection('direction_y', value)
@pyqtSignature("const QString&")
def __slotDirZ(self, text):
"""
INPUT value into direction of inlet flow
"""
if self.sender().validator().state == QValidator.Acceptable:
value = from_qvariant(text, float)
self.__boundary.setDirection('direction_z', value)
@pyqtSignature("")
def __slotDirectionFormula(self):
"""
"""
exp = self.__boundary.getDirection('direction_formula')
req = [('dir_x', 'Direction of the flow along X'),
('dir_y', 'Direction of the flow along Y'),
('dir_z', 'Direction of the flow along Z')]
exa = "dir_x = 3.0;\ndir_y = 1.0;\ndir_z = 0.0;\n"
sym = [('x', "X face's gravity center"),
('y', "Y face's gravity center"),
('z', "Z face's gravity center"),
('dt', 'time step'),
('t', 'current time'),
('iter', 'number of iteration')]
dialog = QMeiEditorView(self,
check_syntax = self.__case['package'].get_check_syntax(),
expression = exp,
required = req,
symbols = sym,
examples = exa)
if dialog.exec_():
result = dialog.get_result()
log.debug("slotFormulaDirection -> %s" % str(result))
self.__boundary.setDirection('direction_formula', result)
setGreenColor(self.pushButtonDirectionFormula, False)
@pyqtSignature("const QString&")
def __slotInletType(self, text):
"""
INPUT inlet type : 'oxydant' or 'oxydant + coal'
"""
value = self.modelTypeInlet.dicoV2M[str(text)]
log.debug("__slotInletType value = %s " % value)
self.__boundary.setInletType(value)
if value == 'oxydantFlow':
self.groupBoxCoal.hide()
self.groupBoxCoalMass.hide()
else:
self.groupBoxCoal.show()
self.groupBoxCoalMass.show()
self.__updateTables()
@pyqtSignature("const QString&")
def __slotTemperature(self, text):
if self.sender().validator().state == QValidator.Acceptable:
t = from_qvariant(text, float)
self.__boundary.setOxydantTemperature(t)
@pyqtSignature("int")
def __slotOxydantNumber(self, i):
self.__boundary.setOxydantNumber(i)
def getCoalNumber(self):
"""
Return the coal number
"""
return self.__coalNumber
def tr(self, text):
"""
Translation
"""
return text
class StandardItemModelCoalMass(QStandardItemModel):
def __init__(self, case, coalNumber, coalClassesNumber):
QStandardItemModel.__init__(self)
self.__case = case
self.coalNumber = coalNumber
self.coalClassesNumber = coalClassesNumber
def setRatio(self, ratio):
cols = len(ratio)
if type(ratio[0]) == type([]):
rows = max([len(c) for c in ratio])
else:
rows = 1
self.setColumnCount(cols)
self.setRowCount(rows)
self.ratio = ratio
def setBoundaryFromLabel(self, label):
log.debug("setBoundaryFromLabel")
self.modelBoundary = Boundary('coal_inlet', label, self.__case)
def data(self, index, role):
if not index.isValid():
return to_qvariant()
if role == Qt.DisplayRole:
classe = index.row()
coal = index.column()
if classe < self.coalClassesNumber[coal]:
try:
return to_qvariant(self.ratio[coal][classe])
except:
log.debug("ERROR no data for self.ratio[%i][%i] "%(coal, classe))
return to_qvariant()
def flags(self, index):
if not index.isValid():
return Qt.ItemIsEnabled
elif index.row() >= self.coalClassesNumber[index.column()]:
return Qt.ItemIsEnabled | Qt.ItemIsSelectable
else:
return Qt.ItemIsEnabled | Qt.ItemIsSelectable | Qt.ItemIsEditable
def headerData(self, section, orientation, role):
if orientation == Qt.Horizontal and role == Qt.DisplayRole:
return to_qvariant("Coal" + " " + str(section+1))
if orientation == Qt.Vertical and role == Qt.DisplayRole:
return to_qvariant("Class" + " " + str(section+1))
return to_qvariant()
def setData(self, index, value, role):
if not hasattr(self, "modelBoundary"):
log.debug("ERROR in setData (StandardItemModelCoalMass): no Boundary model defined")
return
classe = index.row()
coal = index.column()
v = from_qvariant(value, float)
self.ratio[coal][classe] = v
log.debug("setData v = %f "%v)
lst = self.modelBoundary.getCoalRatios(coal)
lastValue = 0
for iclasse in range(0, self.coalClassesNumber[coal]-1):
lastValue += self.ratio[coal][iclasse]
if lastValue < 100.+ 1e-6 :
lst[classe] = self.ratio[coal][classe]
lastValue = 100 - lastValue
self.ratio[coal][self.coalClassesNumber[coal]-1] = lastValue
lst[self.coalClassesNumber[coal]-1] = lastValue
self.modelBoundary.setCoalRatios(coal, lst)
else :
self.ratio[coal][classe] = lst[classe]
self.emit(SIGNAL("dataChanged(const QModelIndex &, const QModelIndex &)"), index, index)
return True
def deleteAll(self):
self.ratio = []
self.setRowCount(0)