def setValidators(self):
validatorRelaxa = DoubleValidator(self.lineEditRelaxationTimeFielda,
min=0.0)
validatorRelaxb = DoubleValidator(self.lineEditRelaxationTimeFieldb,
min=0.0)
self.lineEditRelaxationTimeFielda.setValidator(validatorRelaxa)
self.lineEditRelaxationTimeFieldb.setValidator(validatorRelaxb)
def setup(self, case):
"""
Setup the widget
"""
self.case = case
self.__boundary = None
self.case.undoStopGlobal()
# Connections
self.groupBoxMappedInlet.clicked[bool].connect(self.__slotMappedInlet)
self.lineEditTranslationX.textChanged[str].connect(self.__slotTrX)
self.lineEditTranslationY.textChanged[str].connect(self.__slotTrY)
self.lineEditTranslationZ.textChanged[str].connect(self.__slotTrZ)
# Validators
validatorX = DoubleValidator(self.lineEditTranslationX)
validatorY = DoubleValidator(self.lineEditTranslationY)
validatorZ = DoubleValidator(self.lineEditTranslationZ)
# Apply validators
self.lineEditTranslationX.setValidator(validatorX)
self.lineEditTranslationY.setValidator(validatorY)
self.lineEditTranslationZ.setValidator(validatorZ)
self.case.undoStartGlobal()
def setup(self, case):
self.case = case
self.case.undoStopGlobal()
self.mdl = DropletCondensationEvaporationModel(self.case)
self.modelYPlus = ComboModel(self.comboBoxYPlus, 3, 1)
self.modelYPlus.addItem(self.tr("Boundary cell center"), "center")
self.modelYPlus.addItem(self.tr("Y+ = "), "Yplus_value")
self.modelYPlus.addItem(self.tr("Droplets diameter"), "diameter")
# Validators
validatorYplus = DoubleValidator(self.lineEditYPlus, min=0.0)
validatorYplus.setExclusiveMin(True)
self.lineEditYPlus.setValidator(validatorYplus)
# Connect signals to slots
self.comboBoxYPlus.activated[str].connect(self.slotYPlus)
self.lineEditYPlus.textChanged[str].connect(self.slotYPlusValue)
isYPlus = self.mdl.getYPlusModel()
self.modelYPlus.setItem(str_model=isYPlus)
if isYPlus == "Yplus_value":
self.lineEditYPlus.show()
self.lineEditYPlus.setText(str(self.mdl.getYPlusValue()))
else:
self.lineEditYPlus.hide()
self.case.undoStartGlobal()
def __init__(self, parent):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_BoundaryConditionsTurbulenceInletForm.__init__(self)
self.setupUi(self)
# Connections
self.comboBoxTurbulence.activated[str].connect(
self.__slotChoiceTurbulence)
self.__modelTurbulence = ComboModel(self.comboBoxTurbulence, 3, 1)
self.__modelTurbulence.addItem(
self.tr("Calculation by hydraulic diameter"), 'hydraulic_diameter')
self.__modelTurbulence.addItem(
self.tr("Calculation by turbulent intensity"),
'turbulent_intensity')
self.__modelTurbulence.addItem(self.tr("Calculation by formula"),
'formula')
self.lineEditDiameter.textChanged[str].connect(self.__slotDiam)
self.lineEditIntensity.textChanged[str].connect(self.__slotIntensity)
self.lineEditDiameterIntens.textChanged[str].connect(self.__slotDiam)
self.pushButtonTurb.clicked.connect(self.__slotTurbulenceFormula)
validatorDiam = DoubleValidator(self.lineEditDiameter, min=0.)
validatorDiam.setExclusiveMin(True)
validatorIntensity = DoubleValidator(self.lineEditIntensity, min=0.)
self.lineEditDiameter.setValidator(validatorDiam)
self.lineEditDiameterIntens.setValidator(validatorDiam)
self.lineEditIntensity.setValidator(validatorIntensity)
def setup(self, case):
"""
Setup the widget
"""
self.case = case
self.__boundary = None
self.case.undoStopGlobal()
self.notebook = NotebookModel(self.case)
self.comboBoxTurbulence.activated[str].connect(self.__slotChoiceTurbulence)
self.__modelTurbulence = ComboModel(self.comboBoxTurbulence, 2, 1)
self.__modelTurbulence.addItem(self.tr("Calculation by hydraulic diameter"), 'hydraulic_diameter')
self.__modelTurbulence.addItem(self.tr("Calculation by turbulent intensity"), 'turbulent_intensity')
self.__modelTurbulence.addItem(self.tr("Calculation by formula"), 'formula')
self.lineEditDiameter.textChanged[str].connect(self.__slotDiam)
self.lineEditIntensity.textChanged[str].connect(self.__slotIntensity)
self.lineEditDiameterIntens.textChanged[str].connect(self.__slotDiam)
self.pushButtonTurb.clicked.connect(self.__slotTurbulenceFormula)
validatorDiam = DoubleValidator(self.lineEditDiameter, min=0.)
validatorDiam.setExclusiveMin(True)
validatorIntensity = DoubleValidator(self.lineEditIntensity, min=0.)
self.lineEditDiameter.setValidator(validatorDiam)
self.lineEditDiameterIntens.setValidator(validatorDiam)
self.lineEditIntensity.setValidator(validatorIntensity)
self.case.undoStartGlobal()
def createEditor(self, parent, option, index):
editor = QLineEdit(parent)
if self.turb.getTurbulenceModel() in ('LES_Smagorinsky', 'LES_dynamique', 'LES_WALE'):
validator = DoubleValidator(editor, min=0.95, max=1.)
else:
validator = DoubleValidator(editor, min=0., max=1.)
# validator.setExclusiveMin(True)
editor.setValidator(validator)
return editor
def __addValidators(self):
"""
Add the validator for NALIMX and EPALIM
"""
validatorNALIMX = IntValidator(self.lineEditNALIMX, min=1)
self.lineEditNALIMX.setValidator(validatorNALIMX)
validatorEPALIM = DoubleValidator(self.lineEditEPALIM, min=0.0)
validatorEPALIM.setExclusiveMin(True)
self.lineEditEPALIM.setValidator(validatorEPALIM)
def setup(self, case):
self.case = case
self.case.undoStopGlobal()
self.__model = ConjugateHeatTransferModel(self.case)
# Models
self.modelSyrthes = StandardItemModelSyrthes(self.__model)
self.tableViewSyrthes.setModel(self.modelSyrthes)
if QT_API == "PYQT4":
self.tableViewSyrthes.verticalHeader().setResizeMode(
QHeaderView.ResizeToContents)
self.tableViewSyrthes.horizontalHeader().setResizeMode(
QHeaderView.ResizeToContents)
self.tableViewSyrthes.horizontalHeader().setResizeMode(
1, QHeaderView.Stretch)
elif QT_API == "PYQT5":
self.tableViewSyrthes.verticalHeader().setSectionResizeMode(
QHeaderView.ResizeToContents)
self.tableViewSyrthes.horizontalHeader().setSectionResizeMode(
QHeaderView.ResizeToContents)
self.tableViewSyrthes.horizontalHeader().setSectionResizeMode(
1, QHeaderView.Stretch)
self.modelProjectionAxis = ComboModel(self.comboBoxProjectionAxis, 1,
1)
self.modelProjectionAxis.addItem("off")
self.modelProjectionAxis.addItem("x")
self.modelProjectionAxis.addItem("y")
self.modelProjectionAxis.addItem("z")
# connections
self.comboBoxProjectionAxis.currentTextChanged[str].connect(
self.slotProjectionAxis)
self.lineEditVerbosity.textChanged[str].connect(self.slotVerbosity)
self.lineEditVisualization.textChanged[str].connect(
self.slotVisualization)
self.lineEditTolerance.editingFinished.connect(self.slotTolerance)
self.lineEditVerbosity.setValidator(
IntValidator(self.lineEditVerbosity))
self.lineEditVisualization.setValidator(
IntValidator(self.lineEditVisualization))
_tolValidator = DoubleValidator(self.lineEditTolerance, min=0.)
_tolValidator.setExclusiveMin()
self.lineEditTolerance.setValidator(_tolValidator)
self.initializeParameters()
self.case.undoStartGlobal()
def __setValidator(self):
"""
Set the validator
"""
validator = DoubleValidator(self.lineEditDisplacementAlpha, min=0.0)
self.lineEditDisplacementAlpha.setValidator(validator)
validator = DoubleValidator(self.lineEditDisplacementBeta, min=0.0)
self.lineEditDisplacementBeta.setValidator(validator)
validator = DoubleValidator(self.lineEditStressAlpha, min=0.0)
self.lineEditStressAlpha.setValidator(validator)
def __init__(self, parent):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_BoundaryConditionsVelocityInletForm.__init__(self)
self.setupUi(self)
# Connections
self.comboBoxVelocity.activated[str].connect(self.__slotChoiceVelocity)
self.lineEditVelocity.textChanged[str].connect(self.__slotVelocityValue)
self.comboBoxDirection.activated[str].connect(self.__slotChoiceDirection)
# Combo models
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, 2, 1)
self.modelDirection.addItem(self.tr("Normal direction to the inlet"), 'normal')
self.modelDirection.addItem(self.tr("User profile"), 'formula')
# Validators
validatorVelocity = DoubleValidator(self.lineEditVelocity)
# Apply validators
self.lineEditVelocity.setValidator(validatorVelocity)
self.pushButtonVelocityFormula.clicked.connect(self.__slotVelocityFormula)
self.pushButtonDirectionFormula.clicked.connect(self.__slotDirectionFormula)
def __init__(self, parent):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_BoundaryConditionsInterfacialArea.__init__(self)
self.setupUi(self)
# Connections
self.lineEditDiameter.textChanged[str].connect(self.__slotDiameter)
validatorDiam = DoubleValidator(self.lineEditDiameter, min = 0.)
validatorDiam.setExclusiveMin(True)
self.lineEditDiameter.setValidator(validatorDiam)
def setup(self, case):
"""
Setup the widget
"""
self.case = case
self.__boundary = None
self.case.undoStopGlobal()
self.mdl = CompressibleModel(self.case)
# Connections
self.comboBoxTypeOutlet.activated[str].connect(self.slotOutletType)
self.lineEditPressure.textChanged[str].connect(self.slotPressureValue)
# Combo models
self.modelTypeOutlet = ComboModel(self.comboBoxTypeOutlet, 2, 1)
self.modelTypeOutlet.addItem(self.tr("supersonic outlet"),
'supersonic_outlet')
self.modelTypeOutlet.addItem(self.tr("subsonic outlet"),
'subsonic_outlet')
# Validators
validatorP = DoubleValidator(self.lineEditPressure, min=0.0)
# Apply validators
self.lineEditPressure.setValidator(validatorP)
self.case.undoStartGlobal()
def __init__(self, parent):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_BoundaryConditionsScalar.__init__(self)
self.setupUi(self)
# Connections
self.comboBoxScalar.activated[str].connect(self.__slotChoiceScalar)
self.__Scalarmodel = ComboModel(self.comboBoxScalar, 1, 1)
self.comboBoxScalarChoice.activated[str].connect(
self.slotScalarTypeChoice)
self.scalarChoiceModel = ComboModel(self.comboBoxScalarChoice, 1, 1)
self.scalarChoiceModel.addItem(self.tr("Value"), 'dirichlet')
self.scalarChoiceModel.addItem(self.tr("Flux"), 'flux')
self.lineEditScalar.textChanged[str].connect(self.__slotScalar)
validatorScalar = DoubleValidator(self.lineEditScalar)
self.lineEditScalar.setValidator(validatorScalar)
def createEditor(self, parent, option, index):
editor = QLineEdit(parent)
if index.column() == 3:
validator = DoubleValidator(editor, min=0., max=0.01)
validator.setExclusiveMin(True)
elif (index.column() == 2 or index.column() == 4):
validator = IntValidator(editor, min=1)
elif index.column() == 5:
validator = DoubleValidator(editor, min=0.)
validator.setExclusiveMin(True)
editor.setValidator(validator)
editor.installEventFilter(self)
return editor
def __init__(self, lineEdit, getter, setter):
"""
Constructor
"""
Coupling.__init__(self, lineEdit, getter, setter)
# Add validator.
validator = DoubleValidator(lineEdit)
lineEdit.setValidator(validator)
lineEdit.textChanged[str].connect(self.__slotTextChanged)
def createEditor(self, parent, option, index):
row = index.row()
stype = index.model().getData(row, 2)
editor = QLineEdit(parent)
if stype == 'time step':
validator = IntValidator(editor, min=1)
else:
validator = DoubleValidator(editor, min=0.)
editor.setValidator(validator)
return editor
def setup(self, case):
"""
Setup the widget.
"""
self.case = case
self.__boundary = None
self.__model = ElectricalModel(self.case)
self.species_list = []
self.notebook = NotebookModel(self.case)
self.lineEditValuePotElec.textChanged[str].connect(self.slotPotElec)
self.lineEditValuePotElecIm.textChanged[str].connect(
self.slotPotElecIm)
self.lineEditValueSpecies.textChanged[str].connect(self.slotSpecies)
self.pushButtonPotVectorFormula.clicked.connect(
self.slotPotVectorFormula)
self.pushButtonPotElecFormula.clicked.connect(self.slotPotElecFormula)
self.pushButtonPotElecImFormula.clicked.connect(
self.slotPotElecImFormula)
self.comboBoxTypePotElec.activated[str].connect(self.slotPotElecChoice)
self.comboBoxTypePotElecIm.activated[str].connect(
self.slotPotElecImChoice)
self.comboBoxTypePotVector.activated[str].connect(
self.slotPotVectorChoice)
self.comboBoxSpecies.activated[str].connect(self.slotSpeciesChoice)
self.comboBoxPotVector.activated[str].connect(
self.slotPotVectorComponentChoice)
## Validators
validatorPotElec = DoubleValidator(self.lineEditValuePotElec)
validatorPotElecIm = DoubleValidator(self.lineEditValuePotElecIm)
validatorSpecies = DoubleValidator(self.lineEditValueSpecies, min=0.)
self.lineEditValuePotElec.setValidator(validatorPotElec)
self.lineEditValuePotElecIm.setValidator(validatorPotElecIm)
self.lineEditValueSpecies.setValidator(validatorSpecies)
def __init__(self, parent):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_BoundaryConditionsWallRadiativeTransferForm.__init__(self)
self.setupUi(self)
validatorEmissivity = DoubleValidator(self.lineEditEmissivity, min=0.0)
self.lineEditEmissivity.setValidator(validatorEmissivity)
validatorConductivity = DoubleValidator(self.lineEditConductivity, min=0.0)
self.lineEditConductivity.setValidator(validatorConductivity)
validatorThickness = DoubleValidator(self.lineEditThickness, min=0.0)
self.lineEditThickness.setValidator(validatorThickness)
validatorExtTemperature = DoubleValidator(self.lineEditExtTemperature, min=0.0)
self.lineEditExtTemperature.setValidator(validatorExtTemperature)
validatorConductionFlux = DoubleValidator(self.lineEditConductionFlux, min=0.0)
self.lineEditConductionFlux.setValidator(validatorConductionFlux)
def __init__(self, parent):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_BoundaryConditionsNonCondensable.__init__(self)
self.setupUi(self)
# Connections
self.comboBoxNonCondensable.activated[str].connect(
self.__slotChoiceNonCondensable)
self.__NonCondensablemodel = ComboModel(self.comboBoxNonCondensable, 1,
1)
self.lineEditNonCondensable.textChanged[str].connect(
self.__slotNonCondensable)
validatorNonCond = DoubleValidator(self.lineEditNonCondensable, min=0.)
validatorNonCond.setExclusiveMin(False)
self.lineEditNonCondensable.setValidator(validatorNonCond)
def createEditor(self, parent, option, index):
editor = QLineEdit(parent)
if index.column() == 1 or index.column() == 2:
v = DoubleValidator(editor, min=0.)
v.setExclusiveMin(True)
else:
v = DoubleValidator(editor)
editor.setValidator(v)
return editor
def setup(self, case):
"""
Setup the widget
"""
self.case = case
self.__boundary = None
self.notebook = NotebookModel(self.case)
self.case.undoStopGlobal()
# Validators
validatorHh = DoubleValidator(self.lineEditValueHydraulicHead)
validatorExHh = DoubleValidator(self.lineEditExHydraulicHead)
# Apply validators
self.lineEditValueHydraulicHead.setValidator(validatorHh)
self.lineEditExHydraulicHead.setValidator(validatorHh)
self.modelTypeHydraulic = ComboModel(self.comboBoxTypeHydraulicHead, 1,
1)
self.modelTypeHydraulic.addItem(self.tr("Prescribed value"),
'dirichlet')
self.modelTypeHydraulic.addItem(
self.tr("Prescribed value (user law)"), 'dirichlet_formula')
self.modelTypeHydraulic.addItem(self.tr("Prescribed flux"), 'neumann')
# Connections
self.lineEditValueHydraulicHead.textChanged[str].connect(
self.slotHydraulicHeadValue)
self.lineEditExHydraulicHead.textChanged[str].connect(
self.slotHydraulicHeadFlux)
self.pushButtonHydraulicHead.clicked.connect(
self.slotHydraulicHeadFormula)
self.comboBoxTypeHydraulicHead.activated[str].connect(
self.slotHydraulicHeadChoice)
self.case.undoStartGlobal()
def setup(self, case):
"""
Setup the widget
"""
self.case = case
self.__boundary = None
self.case.undoStopGlobal()
self.groupBoxSliding.clicked[bool].connect(self.__slotSlidingWall)
self.lineEditSlideU.textChanged[str].connect(self.__slotVelocityU)
self.lineEditSlideV.textChanged[str].connect(self.__slotVelocityV)
self.lineEditSlideW.textChanged[str].connect(self.__slotVelocityW)
validatorSlideU = DoubleValidator(self.lineEditSlideU)
validatorSlideV = DoubleValidator(self.lineEditSlideV)
validatorSlideW = DoubleValidator(self.lineEditSlideW)
self.lineEditSlideU.setValidator(validatorSlideU)
self.lineEditSlideV.setValidator(validatorSlideV)
self.lineEditSlideW.setValidator(validatorSlideW)
self.case.undoStartGlobal()
def setup(self, case):
"""
Setup the widget
"""
self.case = case
self.__boundary = None
self.case.undoStopGlobal()
# Connections
self.lineEditPressure.textChanged[str].connect(self.slotPressureValue)
# Validators
validatorP = DoubleValidator(self.lineEditPressure, min=0.0)
# Apply validators
self.lineEditPressure.setValidator(validatorP)
self.case.undoStartGlobal()
def __init__(self, parent):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_BoundaryConditionsPressure.__init__(self)
self.setupUi(self)
# Connections
self.lineEditPressure.textChanged[str].connect(self.__slotPressure)
validatorPressure = DoubleValidator(self.lineEditPressure)
self.lineEditPressure.setValidator(validatorPressure)
self.comboBoxPressureMode.activated[str].connect(
self._slotChoicePressure)
self._modelPressure = ComboModel(self.comboBoxPressureMode, 2, 1)
def __init__(self, parent):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_BoundaryConditionsEnergy.__init__(self)
self.setupUi(self)
# Connections
self.comboBoxEnergy.activated[str].connect(self.__slotChoiceEnergy)
self.__modelEnergy = ComboModel(self.comboBoxEnergy, 1, 1)
self.lineEditEnergy.textChanged[str].connect(self.__slotEnergy)
validatorEner = DoubleValidator(self.lineEditEnergy)
self.lineEditEnergy.setValidator(validatorEner)
self.lineEditSyrthes.editingFinished.connect(self.__slotEnergySyrthes)
def setup(self, case):
"""
Setup the widget
"""
self.case = case
self.__boundary = None
self.case.undoStopGlobal()
self.radioButtonSmooth.clicked.connect(self.__slotRoughness)
self.radioButtonRough.clicked.connect(self.__slotRoughness)
self.lineEditRoughCoef.textChanged[str].connect(self.__slotRoughnessHeight)
validatorRoughCoef = DoubleValidator(self.lineEditRoughCoef)
self.lineEditRoughCoef.setValidator(validatorRoughCoef)
turb_mdl = TurbulenceModel(self.case)
if turb_mdl.getWallFunction() in [0, 1, 7]:
self.radioButtonRough.setEnabled(False)
self.case.undoStartGlobal()
def __init__(self, parent):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_BoundaryConditionsFraction.__init__(self)
self.setupUi(self)
self.__modelFraction = ComboModel(self.comboBoxFraction, 2, 1)
self.__modelFraction.addItem(self.tr("Imposed value"), 'dirichlet')
self.__modelFraction.addItem(self.tr("Automatic value"), 'automatic')
# Connections
self.lineEditFraction.textChanged[str].connect(self.__slotFraction)
self.comboBoxFraction.activated[str].connect(self.__slotChoiceFraction)
validatorFraction = DoubleValidator(self.lineEditFraction,
min=0.,
max=1.)
validatorFraction.setExclusiveMin(False)
validatorFraction.setExclusiveMax(False)
self.lineEditFraction.setValidator(validatorFraction)
def createEditor(self, parent, option, index):
editor = QLineEdit(parent)
v = DoubleValidator(editor)
editor.setValidator(v)
return editor
def setup(self, case):
"""
Setup the widget
"""
self.case = case
self.__boundary = None
self.case.undoStopGlobal()
self.notebook = NotebookModel(self.case)
# Connections
self.comboBoxTypeInlet.activated[str].connect(self.__slotInletType)
self.comboBoxVelocity.activated[str].connect(self.__slotChoiceVelocity)
self.lineEditVelocity.textChanged[str].connect(
self.__slotVelocityValue)
self.lineEditTemperature.textChanged[str].connect(
self.__slotTemperature)
self.spinBoxOxydantNumber.valueChanged[int].connect(
self.__slotOxydantNumber)
self.comboBoxDirection.activated[str].connect(
self.__slotChoiceDirection)
self.lineEditDirectionX.textChanged[str].connect(self.__slotDirX)
self.lineEditDirectionY.textChanged[str].connect(self.__slotDirY)
self.lineEditDirectionZ.textChanged[str].connect(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.pushButtonVelocityFormula.clicked.connect(
self.__slotVelocityFormula)
self.pushButtonDirectionFormula.clicked.connect(
self.__slotDirectionFormula)
# Useful information about coals, classes, and ratios
mdl = CoalCombustionModel.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 = FloatDelegate(self.tableViewCoal, minVal=0.)
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 = FloatDelegate(self.tableViewCoalMass, minVal=0.)
for c in range(self.__modelCoalMass.columnCount()):
self.tableViewCoalMass.setItemDelegateForColumn(
c, delegateValueMass)
self.case.undoStartGlobal()
def _setValidators(self):
validatorIJNBP = IntValidator(self.lineEditIJNBP, min=0)
validatorIJFRE = IntValidator(self.lineEditIJFRE, min=0)
validatorICLST = IntValidator(self.lineEditICLST, min=0)
validatorIDEBT = DoubleValidator(self.lineEditIDEBT, min=0.)
validatorIPOIT = DoubleValidator(self.lineEditIPOIT, min=0.)
validatorIPOIT.setExclusiveMin(True)
validatorIROPT = DoubleValidator(self.lineEditIROPT, min=0.)
validatorIROPT.setExclusiveMin(True)
validatorIRCOLM = DoubleValidator(self.lineEditIRCOLM, min=0.)
validatorIUNO = DoubleValidator(self.lineEditIUNO)
validatorIUPT = DoubleValidator(self.lineEditIUPT)
validatorIVPT = DoubleValidator(self.lineEditIVPT)
validatorIWPT = DoubleValidator(self.lineEditIWPT)
validatorITPT = DoubleValidator(self.lineEditITPT)
validatorICPT = DoubleValidator(self.lineEditICPT)
validatorIEPSI = DoubleValidator(self.lineEditIEPSI)
validatorIDPT = DoubleValidator(self.lineEditIDPT, min=0.)
validatorIVDPT = DoubleValidator(self.lineEditIVDPT)
validatorINUCHL = IntValidator(self.lineEditINUCHL, min=0)
validatorIHPT = DoubleValidator(self.lineEditIHPT)
self.lineEditIJNBP.setValidator(validatorIJNBP)
self.lineEditIJFRE.setValidator(validatorIJFRE)
self.lineEditICLST.setValidator(validatorICLST)
self.lineEditIDEBT.setValidator(validatorIDEBT)
self.lineEditIPOIT.setValidator(validatorIPOIT)
self.lineEditIROPT.setValidator(validatorIROPT)
self.lineEditIRCOLM.setValidator(validatorIRCOLM)
self.lineEditIUNO.setValidator(validatorIUNO)
self.lineEditIUPT.setValidator(validatorIUPT)
self.lineEditIVPT.setValidator(validatorIVPT)
self.lineEditIWPT.setValidator(validatorIWPT)
self.lineEditITPT.setValidator(validatorITPT)
self.lineEditICPT.setValidator(validatorICPT)
self.lineEditIEPSI.setValidator(validatorIEPSI)
self.lineEditIDPT.setValidator(validatorIDPT)
self.lineEditIVDPT.setValidator(validatorIVDPT)
self.lineEditINUCHL.setValidator(validatorINUCHL)
self.lineEditIHPT.setValidator(validatorIHPT)
