def setup(self, case):
"""
Setup the widget
"""
self.__case = case
self.__boundary = None
self.__case.undoStopGlobal()
self.connect(self.comboBoxTurbulence, SIGNAL("activated(const QString&)"), 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.connect(self.lineEditDiameter, SIGNAL("textChanged(const QString &)"), self.__slotDiam)
self.connect(self.lineEditIntensity, SIGNAL("textChanged(const QString &)"), self.__slotIntensity)
self.connect(self.lineEditDiameterIntens, SIGNAL("textChanged(const QString &)"), self.__slotDiam)
self.connect(self.pushButtonTurb, SIGNAL("clicked()"), 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 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 __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 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)
editor.setValidator(validator)
editor.installEventFilter(self)
return editor
def __init__(self, parent, case):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_SteadyManagementForm.__init__(self)
self.setupUi(self)
self.case = case
self.case.undoStopGlobal()
self.mdl = SteadyManagementModel(self.case)
# Connections
self.connect(self.lineEditRELXST, SIGNAL("textChanged(const QString &)"), self.slotRelaxCoef)
self.connect(self.lineEditNTMABS, SIGNAL("textChanged(const QString &)"), self.slotNbIter)
self.connect(self.checkBoxINPDT0, SIGNAL("clicked()"), self.slotZeroIteration)
# Validators
validatorRELXST = DoubleValidator(self.lineEditRELXST, min=0.0, max=1.0)
validatorRELXST.setExclusiveMin(True)
self.lineEditRELXST.setValidator(validatorRELXST)
validatorNTMABS = IntValidator(self.lineEditNTMABS, min=0)
self.lineEditNTMABS.setValidator(validatorNTMABS)
# Initialization
relax_coef = self.mdl.getRelaxCoefficient()
self.lineEditRELXST.setText(str(relax_coef))
nb_iter = self.mdl.getNbIter()
self.lineEditNTMABS.setText(str(nb_iter))
if self.mdl.getZeroIteration() == 'on':
self.checkBoxINPDT0.setChecked(True)
else:
self.checkBoxINPDT0.setChecked(False)
self.case.undoStartGlobal()
def createEditor(self, parent, option, index):
editor = QLineEdit(parent)
v = DoubleValidator(editor, min=0.)
editor.setValidator(v)
#editor.installEventFilter(self)
return editor
def __init__(self, parent, case):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_FluidCharacteristicsForm.__init__(self)
self.setupUi(self)
self.case = case
self.case.undoStopGlobal()
self.mdl = FluidCharacteristicsModel(self.case)
if EOS == 1:
self.ava = eosAva.EosAvailable()
import cs_config
cfg = cs_config.config()
self.freesteam = 0
if cfg.libs['freesteam'].have != "no":
self.freesteam = 1
if CompressibleModel(self.case).getCompressibleModel() != 'off':
self.lst = [('density', 'Rho'),
('molecular_viscosity', 'Mu'),
('specific_heat', 'Cp'),
('thermal_conductivity', 'Al'),
('volume_viscosity', 'Viscv0'),
('dynamic_diffusion', 'Diftl0')]
elif CoalCombustionModel(self.case).getCoalCombustionModel() != 'off' or \
GasCombustionModel(self.case).getGasCombustionModel() != 'off':
self.lst = [('density', 'Rho'),
('molecular_viscosity', 'Mu'),
('specific_heat', 'Cp'),
('dynamic_diffusion', 'Diftl0')]
else:
self.lst = [('density', 'Rho'),
('molecular_viscosity', 'Mu'),
('specific_heat', 'Cp'),
('thermal_conductivity', 'Al')]
self.list_scalars = []
self.m_th = ThermalScalarModel(self.case)
s = self.m_th.getThermalScalarName()
mdl = self.m_th.getThermalScalarModel()
if mdl == "temperature_celsius":
self.list_scalars.append((s, self.tr("Thermal scalar: temperature (C)")))
elif mdl == "temperature_kelvin":
self.list_scalars.append((s, self.tr("Thermal scalar: temperature (K)")))
elif mdl != "off":
self.list_scalars.append((s, self.tr("Thermal scalar")))
self.m_sca = DefineUserScalarsModel(self.case)
for s in self.m_sca.getUserScalarNameList():
self.list_scalars.append((s, self.tr("Additional scalar")))
# Particular Widget initialization taking into account of "Calculation Features"
mdl_atmo, mdl_joule, mdl_thermal, mdl_gas, mdl_coal, mdl_comp = self.mdl.getThermoPhysicalModel()
# Combo models
self.modelRho = ComboModel(self.comboBoxRho, 3, 1)
self.modelMu = ComboModel(self.comboBoxMu, 3, 1)
self.modelCp = ComboModel(self.comboBoxCp, 3, 1)
self.modelAl = ComboModel(self.comboBoxAl, 3, 1)
self.modelDiff = ComboModel(self.comboBoxDiff, 2, 1)
self.modelNameDiff = ComboModel(self.comboBoxNameDiff,1,1)
self.modelViscv0 = ComboModel(self.comboBoxViscv0, 3, 1)
self.modelDiftl0 = ComboModel(self.comboBoxDiftl0, 3, 1)
self.modelMaterial = ComboModel(self.comboBoxMaterial, 1, 1)
self.modelMethod = ComboModel(self.comboBoxMethod, 1, 1)
self.modelPhas = ComboModel(self.comboBoxPhas, 2, 1)
self.modelRho.addItem(self.tr('constant'), 'constant')
self.modelRho.addItem(self.tr('variable'), 'variable')
self.modelRho.addItem(self.tr('thermal law'), 'thermal_law')
if mdl_atmo != 'off':
self.modelRho.addItem(self.tr('defined in atphyv'), 'variable')
elif mdl_joule == 'arc':
self.modelRho.addItem(self.tr('defined in elphyv'), 'variable')
self.modelMu.addItem(self.tr('constant'), 'constant')
self.modelMu.addItem(self.tr('variable'), 'variable')
self.modelMu.addItem(self.tr('thermal law'), 'thermal_law')
if mdl_joule == 'arc':
self.modelMu.addItem(self.tr('defined in elphyv'), 'variable')
self.modelCp.addItem(self.tr('constant'), 'constant')
self.modelCp.addItem(self.tr('variable'), 'variable')
self.modelCp.addItem(self.tr('thermal law'), 'thermal_law')
if mdl_joule == 'arc':
self.modelCp.addItem(self.tr('defined in elphyv'), 'variable')
self.modelAl.addItem(self.tr('constant'), 'constant')
self.modelAl.addItem(self.tr('variable'), 'variable')
self.modelAl.addItem(self.tr('thermal law'), 'thermal_law')
if mdl_joule == 'arc':
self.modelAl.addItem(self.tr('defined in elphyv'), 'variable')
self.modelDiff.addItem(self.tr('constant'), 'constant')
self.modelDiff.addItem(self.tr('variable'), 'variable')
self.modelViscv0.addItem(self.tr('constant'), 'constant')
self.modelViscv0.addItem(self.tr('variable'), 'variable')
self.modelViscv0.addItem(self.tr('thermal law'), 'thermal_law')
self.modelDiftl0.addItem(self.tr('constant'), 'constant')
self.modelDiftl0.addItem(self.tr('variable'), 'variable')
self.modelDiftl0.addItem(self.tr('thermal law'), 'thermal_law')
self.modelPhas.addItem(self.tr('liquid'), 'liquid')
self.modelPhas.addItem(self.tr('gas'), 'gas')
if (self.freesteam == 0 and EOS == 0) or \
self.m_th.getThermalScalarModel() == "off" or \
mdl_joule != 'off' or mdl_comp != 'off':
self.groupBoxTableChoice.hide()
else:
self.groupBoxTableChoice.show()
self.lineEditReference.setEnabled(False)
# suppress perfect gas
self.modelMaterial.addItem(self.tr('user material'), 'user_material')
tmp = ["Argon", "Nitrogen", "Hydrogen", "Oxygen", "Helium", "Air"]
if EOS == 1:
fls = self.ava.whichFluids()
for fli in fls:
if fli not in tmp:
tmp.append(fli)
self.modelMaterial.addItem(self.tr(fli), fli)
if self.freesteam == 1 and EOS == 0:
self.modelMaterial.addItem(self.tr('Water'), 'Water')
material = self.mdl.getMaterials()
self.modelMaterial.setItem(str_model=material)
self.updateMethod()
self.scalar = ""
scalar_list = self.m_sca.getUserScalarNameList()
for s in self.m_sca.getScalarsVarianceList():
if s in scalar_list: scalar_list.remove(s)
if scalar_list != []:
self.scalar = scalar_list[0]
for scalar in scalar_list:
self.modelNameDiff.addItem(scalar)
# Connections
self.connect(self.comboBoxRho, SIGNAL("activated(const QString&)"), self.slotStateRho)
self.connect(self.comboBoxMu, SIGNAL("activated(const QString&)"), self.slotStateMu)
self.connect(self.comboBoxCp, SIGNAL("activated(const QString&)"), self.slotStateCp)
self.connect(self.comboBoxAl, SIGNAL("activated(const QString&)"), self.slotStateAl)
self.connect(self.comboBoxDiff, SIGNAL("activated(const QString&)"), self.slotStateDiff)
self.connect(self.comboBoxNameDiff, SIGNAL("activated(const QString&)"), self.slotNameDiff)
self.connect(self.comboBoxViscv0, SIGNAL("activated(const QString&)"), self.slotStateViscv0)
self.connect(self.comboBoxMaterial, SIGNAL("activated(const QString&)"), self.slotMaterial)
self.connect(self.comboBoxMethod, SIGNAL("activated(const QString&)"), self.slotMethod)
self.connect(self.comboBoxPhas, SIGNAL("activated(const QString&)"), self.slotPhas)
self.connect(self.lineEditRho, SIGNAL("textChanged(const QString &)"), self.slotRho)
self.connect(self.lineEditMu, SIGNAL("textChanged(const QString &)"), self.slotMu)
self.connect(self.lineEditCp, SIGNAL("textChanged(const QString &)"), self.slotCp)
self.connect(self.lineEditAl, SIGNAL("textChanged(const QString &)"), self.slotAl)
self.connect(self.lineEditDiff, SIGNAL("textChanged(const QString &)"), self.slotDiff)
self.connect(self.lineEditDiftl0, SIGNAL("textChanged(const QString &)"), self.slotDiftl0)
self.connect(self.lineEditViscv0, SIGNAL("textChanged(const QString &)"), self.slotViscv0)
self.connect(self.pushButtonRho, SIGNAL("clicked()"), self.slotFormulaRho)
self.connect(self.pushButtonMu, SIGNAL("clicked()"), self.slotFormulaMu)
self.connect(self.pushButtonCp, SIGNAL("clicked()"), self.slotFormulaCp)
self.connect(self.pushButtonAl, SIGNAL("clicked()"), self.slotFormulaAl)
self.connect(self.pushButtonDiff, SIGNAL("clicked()"), self.slotFormulaDiff)
self.connect(self.pushButtonViscv0, SIGNAL("clicked()"), self.slotFormulaViscv0)
# Validators
validatorRho = DoubleValidator(self.lineEditRho, min = 0.0)
validatorMu = DoubleValidator(self.lineEditMu, min = 0.0)
validatorCp = DoubleValidator(self.lineEditCp, min = 0.0)
validatorAl = DoubleValidator(self.lineEditAl, min = 0.0)
validatorDiff = DoubleValidator(self.lineEditDiff, min = 0.0)
validatorViscv0 = DoubleValidator(self.lineEditViscv0, min = 0.0)
validatorDiftl0 = DoubleValidator(self.lineEditDiftl0, min = 0.0)
validatorRho.setExclusiveMin(True)
validatorMu.setExclusiveMin(True)
validatorCp.setExclusiveMin(True)
validatorAl.setExclusiveMin(True)
validatorDiff.setExclusiveMin(True)
validatorDiftl0.setExclusiveMin(True)
self.lineEditRho.setValidator(validatorRho)
self.lineEditMu.setValidator(validatorMu)
self.lineEditCp.setValidator(validatorCp)
self.lineEditAl.setValidator(validatorAl)
self.lineEditDiff.setValidator(validatorDiff)
self.lineEditViscv0.setValidator(validatorViscv0)
self.lineEditDiftl0.setValidator(validatorDiftl0)
if scalar_list == []:
self.groupBoxDiff.hide()
else :
self.groupBoxDiff.show()
self.lineEditDiff.setText(str(self.m_sca.getScalarDiffusivityInitialValue(self.scalar)))
diff_choice = self.m_sca.getScalarDiffusivityChoice(self.scalar)
self.modelDiff.setItem(str_model=diff_choice)
self.modelNameDiff.setItem(str_model=str(self.scalar))
if diff_choice != 'variable':
self.pushButtonDiff.setEnabled(False)
setGreenColor(self.pushButtonDiff, False)
else:
self.pushButtonDiff.setEnabled(True)
setGreenColor(self.pushButtonDiff, True)
#compressible
self.groupBoxViscv0.hide()
# combustion
self.groupBoxDiftl0.hide()
# Standard Widget initialization
for tag, symbol in self.lst:
__model = getattr(self, "model" + symbol)
__line = getattr(self, "lineEdit" + symbol)
__button = getattr(self, "pushButton" + symbol)
__label = getattr(self, "label" + symbol)
__labelu = getattr(self, "labelUnit" + symbol)
if tag != 'dynamic_diffusion':
__labelv = getattr(self, "labelVar" + symbol)
c = self.mdl.getPropertyMode(tag)
__model.setItem(str_model=c)
if c == 'variable':
__button.setEnabled(True)
__label.setText(self.tr("Reference value"))
else:
__button.setEnabled(False)
__label.setText(self.tr("Reference value"))
if c == 'thermal_law':
__line.hide()
__label.hide()
__labelu.hide()
__labelv.hide()
else:
__line.show()
__label.show()
__labelu.show()
__labelv.show()
if self.mdl.getMaterials() == "user_material":
__model.disableItem(str_model='thermal_law')
else:
__model.enableItem(str_model='thermal_law')
else:
__label.setText(self.tr("Reference value"))
self.mdl.getInitialValue(tag)
__line.setText(str(self.mdl.getInitialValue(tag)))
# no 'thermal_conductivity' if not Joule and not Thermal scalar and not
if mdl_joule == 'off' and mdl_thermal == 'off' and mdl_atmo == 'off' and\
CompressibleModel(self.case).getCompressibleModel() == 'off':
self.groupBoxAl.hide()
if mdl_gas != 'off' or mdl_coal != 'off':
self.groupBoxDiftl0.show()
for tag, symbol in self.lst:
__model = getattr(self, "model" + symbol)
__line = getattr(self, "lineEdit" + symbol)
__button = getattr(self, "pushButton" + symbol)
__label = getattr(self, "label" + symbol)
__combo = getattr(self, "comboBox" + symbol)
# Gas or coal combustion
if mdl_gas != 'off' or mdl_coal != 'off':
if tag == 'density':
__model.setItem(str_model='variable')
__combo.setEnabled(False)
__button.setEnabled(False)
self.mdl.setPropertyMode(tag, 'variable')
__label.setText(self.tr("Calculation by\n perfect gas law"))
__line.setText(str(""))
__line.setEnabled(False)
elif tag == 'dynamic_diffusion':
__model.setItem(str_model='variable')
__combo.setEnabled(False)
__button.setEnabled(False)
else:
__model.setItem(str_model='constant')
self.mdl.setPropertyMode(tag, 'constant')
# Joule
if mdl_joule == 'arc':
__model.disableItem(str_model='constant')
__model.disableItem(str_model='variable')
__model.setItem(str_model='variable')
__combo.setEnabled(False)
__button.setEnabled(False)
self.mdl.setPropertyMode(tag, 'variable')
if mdl_joule == 'joule':
__model.setItem(str_model='variable')
__model.disableItem(str_model='constant')
self.mdl.setPropertyMode(tag, 'variable')
# Atmospheric Flows
if mdl_atmo != 'off':
if tag == 'density':
__model.disableItem(str_model='constant')
__model.disableItem(str_model='variable')
__model.setItem(str_model='variable')
__combo.setEnabled(False)
__button.setEnabled(False)
# Compressible Flows
if mdl_comp != 'off':
if tag == 'density':
__model.setItem(str_model='variable')
__combo.setEnabled(False)
__button.setEnabled(False)
__combo.hide()
__button.hide()
self.mdl.setPropertyMode(tag, 'variable')
__line.setEnabled(True)
self.groupBoxViscv0.hide()
if tag == 'specific_heat':
__model.setItem(str_model='constant')
__combo.setEnabled(False)
__button.setEnabled(False)
self.mdl.setPropertyMode(tag, 'constant')
self.groupBoxCp.setTitle('Isobaric specific heat')
if tag == 'volume_viscosity':
__combo.setEnabled(True)
c = self.mdl.getPropertyMode(tag)
if c == 'variable':
__button.setEnabled(True)
else:
__button.setEnabled(False)
self.groupBoxViscv0.show()
else:
if tag == 'specific_heat':
self.groupBoxCp.setTitle('Specific heat')
self.case.undoStartGlobal()
class NumericalParamGlobalView(QWidget, Ui_NumericalParamGlobalForm):
"""
"""
def __init__(self, parent, case, tree):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_NumericalParamGlobalForm.__init__(self)
self.setupUi(self)
self.case = case
self.case.undoStopGlobal()
self.model = NumericalParamGlobalModel(self.case)
self.browser = tree
self.labelSRROM.hide()
self.lineEditSRROM.hide()
# Combo models
self.modelEXTRAG = ComboModel(self.comboBoxEXTRAG,2,1)
self.modelIMRGRA = ComboModel(self.comboBoxIMRGRA,7,1)
self.modelEXTRAG.addItem(self.tr("Neumann 1st order"), 'neumann')
self.modelEXTRAG.addItem(self.tr("Extrapolation"), 'extrapolation')
self.modelIMRGRA.addItem(self.tr("Iterative handling of non-orthogonalities"),'0')
self.modelIMRGRA.addItem(self.tr("Least squares method over neighboring cells"),'1')
self.modelIMRGRA.addItem(self.tr("Least squares method over extended cell neighborhood"),'2')
self.modelIMRGRA.addItem(self.tr("Least squares method over partial extended cell neighborhood"),'3')
self.modelIMRGRA.addItem(self.tr("Iterative method with least squares initialization"),'4')
self.modelIMRGRA.addItem(self.tr("Iterative method with least squares initialization and extended neighbordood"),'5')
self.modelIMRGRA.addItem(self.tr("Iterative method with least squares initialization and partial extended neighbordood"),'6')
self.comboBoxEXTRAG.setSizeAdjustPolicy(QComboBox.AdjustToContents)
# Connections
self.checkBoxIVISSE.clicked.connect(self.slotIVISSE)
self.checkBoxIPUCOU.clicked.connect(self.slotIPUCOU)
self.checkBoxICFGRP.clicked.connect(self.slotICFGRP)
self.checkBoxImprovedPressure.clicked.connect(self.slotImprovedPressure)
self.comboBoxEXTRAG.activated[str].connect(self.slotEXTRAG)
self.lineEditRELAXP.textChanged[str].connect(self.slotRELAXP)
self.comboBoxIMRGRA.activated[str].connect(self.slotIMRGRA)
self.lineEditSRROM.textChanged[str].connect(self.slotSRROM)
# Validators
validatorRELAXP = DoubleValidator(self.lineEditRELAXP, min=0., max=1.)
validatorRELAXP.setExclusiveMin(True)
validatorSRROM = DoubleValidator(self.lineEditSRROM, min=0., max=1.)
validatorSRROM.setExclusiveMax(True)
self.lineEditRELAXP.setValidator(validatorRELAXP)
self.lineEditSRROM.setValidator(validatorSRROM)
if self.model.getTransposedGradient() == 'on':
self.checkBoxIVISSE.setChecked(True)
else:
self.checkBoxIVISSE.setChecked(False)
if self.model.getVelocityPressureCoupling() == 'on':
self.checkBoxIPUCOU.setChecked(True)
else:
self.checkBoxIPUCOU.setChecked(False)
import code_saturne.model.FluidCharacteristicsModel as FluidCharacteristics
fluid = FluidCharacteristics.FluidCharacteristicsModel(self.case)
modl_atmo, modl_joul, modl_thermo, modl_gas, modl_coal, modl_comp = fluid.getThermoPhysicalModel()
if self.model.getHydrostaticPressure() == 'on':
self.checkBoxImprovedPressure.setChecked(True)
else:
self.checkBoxImprovedPressure.setChecked(False)
self.lineEditRELAXP.setText(str(self.model.getPressureRelaxation()))
self.modelEXTRAG.setItem(str_model=self.model.getWallPressureExtrapolation())
self.modelIMRGRA.setItem(str_model=str(self.model.getGradientReconstruction()))
if modl_joul != 'off' or modl_gas != 'off' or modl_coal != 'off':
self.labelSRROM.show()
self.lineEditSRROM.show()
self.lineEditSRROM.setText(str(self.model.getDensityRelaxation()))
if modl_comp != 'off':
self.labelICFGRP.show()
self.checkBoxICFGRP.show()
if self.model.getHydrostaticEquilibrium() == 'on':
self.checkBoxICFGRP.setChecked(True)
else:
self.checkBoxICFGRP.setChecked(False)
self.checkBoxIPUCOU.hide()
self.labelIPUCOU.hide()
self.lineEditRELAXP.hide()
self.labelRELAXP.hide()
self.checkBoxImprovedPressure.hide()
self.labelImprovedPressure.hide()
else:
self.labelICFGRP.hide()
self.checkBoxICFGRP.hide()
self.checkBoxIPUCOU.show()
self.labelIPUCOU.show()
self.lineEditRELAXP.show()
self.labelRELAXP.show()
self.checkBoxImprovedPressure.show()
self.labelImprovedPressure.show()
# Update the Tree files and folders
self.browser.configureTree(self.case)
self.case.undoStartGlobal()
class TurbulenceView(QWidget, Ui_TurbulenceForm):
"""
Class to open Turbulence Page.
"""
def __init__(self, parent=None, case=None):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_TurbulenceForm.__init__(self)
self.setupUi(self)
self.case = case
self.case.undoStopGlobal()
self.model = TurbulenceModel(self.case)
# Combo model
self.modelTurbModel = ComboModel(self.comboBoxTurbModel,10,1)
self.modelTurbModel.addItem(self.tr("No model (i.e. laminar flow)"), "off")
self.modelTurbModel.addItem(self.tr("Mixing length"), "mixing_length")
self.modelTurbModel.addItem(self.tr("k-epsilon"), "k-epsilon")
self.modelTurbModel.addItem(self.tr("k-epsilon Linear Production"), "k-epsilon-PL")
self.modelTurbModel.addItem(self.tr("Rij-epsilon LRR"), "Rij-epsilon")
self.modelTurbModel.addItem(self.tr("Rij-epsilon SSG"), "Rij-SSG")
self.modelTurbModel.addItem(self.tr("Rij-epsilon EBRSM"), "Rij-EBRSM")
self.modelTurbModel.addItem(self.tr("v2f BL-v2/k"), "v2f-BL-v2/k")
self.modelTurbModel.addItem(self.tr("k-omega SST"), "k-omega-SST")
self.modelTurbModel.addItem(self.tr("Spalart-Allmaras"), "Spalart-Allmaras")
self.modelTurbModel.addItem(self.tr("LES (Smagorinsky)"), "LES_Smagorinsky")
self.modelTurbModel.addItem(self.tr("LES (classical dynamic model)"), "LES_dynamique")
self.modelTurbModel.addItem(self.tr("LES (WALE)"), "LES_WALE")
self.modelLength = ComboModel(self.comboBoxLength,2,1)
self.modelLength.addItem(self.tr("Automatic"), 'automatic')
self.modelLength.addItem(self.tr("Prescribed"), 'prescribed')
self.comboBoxLength.setSizeAdjustPolicy(QComboBox.AdjustToContents)
# Connections
self.comboBoxTurbModel.activated[str].connect(self.slotTurbulenceModel)
self.pushButtonAdvanced.clicked.connect(self.slotAdvancedOptions)
self.lineEditLength.textChanged[str].connect(self.slotLengthScale)
self.lineEditV0.textChanged[str].connect(self.slotVelocity)
self.comboBoxLength.activated[str].connect(self.slotLengthChoice)
self.lineEditL0.textChanged[str].connect(self.slotLength)
# Frames display
self.frameAdvanced.hide()
self.frameLength.hide()
# Validators
validator = DoubleValidator(self.lineEditLength, min=0.0)
validator.setExclusiveMin(True)
self.lineEditLength.setValidator(validator)
validatorV0 = DoubleValidator(self.lineEditV0, min=0.0)
self.lineEditV0.setValidator(validatorV0)
validatorL0 = DoubleValidator(self.lineEditL0, min=0.0)
self.lineEditL0.setValidator(validatorL0)
# Update the turbulence models list with the calculation features
for turb in self.model.turbulenceModels():
if turb not in self.model.turbulenceModelsList():
self.modelTurbModel.disableItem(str_model=turb)
# Select the turbulence model
model = self.model.getTurbulenceModel()
self.modelTurbModel.setItem(str_model=model)
self.__initializeView()
# Length scale
l_scale = self.model.getLengthScale()
self.lineEditLength.setText(str(l_scale))
# Initialization
v = self.model.getVelocity()
self.lineEditV0.setText(str(v))
init_length_choice = self.model.getLengthChoice()
self.modelLength.setItem(str_model=init_length_choice)
if init_length_choice == 'automatic':
self.lineEditL0.setText(str())
self.lineEditL0.hide()
self.labelUnitL0.hide()
else:
self.lineEditL0.show()
self.labelUnitL0.show()
l = self.model.getLength()
self.lineEditL0.setText(str(l))
self.case.undoStartGlobal()
class ProfilesView(QWidget, Ui_ProfilesForm):
"""
"""
def __init__(self, parent, case, stbar):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_ProfilesForm.__init__(self)
self.setupUi(self)
self.case = case
self.case.undoStopGlobal()
self.mdl = ProfilesModel(self.case)
self.notebook = NotebookModel(self.case)
# Initialize variables concerning the display of the Hlist
self.entriesNumber = 0
# Models
self.modelProfile = StandardItemModelProfile()
self.treeViewProfile.setModel(self.modelProfile)
self.treeViewProfile.resizeColumnToContents(0)
# QListView layout
self.gridlayout1 = QGridLayout(self.widgetDrag)
self.gridlayout1.setContentsMargins(0, 0, 0, 0)
self.DragList = QListView(self.widgetDrag)
self.gridlayout1.addWidget(self.DragList,0,0,1,1)
self.gridlayout2 = QGridLayout(self.widgetDrop)
self.gridlayout2.setContentsMargins(0, 0, 0, 0)
self.DropList = QListView(self.widgetDrop)
self.gridlayout2.addWidget(self.DropList,0,0,1,1)
self.modelDrag = QStringListModel()
self.modelDrop = QStringListModel()
self.DragList.setModel(self.modelDrag)
self.DropList.setModel(self.modelDrop)
self.DragList.setAlternatingRowColors(True)
self.DragList.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.DropList.setAlternatingRowColors(True)
self.DropList.setEditTriggers(QAbstractItemView.NoEditTriggers)
# Combo items
self.modelFreq = ComboModel(self.comboBoxFreq, 3, 1)
self.modelFreq.addItem(self.tr("at the end of the calculation"), "end")
self.modelFreq.addItem(self.tr("at each 'n' time steps"), "frequency")
self.modelFreq.addItem(self.tr("Output every 'x' seconds"), 'time_value')
self.modelFormat = ComboModel(self.comboBoxFormat, 2, 1)
self.modelFormat.addItem(self.tr(".dat"), "DAT")
self.modelFormat.addItem(self.tr(".csv"), "CSV")
# Connections
self.treeViewProfile.pressed[QModelIndex].connect(self.slotSelectProfile)
self.pushButtonAdd.clicked.connect(self.slotAddProfile)
self.pushButtonDelete.clicked.connect(self.slotDeleteProfile)
self.pushButtonAddVar.clicked.connect(self.slotAddVarProfile)
self.pushButtonSuppressVar.clicked.connect(self.slotDeleteVarProfile)
self.comboBoxFreq.activated[str].connect(self.slotFrequencyType)
self.comboBoxFormat.activated[str].connect(self.slotFormatType)
self.pushButtonFormula.clicked.connect(self.slotFormula)
self.lineEditBaseName.textChanged[str].connect(self.slotBaseName)
self.lineEditFreq.textChanged[str].connect(self.slotFrequence)
self.lineEditFreqTime.textChanged[str].connect(self.slotFrequenceTime)
self.lineEditNbPoint.textChanged[str].connect(self.slotNbPoint)
# Validators
validatorFreq = IntValidator(self.lineEditFreq, min=0)
validatorFreq.setExclusiveMin(True)
self.lineEditFreq.setValidator(validatorFreq)
validatorFreqT = DoubleValidator(self.lineEditFreqTime, min=0.)
validatorFreqT.setExclusiveMin(True)
self.lineEditFreqTime.setValidator(validatorFreqT)
validatorNbPoint = IntValidator(self.lineEditNbPoint, min=0)
self.lineEditNbPoint.setValidator(validatorNbPoint)
rx = "[\-_A-Za-z0-9]{1," + str(LABEL_LENGTH_MAX) + "}"
validatorBaseName = RegExpValidator(self.lineEditBaseName, QRegExp(rx))
self.lineEditBaseName.setValidator(validatorBaseName)
#update list of variables, properties, scalars ...
liste_label = []
for label in self.mdl.getVariablesAndVolumeProperties():
liste_label.append(label)
self.modelDrag.setStringList(sorted(liste_label, key=str.lower))
#update list of profiles for view from xml file
for lab in self.mdl.getProfilesLabelsList():
self.entriesNumber = self.entriesNumber + 1
label, fmt, lst, choice, freq, formula, nb_point = self.mdl.getProfileData(lab)
self.__insertProfile(label, lst)
self.__eraseEntries()
self.case.undoStartGlobal()
def setValidators(self):
validator_kxx = DoubleValidator(self.lineEdit_kxx, min=0.0)
validator_kyy = DoubleValidator(self.lineEdit_kyy, min=0.0)
validator_kzz = DoubleValidator(self.lineEdit_kzz, min=0.0)
validator_a11 = DoubleValidator(self.lineEdit_a11)
validator_a12 = DoubleValidator(self.lineEdit_a12)
validator_a13 = DoubleValidator(self.lineEdit_a13)
validator_a21 = DoubleValidator(self.lineEdit_a21)
validator_a22 = DoubleValidator(self.lineEdit_a22)
validator_a23 = DoubleValidator(self.lineEdit_a23)
validator_a31 = DoubleValidator(self.lineEdit_a31)
validator_a32 = DoubleValidator(self.lineEdit_a32)
validator_a33 = DoubleValidator(self.lineEdit_a33)
# Apply validators
self.lineEdit_kxx.setValidator(validator_kxx)
self.lineEdit_kyy.setValidator(validator_kyy)
self.lineEdit_kzz.setValidator(validator_kzz)
self.lineEdit_a11.setValidator(validator_a11)
self.lineEdit_a12.setValidator(validator_a12)
self.lineEdit_a13.setValidator(validator_a13)
self.lineEdit_a21.setValidator(validator_a21)
self.lineEdit_a22.setValidator(validator_a22)
self.lineEdit_a23.setValidator(validator_a23)
self.lineEdit_a31.setValidator(validator_a31)
self.lineEdit_a32.setValidator(validator_a32)
self.lineEdit_a33.setValidator(validator_a33)
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 = 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 __init__(self, parent, case):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_GroundwaterForm.__init__(self)
self.setupUi(self)
self.case = case
self.case.undoStopGlobal()
self.mdl = GroundwaterModel(self.case)
self.list_scalars = []
self.m_sca = DefineUserScalarsModel(self.case)
for s in self.m_sca.getUserScalarNameList():
self.list_scalars.append((s, self.tr("Additional scalar")))
# ComboBox
self.modelPermeability = ComboModel(self.comboBoxPermeability, 2, 1)
self.modelDispersion = ComboModel(self.comboBoxDispersion, 2, 1)
self.modelFlowType = ComboModel(self.comboBoxFlowType, 2, 1)
self.modelUnsaturated = ComboModel(self.comboBoxUnsaturated, 2, 1)
self.modelChemistryModel = ComboModel(self.comboBoxChemistryModel, 2,
1)
self.modelSpeciesName = ComboModel(self.comboBoxSpeciesName, 1, 1)
self.modelPermeability.addItem(self.tr("isotropic"), 'isotropic')
self.modelPermeability.addItem(self.tr("anisotropic"), 'anisotropic')
self.modelDispersion.addItem(self.tr("isotropic"), 'isotropic')
self.modelDispersion.addItem(self.tr("anisotropic"), 'anisotropic')
self.modelFlowType.addItem(self.tr("steady"), 'steady')
self.modelFlowType.addItem(self.tr("unsteady"), 'unsteady')
self.modelUnsaturated.addItem(self.tr("True"), 'true')
self.modelUnsaturated.addItem(self.tr("False"), 'false')
self.modelChemistryModel.addItem(self.tr("Kd"), 'Kd')
self.modelChemistryModel.addItem(self.tr("EK"), 'EK')
self.scalar = ""
scalar_list = self.m_sca.getUserScalarNameList()
for s in self.m_sca.getScalarsVarianceList():
if s in scalar_list: scalar_list.remove(s)
if scalar_list != []:
self.scalar = scalar_list[0]
for scalar in scalar_list:
self.modelSpeciesName.addItem(scalar)
else:
self.groupBoxTransport.hide()
# Set up validators
self.lineEditDecayRate.setValidator(
DoubleValidator(self.lineEditDecayRate))
# Connections
self.comboBoxPermeability.activated[str].connect(
self.slotPermeabilityType)
self.comboBoxDispersion.activated[str].connect(self.slotDispersionType)
self.comboBoxFlowType.activated[str].connect(self.slotFlowType)
self.comboBoxUnsaturated.activated[str].connect(self.slotUnsaturated)
self.checkBoxGravity.clicked.connect(self.slotGravity)
self.comboBoxChemistryModel.activated[str].connect(
self.slotChemistryModel)
self.comboBoxSpeciesName.activated[str].connect(self.slotSpeciesName)
self.lineEditDecayRate.textChanged[str].connect(self.slotDecayRate)
self.initializeWidget(scalar_list)
self.case.undoStartGlobal()
def ui_initialize(self):
self.setAttribute(Qt.WA_DeleteOnClose)
MainView.Instances.add(self)
self.setWindowTitle(self.package.code_name + " TRACKING CONVERGENCE" +
" - " + self.package.version)
# Validator
validator = DoubleValidator(self.lineEditTime, min=0.0)
self.lineEditTime.setValidator(validator)
# connections
self.fileCloseAction.triggered.connect(self.close)
self.fileQuitAction.triggered.connect(self.fileQuit)
self.actionSave_state.triggered.connect(self.SaveState)
self.actionLoad_state.triggered.connect(self.LoadState)
self.displayAboutAction.triggered.connect(self.displayAbout)
self.backgroundColorAction.triggered.connect(self.setColor)
self.actionFont.triggered.connect(self.setFontSize)
self.RestoreStyleDefaults.triggered.connect(self.restoreStyleDefaults)
self.displayLicenceAction.triggered.connect(self.displayLicence)
self.toolButtonDir.clicked.connect(self.slotOpenCase)
self.lineEditTime.textChanged[str].connect(self.slotRefreshTime)
self.pushButtonRefresh.clicked.connect(self.slotRefresh)
# connection for page layout
self.destroyed.connect(MainView.updateInstances)
# Ctrl+C signal handler (allow to shutdown the GUI with Ctrl+C)
signal.signal(signal.SIGINT, signal.SIG_DFL)
self.resize(800, 700)
# restore system settings
settings = QSettings()
try:
self.restoreGeometry(
settings.value("MainWindow/Geometry", QByteArray()))
self.restoreState(settings.value("MainWindow/State", QByteArray()))
except:
self.restoreGeometry(
settings.value("MainWindow/Geometry").toByteArray())
self.restoreState(settings.value("MainWindow/State").toByteArray())
app = QCoreApplication.instance()
self.palette_default = None
self.font_default = None
if settings.contains("MainWindow/Color"):
color = settings.value(
"MainWindow/Color",
self.palette().color(QPalette.Window).name())
color = QColor(color)
if color.isValid():
if not self.palette_default:
self.palette_default = QPalette().resolve(self.palette())
self.setPalette(QPalette(color))
app.setPalette(QPalette(color))
if settings.contains("MainWindow/Font"):
f = settings.value("MainWindow/Font", str(self.font()))
if f:
if not self.font_default:
self.font_default = self.font()
font = QFont()
if (font.fromString(from_qvariant(f, to_text_string))):
self.setFont(font)
app.setFont(font)
# Init
if self.caseName == None:
self.toolButtonDir.setStyleSheet("background-color: red")
else:
self.lineEditCase.setText(self.caseName)
self.loadDirectoryContent()
self.lineEditCase.setEnabled(False)
self.lineEditTime.setText(str(self.timeRefresh))
# treeViewDirectory
self.modelCases = CaseStandardItemModel(self.parent, self.fileList,
self.listFileProbes)
self.treeViewDirectory.setModel(self.modelCases)
self.treeViewDirectory.setAlternatingRowColors(True)
self.treeViewDirectory.setSelectionBehavior(
QAbstractItemView.SelectItems)
self.treeViewDirectory.setSelectionMode(
QAbstractItemView.ExtendedSelection)
self.treeViewDirectory.setEditTriggers(QAbstractItemView.DoubleClicked)
self.treeViewDirectory.expandAll()
self.treeViewDirectory.setSelectionBehavior(
QAbstractItemView.SelectRows)
self.treeViewDirectory.setDragEnabled(False)
self.treeViewDirectory.resizeColumnToContents(0)
self.treeViewDirectory.resizeColumnToContents(1)
self.treeViewDirectory.resizeColumnToContents(2)
self.treeViewDirectory.resizeColumnToContents(3)
self.modelCases.dataChanged.connect(self.treeViewChanged)
self.timer.timeout.connect(self.updateView)
self.spinBox.valueChanged[int].connect(self.updateSubplotNumber)
# gestion des figures
l = QVBoxLayout(self.widget)
self.dc = MyMplCanvas(self.widget,
subplotNb=self.subplotNumber,
width=5,
height=4,
dpi=50)
l.addWidget(self.dc)
# this is the Navigation widget
# it takes the Canvas widget and a parent
self.toolbar = NavigationToolbar(self.dc, self.widget)
l.addWidget(self.toolbar)
self.statusbar.setSizeGripEnabled(False)
self.statusbar.showMessage(self.tr("Ready"), 5000)
self.updateView()
class NumericalParamGlobalView(QWidget, Ui_NumericalParamGlobalForm):
"""
"""
def __init__(self, parent, case, tree):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_NumericalParamGlobalForm.__init__(self)
self.setupUi(self)
self.case = case
self.case.undoStopGlobal()
self.model = NumericalParamGlobalModel(self.case)
self.browser = tree
self.labelSRROM.hide()
self.lineEditSRROM.hide()
self.line_5.hide()
# Combo models
self.modelEXTRAG = ComboModel(self.comboBoxEXTRAG, 2, 1)
self.modelIMRGRA = ComboModel(self.comboBoxIMRGRA, 5, 1)
self.modelNTERUP = ComboModel(self.comboBoxNTERUP, 3, 1)
self.modelEXTRAG.addItem(self.tr("Neumann 1st order"), 'neumann')
self.modelEXTRAG.addItem(self.tr("Extrapolation"), 'extrapolation')
self.modelIMRGRA.addItem(
self.tr("Iterative handling of non-orthogonalities"), '0')
self.modelIMRGRA.addItem(
self.tr("Least squares method over neighboring cells"), '1')
self.modelIMRGRA.addItem(
self.tr("Least squares method over extended cell neighborhood"),
'2')
self.modelIMRGRA.addItem(
self.
tr("Least squares method over partial extended cell neighborhood"),
'3')
self.modelIMRGRA.addItem(
self.tr("Iterative method with least squares initialization"), '4')
self.modelNTERUP.addItem(self.tr("SIMPLE"), 'simple')
self.modelNTERUP.addItem(self.tr("SIMPLEC"), 'simplec')
self.modelNTERUP.addItem(self.tr("PISO"), 'piso')
self.comboBoxEXTRAG.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.comboBoxNTERUP.setSizeAdjustPolicy(QComboBox.AdjustToContents)
# Connections
self.checkBoxIVISSE.clicked.connect(self.slotIVISSE)
self.checkBoxIPUCOU.clicked.connect(self.slotIPUCOU)
self.checkBoxICFGRP.clicked.connect(self.slotICFGRP)
self.checkBoxImprovedPressure.clicked.connect(
self.slotImprovedPressure)
self.comboBoxEXTRAG.activated[str].connect(self.slotEXTRAG)
self.lineEditRELAXP.textChanged[str].connect(self.slotRELAXP)
self.comboBoxIMRGRA.activated[str].connect(self.slotIMRGRA)
self.lineEditSRROM.textChanged[str].connect(self.slotSRROM)
self.comboBoxNTERUP.activated[str].connect(self.slotNTERUP)
self.spinBoxNTERUP.valueChanged[int].connect(self.slotNTERUP2)
# Validators
validatorRELAXP = DoubleValidator(self.lineEditRELAXP, min=0., max=1.)
validatorRELAXP.setExclusiveMin(True)
validatorSRROM = DoubleValidator(self.lineEditSRROM, min=0., max=1.)
validatorSRROM.setExclusiveMax(True)
self.lineEditRELAXP.setValidator(validatorRELAXP)
self.lineEditSRROM.setValidator(validatorSRROM)
if self.model.getTransposedGradient() == 'on':
self.checkBoxIVISSE.setChecked(True)
else:
self.checkBoxIVISSE.setChecked(False)
if self.model.getVelocityPressureCoupling() == 'on':
self.checkBoxIPUCOU.setChecked(True)
else:
self.checkBoxIPUCOU.setChecked(False)
import code_saturne.Pages.FluidCharacteristicsModel as FluidCharacteristics
fluid = FluidCharacteristics.FluidCharacteristicsModel(self.case)
modl_atmo, modl_joul, modl_thermo, modl_gas, modl_coal, modl_comp = fluid.getThermoPhysicalModel(
)
if self.model.getHydrostaticPressure() == 'on':
self.checkBoxImprovedPressure.setChecked(True)
else:
self.checkBoxImprovedPressure.setChecked(False)
self.lineEditRELAXP.setText(str(self.model.getPressureRelaxation()))
self.modelEXTRAG.setItem(
str_model=self.model.getWallPressureExtrapolation())
self.modelIMRGRA.setItem(
str_model=str(self.model.getGradientReconstruction()))
if modl_joul != 'off' or modl_gas != 'off' or modl_coal != 'off':
self.labelSRROM.show()
self.lineEditSRROM.show()
self.lineEditSRROM.setText(str(self.model.getDensityRelaxation()))
self.line_5.show()
algo = self.model.getVelocityPressureAlgorithm()
from code_saturne.Pages.TimeStepModel import TimeStepModel
idtvar = TimeStepModel(self.case).getTimePassing()
if idtvar in [-1, 2]:
self.modelNTERUP.enableItem(str_model='simple')
self.modelNTERUP.disableItem(str_model='piso')
else:
self.modelNTERUP.disableItem(str_model='simple')
self.modelNTERUP.enableItem(str_model='piso')
self.modelNTERUP.setItem(str_model=algo)
if algo == 'piso':
self.spinBoxNTERUP.show()
else:
self.spinBoxNTERUP.hide()
if modl_comp != 'off':
self.labelICFGRP.show()
self.checkBoxICFGRP.show()
self.line_4.show()
if self.model.getHydrostaticEquilibrium() == 'on':
self.checkBoxICFGRP.setChecked(True)
else:
self.checkBoxICFGRP.setChecked(False)
self.checkBoxIPUCOU.hide()
self.labelIPUCOU.hide()
self.lineEditRELAXP.hide()
self.labelRELAXP.hide()
self.checkBoxImprovedPressure.hide()
self.labelImprovedPressure.hide()
self.line_2.hide()
self.line_5.hide()
self.line_7.hide()
self.line_8.hide()
self.labelNTERUP.setText(
"Velocity-Pressure algorithm\nsub-iterations on Navier-Stokes")
self.comboBoxNTERUP.hide()
self.spinBoxNTERUP.show()
else:
self.labelICFGRP.hide()
self.checkBoxICFGRP.hide()
self.line_4.hide()
self.checkBoxIPUCOU.show()
self.labelIPUCOU.show()
self.lineEditRELAXP.show()
self.labelRELAXP.show()
self.checkBoxImprovedPressure.show()
self.labelImprovedPressure.show()
self.line_2.show()
self.line_5.show()
self.line_7.show()
self.line_8.show()
value = self.model.getPisoSweepNumber()
self.spinBoxNTERUP.setValue(value)
# Update the Tree files and folders
self.browser.configureTree(self.case)
self.case.undoStartGlobal()
def __init__(self, parent, case):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_Solid.__init__(self)
self.setupUi(self)
self.case = case
self.case.undoStopGlobal()
self.mdl = SolidModel(self.case)
# Combo box models
self.modelField = ComboModel(self.comboBoxField, 1, 1)
for fieldId in self.mdl.getSolidFieldIdList():
label = self.mdl.getLabel(fieldId)
name = str(fieldId)
self.modelField.addItem(self.tr(label), name)
self.currentid = -1
if len(self.mdl.getSolidFieldIdList()) > 0:
self.currentid = self.mdl.getSolidFieldIdList()[0]
self.modelField.setItem(str_model=self.currentid)
self.modelFriction = ComboModel(self.comboBoxFriction, 3, 1)
self.modelFriction.addItem(self.tr("none"), "none")
self.modelFriction.addItem(self.tr("pressure"), "pressure")
self.modelFriction.addItem(self.tr("fluxes"), "fluxes")
self.modelGranular = ComboModel(self.comboBoxGranular, 3, 1)
self.modelGranular.addItem(self.tr("none"), "none")
self.modelGranular.addItem(self.tr("pressure"), "pressure")
self.modelGranular.addItem(self.tr("fluxes"), "fluxes")
self.modelKinetic = ComboModel(self.comboBoxKinetic, 3, 1)
self.modelKinetic.addItem(self.tr("none"), "none")
self.modelKinetic.addItem(self.tr("uncorrelate collision"),
"uncorrelate_collision")
self.modelKinetic.addItem(self.tr("correlate collision"),
"correlate_collision")
# Validators
validatorComp = DoubleValidator(self.lineEditCompaction, min=0.0)
validatorComp.setExclusiveMin(True)
self.lineEditCompaction.setValidator(validatorComp)
# Connect signals to slots
self.comboBoxField.activated[str].connect(self.slotField)
self.comboBoxFriction.activated[str].connect(self.slotFriction)
self.comboBoxGranular.activated[str].connect(self.slotGranular)
self.comboBoxKinetic.activated[str].connect(self.slotKinetic)
self.lineEditCompaction.textChanged[str].connect(self.slotCompaction)
self.checkBoxCoupling.clicked[bool].connect(self.slotCoupling)
# Initialize widget
self.initializeVariables(self.currentid)
self.case.undoStartGlobal()
def createEditor(self, parent, option, index):
editor = QLineEdit(parent)
validator = DoubleValidator(editor, min=0.)
validator.setExclusiveMin(True)
editor.setValidator(validator)
return editor
def __init__(self, parent, case):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_LagrangianStatisticsForm.__init__(self)
self.setupUi(self)
self.case = case
self.case.undoStopGlobal()
self.model = LagrangianStatisticsModel(self.case)
self.checkBoxISUIST.clicked.connect(self.slotISUIST)
self.lineEditNBCLST.textChanged[str].connect(self.slotNBCLST)
self.groupBoxISTALA.clicked.connect(self.slotISTALA)
self.lineEditIDSTNT.editingFinished.connect(self.slotIDSTNT)
self.lineEditNSTIST.editingFinished.connect(self.slotNSTIST)
self.lineEditSEUIL.textChanged[str].connect(self.slotSEUIL)
self.groupBoxIENSI3.clicked.connect(self.slotIENSI3)
validatorNBCLST = IntValidator(self.lineEditNBCLST, min=0) # max=100
validatorIDSTNT = IntValidator(self.lineEditIDSTNT, min=0)
validatorIDSTNT.setExclusiveMin(True)
validatorNSTIST = IntValidator(self.lineEditNSTIST, min=0)
validatorSEUIL = DoubleValidator(self.lineEditSEUIL, min=0.)
self.lineEditNBCLST.setValidator(validatorNBCLST)
self.lineEditIDSTNT.setValidator(validatorIDSTNT)
self.lineEditNSTIST.setValidator(validatorNSTIST)
self.lineEditSEUIL.setValidator(validatorSEUIL)
# initialize Widgets
status = self.model.getRestartStatisticsStatus()
if status == "on":
self.checkBoxISUIST.setChecked(True)
else:
self.checkBoxISUIST.setChecked(False)
nclust = self.model.getGroupOfParticlesValue()
self.lineEditNBCLST.setText(str(nclust))
it = self.model.getIterationStart()
self.lineEditIDSTNT.setText(str(it))
it = self.model.getIterSteadyStart()
self.lineEditNSTIST.setText(str(it))
seuil = self.model.getThresholdValue()
self.lineEditSEUIL.setText(str(seuil))
# volume
status = self.model.getVolumeStatisticsStatus()
if status == "on":
self.groupBoxISTALA.setChecked(True)
else:
self.groupBoxISTALA.setChecked(False)
self.slotISTALA()
# boundary
status = self.model.getBoundaryStatisticsStatus()
if status == "on":
self.groupBoxIENSI3.setChecked(True)
else:
self.groupBoxIENSI3.setChecked(False)
self.slotIENSI3()
self.case.undoStartGlobal()
class BodyForcesView(QWidget, Ui_BodyForcesForm):
"""
Class to open the Body Forces (gravity) Page.
"""
def __init__(self, parent, case):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_BodyForcesForm.__init__(self)
self.setupUi(self)
self.case = case
self.case.undoStopGlobal()
self.gmdl = BodyForcesModel(self.case)
self.cmdl = None
if case.xmlRootNode().tagName != "NEPTUNE_CFD_GUI":
node_pm = self.case.xmlGetNode('thermophysical_models')
if node_pm:
node = node_pm.xmlGetNode('groundwater_model', 'model')
if not node or node['model'] == 'off':
self.cmdl = CoriolisSourceTermsModel(self.case)
if self.cmdl is None:
self.groupBoxCoriolis.hide()
# Connections
self.lineEditX.textChanged[str].connect(self.slotGravityX)
self.lineEditY.textChanged[str].connect(self.slotGravityY)
self.lineEditZ.textChanged[str].connect(self.slotGravityZ)
# Validators
validatorX = DoubleValidator(self.lineEditX)
validatorY = DoubleValidator(self.lineEditY)
validatorZ = DoubleValidator(self.lineEditZ)
self.lineEditX.setValidator(validatorX)
self.lineEditY.setValidator(validatorY)
self.lineEditZ.setValidator(validatorZ)
# Initialization
gravity_x = self.gmdl.getGravity(self.gmdl.nodes[0])
gravity_y = self.gmdl.getGravity(self.gmdl.nodes[1])
gravity_z = self.gmdl.getGravity(self.gmdl.nodes[2])
self.lineEditX.setText(str(gravity_x))
self.lineEditY.setText(str(gravity_y))
self.lineEditZ.setText(str(gravity_z))
# Coriolis source terms view
if self.cmdl:
# Connections
self.lineEditOMEGAX.textChanged[str].connect(self.slotOmegaX)
self.lineEditOMEGAY.textChanged[str].connect(self.slotOmegaY)
self.lineEditOMEGAZ.textChanged[str].connect(self.slotOmegaZ)
# Validators
validatorOmegaX = DoubleValidator(self.lineEditOMEGAX)
validatorOmegaY = DoubleValidator(self.lineEditOMEGAY)
validatorOmegaZ = DoubleValidator(self.lineEditOMEGAZ)
self.lineEditOMEGAX.setValidator(validatorOmegaX)
self.lineEditOMEGAY.setValidator(validatorOmegaY)
self.lineEditOMEGAZ.setValidator(validatorOmegaZ)
# Initialization
omega_x = self.cmdl.getOmega(self.cmdl.nodes[0])
omega_y = self.cmdl.getOmega(self.cmdl.nodes[1])
omega_z = self.cmdl.getOmega(self.cmdl.nodes[2])
self.lineEditOMEGAX.setText(str(omega_x))
self.lineEditOMEGAY.setText(str(omega_y))
self.lineEditOMEGAZ.setText(str(omega_z))
self.case.undoStartGlobal()
def __init__(self, parent, case):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_TimeStep.__init__(self)
self.setupUi(self)
self.case = case
self.case.undoStopGlobal()
self.mdl = TimeStepModel(self.case)
# Combo box models
self.modelTimeStepOption = ComboModel(self.comboBoxTimeStepOption, 3, 1)
self.modelTimeStepOption.addItem(self.tr("Constant"), "constant")
self.modelTimeStepOption.addItem(self.tr("Adaptive"), "uniform")
self.modelTimeStepOption.addItem(self.tr("Steady"), "steady")
self.modelTimeStop = ComboModel(self.comboBoxTimeStopType, 2, 1)
self.modelTimeStop.addItem(self.tr("Number of time steps"), "iteration")
self.modelTimeStop.addItem(self.tr("Time analysis (s)"), "time")
# Validators
validatorRefT = DoubleValidator(self.lineEditReferenceTimeStep, min = 0.0)
validatorNumT = IntValidator(self.lineEditNumberTimeStep, min = 0)
validatorAnaT = DoubleValidator(self.lineEditTimeAnalysis)
validatorDtMin = DoubleValidator(self.lineEditDtMin, min = 0.0)
validatorDtMax = DoubleValidator(self.lineEditDtMax, min = 0.0)
validatorIncMax = DoubleValidator(self.lineEditDtIncreasingMax, min = 0.0)
validatorDecMax = DoubleValidator(self.lineEditDtDecreasingMax, min = 0.0)
validatorRefT.setExclusiveMin(True)
validatorNumT.setExclusiveMin(True)
validatorDtMin.setExclusiveMin(True)
validatorDtMax.setExclusiveMin(True)
validatorIncMax.setExclusiveMin(True)
validatorDecMax.setExclusiveMin(True)
self.lineEditReferenceTimeStep.setValidator(validatorRefT)
self.lineEditNumberTimeStep.setValidator(validatorNumT)
self.lineEditTimeAnalysis.setValidator(validatorAnaT)
self.lineEditDtMin.setValidator(validatorDtMin)
self.lineEditDtMax.setValidator(validatorDtMax)
self.lineEditDtIncreasingMax.setValidator(validatorIncMax)
self.lineEditDtDecreasingMax.setValidator(validatorDecMax)
# tableViewCourantFourier
self.tableModelCourantFourier = StandardItemModelCourantFourier(self.mdl)
self.tableViewCourantFourier.setModel(self.tableModelCourantFourier)
self.tableViewCourantFourier.resizeColumnsToContents()
self.tableViewCourantFourier.resizeRowsToContents()
if QT_API == "PYQT4":
self.tableViewCourantFourier.verticalHeader().setResizeMode(QHeaderView.ResizeToContents)
self.tableViewCourantFourier.horizontalHeader().setResizeMode(QHeaderView.ResizeToContents)
self.tableViewCourantFourier.horizontalHeader().setResizeMode(0,QHeaderView.Stretch)
elif QT_API == "PYQT5":
self.tableViewCourantFourier.verticalHeader().setSectionResizeMode(QHeaderView.ResizeToContents)
self.tableViewCourantFourier.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeToContents)
self.tableViewCourantFourier.horizontalHeader().setSectionResizeMode(0,QHeaderView.Stretch)
self.tableViewCourantFourier.setSelectionBehavior(QAbstractItemView.SelectRows)
self.tableViewCourantFourier.setSelectionMode(QAbstractItemView.SingleSelection)
delegateMaxFourier = ValueDelegate(self.tableViewCourantFourier)
delegateMaxCourant = ValueDelegate(self.tableViewCourantFourier)
self.tableViewCourantFourier.setItemDelegateForColumn(1, delegateMaxFourier)
self.tableViewCourantFourier.setItemDelegateForColumn(2, delegateMaxCourant)
# Connect signals to slots
self.comboBoxTimeStepOption.activated[str].connect(self.slotTimeStepOption)
self.comboBoxTimeStopType.activated[str].connect(self.slotTimeStop)
self.lineEditReferenceTimeStep.textChanged[str].connect(self.slotReferenceTimeStep)
self.lineEditNumberTimeStep.textChanged[str].connect(self.slotNumberTimeStep)
self.lineEditTimeAnalysis.textChanged[str].connect(self.slotTimeAnalysis)
self.lineEditDtMin.textChanged[str].connect(self.slotDtMin)
self.lineEditDtMax.textChanged[str].connect(self.slotDtMax)
self.lineEditDtIncreasingMax.textChanged[str].connect(self.slotDtIncreasingMax)
self.lineEditDtDecreasingMax.textChanged[str].connect(self.slotDtDecreasingMax)
self.tableModelCourantFourier.dataChanged.connect(self.dataChanged)
# Initialize widget
self.initializeVariables()
self.case.undoStartGlobal()
def __init__(self, parent, case):
"""
Constructor.
"""
QWidget.__init__(self, parent)
Ui_FansForm.__init__(self)
self.setupUi(self)
self.case = case
self.case.undoStopGlobal()
self.mdl = FansModel(self.case)
# tableView fans
self.fansModel = StandardItemModelFans(self.mdl)
self.tableViewFans.setModel(self.fansModel)
self.tableViewFans.setAlternatingRowColors(True)
self.tableViewFans.setSelectionBehavior(QAbstractItemView.SelectRows)
self.tableViewFans.setSelectionMode(QAbstractItemView.SingleSelection)
delegateIdx = LineEditDelegateIndex(self.tableViewFans)
self.tableViewFans.setItemDelegateForColumn(0, delegateIdx)
delegateMeshDim = MeshDimDelegate(self, self.tableViewFans)
self.tableViewFans.setItemDelegateForColumn(1, delegateMeshDim)
delegateFanRadius = LineEditDelegateFloat(self.tableViewFans)
self.tableViewFans.setItemDelegateForColumn(2, delegateFanRadius)
delegateHubRadius = LineEditDelegateFloat(self.tableViewFans)
self.tableViewFans.setItemDelegateForColumn(3, delegateHubRadius)
delegateAxialTorque = LineEditDelegateFloat(self.tableViewFans)
self.tableViewFans.setItemDelegateForColumn(4, delegateAxialTorque)
delegateBladeRadius = LineEditDelegateFloat(self.tableViewFans)
self.tableViewFans.setItemDelegateForColumn(5, delegateBladeRadius)
self.tableViewFans.resizeColumnsToContents()
self.tableViewFans.resizeRowsToContents()
if QT_API == "PYQT4":
self.tableViewFans.horizontalHeader().setResizeMode(5,QHeaderView.Stretch)
elif QT_API == "PYQT5":
self.tableViewFans.horizontalHeader().setSectionResizeMode(5,QHeaderView.Stretch)
# Validator
validatorInX = DoubleValidator(self.lineEditInletX)
self.lineEditInletX.setValidator(validatorInX)
validatorInY = DoubleValidator(self.lineEditInletY)
self.lineEditInletY.setValidator(validatorInY)
validatorInZ = DoubleValidator(self.lineEditInletZ)
self.lineEditInletZ.setValidator(validatorInZ)
validatorOutX = DoubleValidator(self.lineEditOutletX)
self.lineEditOutletX.setValidator(validatorOutX)
validatorOutY = DoubleValidator(self.lineEditOutletY)
self.lineEditOutletY.setValidator(validatorOutY)
validatorOutZ = DoubleValidator(self.lineEditOutletZ)
self.lineEditOutletZ.setValidator(validatorOutZ)
validatorCoX = DoubleValidator(self.lineEditCoefX)
self.lineEditCoefX.setValidator(validatorCoX)
validatorCoY = DoubleValidator(self.lineEditCoefY)
self.lineEditCoefY.setValidator(validatorCoY)
validatorCoZ = DoubleValidator(self.lineEditCoefZ)
self.lineEditCoefZ.setValidator(validatorCoZ)
# Connections
self.pushButtonAddSFan.clicked.connect(self.slotAddFan)
self.pushButtonDeleteFan.clicked.connect(self.slotDeleteFan)
self.tableViewFans.pressed[QModelIndex].connect(self.slotSelectFan)
self.lineEditInletX.textChanged[str].connect(self.slotInletX)
self.lineEditInletY.textChanged[str].connect(self.slotInletY)
self.lineEditInletZ.textChanged[str].connect(self.slotInletZ)
self.lineEditOutletX.textChanged[str].connect(self.slotOutletX)
self.lineEditOutletY.textChanged[str].connect(self.slotOutletY)
self.lineEditOutletZ.textChanged[str].connect(self.slotOutletZ)
self.lineEditCoefX.textChanged[str].connect(self.slotCoefX)
self.lineEditCoefY.textChanged[str].connect(self.slotCoefY)
self.lineEditCoefZ.textChanged[str].connect(self.slotCoefZ)
if self.mdl.getFanList() != None:
for i in range(len(self.mdl.getFanList())):
self.fansModel.addItem(i)
self.groupBoxFanOption.hide()
self.case.undoStartGlobal()
def __init__(self, parent, case):
"""
Constructor.
"""
QWidget.__init__(self, parent)
Ui_TurboMachineryForm.__init__(self)
self.setupUi(self)
self.case = case
self.case.undoStopGlobal()
self.mdl = TurboMachineryModel(self.case)
# Combo model
self.modelTurboMachineryType = ComboModel(self.comboBoxTurboMachineryType, 3, 1)
self.modelTurboMachineryType.addItem(self.tr("None"), "off")
self.modelTurboMachineryType.addItem(self.tr("Full transient simulation"), "transient")
self.modelTurboMachineryType.addItem(self.tr("Transient with explicit coupling"), "transient_coupled")
self.modelTurboMachineryType.addItem(self.tr("Frozen rotor model"), "frozen")
self.modelTurboMachineryType.addItem(self.tr("Frozen rotor with explicit coupling"), "frozen_coupled")
# Set up validators
self.lineEditDX.setValidator(DoubleValidator(self.lineEditDX))
self.lineEditDY.setValidator(DoubleValidator(self.lineEditDY))
self.lineEditDZ.setValidator(DoubleValidator(self.lineEditDZ))
self.lineEditX1.setValidator(DoubleValidator(self.lineEditX1))
self.lineEditY1.setValidator(DoubleValidator(self.lineEditY1))
self.lineEditZ1.setValidator(DoubleValidator(self.lineEditZ1))
# tableView TurboMachinery
self.rotorModel = StandardItemModelRotor(self.mdl)
self.tableViewTurboMachinery.setModel(self.rotorModel)
self.tableViewTurboMachinery.resizeColumnsToContents()
self.tableViewTurboMachinery.resizeRowsToContents()
self.tableViewTurboMachinery.setAlternatingRowColors(True)
self.tableViewTurboMachinery.setSelectionBehavior(QAbstractItemView.SelectRows)
delegateVelocity = VelocityDelegate(self.tableViewTurboMachinery)
self.tableViewTurboMachinery.setItemDelegateForColumn(0, delegateVelocity)
delegateSelector = LineEditDelegateSelector(self.tableViewTurboMachinery)
self.tableViewTurboMachinery.setItemDelegateForColumn(1, delegateSelector)
self.tableViewTurboMachinery.resizeColumnsToContents()
self.tableViewTurboMachinery.resizeRowsToContents()
if QT_API == "PYQT4":
self.tableViewTurboMachinery.horizontalHeader().setResizeMode(1,QHeaderView.Stretch)
elif QT_API == "PYQT5":
self.tableViewTurboMachinery.horizontalHeader().setSectionResizeMode(1,QHeaderView.Stretch)
# Faces to join selection (Custom Widgets)
model = StandardItemModelFaces(self, self.mdl, 'face_joining')
self.widgetFacesJoin.modelFaces = model
self.widgetFacesJoin.tableView.setModel(model)
# Connections
self.comboBoxTurboMachineryType.activated[str].connect(self.slotTurboModel)
self.rotorModel.dataChanged.connect(self.dataChanged)
self.tableViewTurboMachinery.clicked[QModelIndex].connect(self.slotChangeSelection)
self.pushButtonAdd.clicked.connect(self.slotAddRotor)
self.pushButtonDelete.clicked.connect(self.slotDeleteRotor)
self.lineEditDX.textChanged[str].connect(self.slotRotationX)
self.lineEditDY.textChanged[str].connect(self.slotRotationY)
self.lineEditDZ.textChanged[str].connect(self.slotRotationZ)
self.lineEditX1.textChanged[str].connect(self.slotCenterRotationX1)
self.lineEditY1.textChanged[str].connect(self.slotCenterRotationY1)
self.lineEditZ1.textChanged[str].connect(self.slotCenterRotationZ1)
if self.mdl.getRotorList() != None:
for i in range(len(self.mdl.getRotorList())):
self.rotorModel.addItem(i)
# Initialize widget
self.updateView()
self.case.undoStartGlobal()
def createEditor(self, parent, option, index):
editor = QLineEdit(parent)
v = DoubleValidator(editor)
editor.setValidator(v)
return editor
class TurbulenceView(QWidget, Ui_TurbulenceForm):
"""
Class to open Turbulence Page.
"""
def __init__(self, parent=None, case=None):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_TurbulenceForm.__init__(self)
self.setupUi(self)
self.case = case
self.case.undoStopGlobal()
self.model = TurbulenceModel(self.case)
# Combo model
self.modelTurbModel = ComboModel(self.comboBoxTurbModel, 10, 1)
self.modelTurbModel.addItem(self.tr("No model (i.e. laminar flow)"),
"off")
self.modelTurbModel.addItem(self.tr("Mixing length"), "mixing_length")
self.modelTurbModel.addItem(self.tr("k-epsilon"), "k-epsilon")
self.modelTurbModel.addItem(self.tr("k-epsilon Linear Production"),
"k-epsilon-PL")
self.modelTurbModel.addItem(self.tr("Rij-epsilon LRR"), "Rij-epsilon")
self.modelTurbModel.addItem(self.tr("Rij-epsilon SSG"), "Rij-SSG")
self.modelTurbModel.addItem(self.tr("Rij-epsilon EBRSM"), "Rij-EBRSM")
self.modelTurbModel.addItem(self.tr("v2f BL-v2/k"), "v2f-BL-v2/k")
self.modelTurbModel.addItem(self.tr("k-omega SST"), "k-omega-SST")
self.modelTurbModel.addItem(self.tr("Spalart-Allmaras"),
"Spalart-Allmaras")
self.modelTurbModel.addItem(self.tr("LES (Smagorinsky)"),
"LES_Smagorinsky")
self.modelTurbModel.addItem(self.tr("LES (classical dynamic model)"),
"LES_dynamique")
self.modelTurbModel.addItem(self.tr("LES (WALE)"), "LES_WALE")
# Connections
self.comboBoxTurbModel.activated[str].connect(self.slotTurbulenceModel)
self.pushButtonAdvanced.clicked.connect(self.slotAdvancedOptions)
self.lineEditLength.textChanged[str].connect(self.slotLengthScale)
# Frames display
self.frameAdvanced.hide()
self.frameLength.hide()
# Validator
validator = DoubleValidator(self.lineEditLength, min=0.0)
validator.setExclusiveMin(True)
self.lineEditLength.setValidator(validator)
# Update the turbulence models list with the calculation features
for turb in self.model.turbulenceModels():
if turb not in self.model.turbulenceModelsList():
self.modelTurbModel.disableItem(str_model=turb)
# Select the turbulence model
model = self.model.getTurbulenceModel()
self.modelTurbModel.setItem(str_model=model)
self.slotTurbulenceModel(self.comboBoxTurbModel.currentText())
# Length scale
l_scale = self.model.getLengthScale()
self.lineEditLength.setText(str(l_scale))
self.case.undoStartGlobal()
def setup(self, case):
"""
Setup the widget
"""
self.__case = case
self.__boundary = None
self.__case.undoStopGlobal()
self.mdl = CompressibleModel(self.__case)
self.gas = GasCombustionModel(self.__case)
self.notebook = NotebookModel(self.__case)
# Connections
self.comboBoxVelocity.activated[str].connect(self.__slotChoiceVelocity)
self.lineEditVelocity.textChanged[str].connect(self.__slotVelocityValue)
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)
self.comboBoxTypeInlet.activated[str].connect(self.__slotInletType)
self.checkBoxPressure.clicked.connect(self.__slotPressure)
self.checkBoxDensity.clicked.connect(self.__slotDensity)
self.checkBoxTemperature.clicked.connect(self.__slotTemperature)
self.checkBoxEnergy.clicked.connect(self.__slotEnergy)
self.lineEditPressure.textChanged[str].connect(self.__slotPressureValue)
self.lineEditDensity.textChanged[str].connect(self.__slotDensityValue)
self.lineEditTotalPressure.textChanged[str].connect(self.__slotTotalPressure)
self.lineEditTotalEnthalpy.textChanged[str].connect(self.__slotTotalEnthalpy)
self.lineEditTemperature.textChanged[str].connect(self.__slotTemperatureValue)
self.lineEditEnergy.textChanged[str].connect(self.__slotEnergyValue)
self.comboBoxTypeInletGasComb.activated[str].connect(self.__slotInletTypeGasComb)
self.lineEditTemperatureGasComb.textChanged[str].connect(self.__slotTemperatureGasComb)
self.lineEditFraction.textChanged[str].connect(self.__slotMeanMixtureFraction)
# Combo models
self.modelVelocity = ComboModel(self.comboBoxVelocity, 6, 1)
self.modelVelocity.addItem(self.tr("norm"), 'norm')
self.modelVelocity.addItem(self.tr("mass flow rate"), 'flow1')
self.modelVelocity.addItem(self.tr("volumic flow rate"), 'flow2')
self.modelVelocity.addItem(self.tr("norm (user law)"), 'norm_formula')
self.modelVelocity.addItem(self.tr("mass flow rate (user law)"), 'flow1_formula')
self.modelVelocity.addItem(self.tr("volumic flow rate (user law)"), 'flow2_formula')
self.modelDirection = ComboModel(self.comboBoxDirection, 3, 1)
self.modelDirection.addItem(self.tr("normal direction to the inlet"), 'normal')
self.modelDirection.addItem(self.tr("specified coordinates"), 'coordinates')
self.modelDirection.addItem(self.tr("user profile"), 'formula')
self.modelTypeInlet = ComboModel(self.comboBoxTypeInlet, 2, 1)
self.modelTypeInlet.addItem(self.tr("imposed inlet"), 'imposed_inlet')
self.modelTypeInlet.addItem(self.tr("subsonic inlet (imposed total pressure and total enthalpy)"), \
'subsonic_inlet_PH')
self.modelTypeInletGasComb = ComboModel(self.comboBoxTypeInletGasComb, 2, 1)
model = self.gas.getGasCombustionModel()
if model == 'lwp' or model =='ebu':
self.modelTypeInletGasComb.addItem(self.tr("Unburned gas"), 'unburned')
self.modelTypeInletGasComb.addItem(self.tr("Burned gas"), 'burned')
elif model == 'd3p':
self.modelTypeInletGasComb.addItem(self.tr("Oxydant"), 'oxydant')
self.modelTypeInletGasComb.addItem(self.tr("Fuel"), 'fuel')
# Validators
validatorVelocity = DoubleValidator(self.lineEditVelocity)
validatorX = DoubleValidator(self.lineEditDirectionX)
validatorY = DoubleValidator(self.lineEditDirectionY)
validatorZ = DoubleValidator(self.lineEditDirectionZ)
validatorP = DoubleValidator(self.lineEditPressure, min = 0.0)
validatorD = DoubleValidator(self.lineEditDensity, min = 0.0)
validatorT = DoubleValidator(self.lineEditTemperature, min = 0.0)
validatorE = DoubleValidator(self.lineEditEnergy, min = 0.0)
validatorP2 = DoubleValidator(self.lineEditTotalPressure, min = 0.0)
validatorH2 = DoubleValidator(self.lineEditTotalEnthalpy, min = 0.0)
validatorTemp = DoubleValidator(self.lineEditTemperatureGasComb, min=0.)
validatorFrac = DoubleValidator(self.lineEditFraction, min=0., max=1.)
# Apply validators
self.lineEditVelocity.setValidator(validatorVelocity)
self.lineEditDirectionX.setValidator(validatorX)
self.lineEditDirectionY.setValidator(validatorY)
self.lineEditDirectionZ.setValidator(validatorZ)
self.lineEditPressure.setValidator(validatorP)
self.lineEditDensity.setValidator(validatorD)
self.lineEditTemperature.setValidator(validatorT)
self.lineEditEnergy.setValidator(validatorE)
self.lineEditTotalPressure.setValidator(validatorP2)
self.lineEditTotalEnthalpy.setValidator(validatorH2)
self.lineEditTemperatureGasComb.setValidator(validatorTemp)
self.lineEditFraction.setValidator(validatorFrac)
self.pushButtonVelocityFormula.clicked.connect(self.__slotVelocityFormula)
self.pushButtonDirectionFormula.clicked.connect(self.__slotDirectionFormula)
self.__case.undoStartGlobal()
def __init__(self, parent, case):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_FluidCharacteristicsForm.__init__(self)
self.setupUi(self)
self.case = case
self.case.undoStopGlobal()
self.mdl = FluidCharacteristicsModel(self.case)
self.notebook = NotebookModel(self.case)
if EOS == 1:
self.ava = eosAva.EosAvailable()
import cs_config
cfg = cs_config.config()
self.freesteam = 0
if cfg.libs['freesteam'].have != "no":
self.freesteam = 1
self.m_th = ThermalScalarModel(self.case)
s = self.m_th.getThermalScalarName()
tsm = self.mdl.tsm
# Particular Widget initialization taking into account of "Calculation Features"
mdl_atmo, mdl_joule, mdl_thermal, mdl_gas, mdl_coal, mdl_comp = self.mdl.getThermoPhysicalModel(
)
# Combo models
self.modelRho = ComboModel(self.comboBoxRho, 3, 1)
self.modelMu = ComboModel(self.comboBoxMu, 3, 1)
self.modelCp = ComboModel(self.comboBoxCp, 3, 1)
self.modelAl = ComboModel(self.comboBoxAl, 3, 1)
self.modelDiff = ComboModel(self.comboBoxDiff, 2, 1)
self.modelNameDiff = ComboModel(self.comboBoxNameDiff, 1, 1)
self.modelViscv0 = ComboModel(self.comboBoxViscv0, 3, 1)
self.modelDiftl0 = ComboModel(self.comboBoxDiftl0, 3, 1)
self.modelMaterial = ComboModel(self.comboBoxMaterial, 1, 1)
self.modelMethod = ComboModel(self.comboBoxMethod, 1, 1)
self.modelPhas = ComboModel(self.comboBoxPhas, 2, 1)
self.modelRho.addItem(self.tr('constant'), 'constant')
self.modelRho.addItem(self.tr('user law'), 'user_law')
self.modelRho.addItem(self.tr('material law'), 'thermal_law')
if mdl_atmo != 'off':
self.modelRho.addItem(self.tr('defined in atphyv'),
'predefined_law')
elif mdl_joule == 'arc':
self.modelRho.addItem(self.tr('defined in elphyv'),
'predefined_law')
elif mdl_comp != 'off':
self.modelRho.addItem(self.tr('predefined law'), 'predefined_law')
elif mdl_gas != 'off' or mdl_coal != 'off':
self.modelRho.addItem(self.tr('predefined law'), 'predefined_law')
self.modelMu.addItem(self.tr('constant'), 'constant')
self.modelMu.addItem(self.tr('user law'), 'user_law')
self.modelMu.addItem(self.tr('material law'), 'thermal_law')
if mdl_joule == 'arc':
self.modelMu.addItem(self.tr('defined in elphyv'),
'predefined_law')
self.modelCp.addItem(self.tr('constant'), 'constant')
self.modelCp.addItem(self.tr('user law'), 'user_law')
self.modelCp.addItem(self.tr('material law'), 'thermal_law')
if mdl_joule == 'arc':
self.modelCp.addItem(self.tr('defined in elphyv'),
'predefined_law')
self.modelAl.addItem(self.tr('constant'), 'constant')
self.modelAl.addItem(self.tr('user law'), 'user_law')
self.modelAl.addItem(self.tr('material law'), 'thermal_law')
if mdl_joule == 'arc':
self.modelAl.addItem(self.tr('defined in elphyv'),
'predefined_law')
self.modelDiff.addItem(self.tr('constant'), 'constant')
self.modelDiff.addItem(self.tr('user law'), 'user_law')
self.modelViscv0.addItem(self.tr('constant'), 'constant')
self.modelViscv0.addItem(self.tr('user law'), 'user_law')
self.modelViscv0.addItem(self.tr('material law'), 'thermal_law')
self.modelDiftl0.addItem(self.tr('constant'), 'constant')
self.modelDiftl0.addItem(self.tr('user law'), 'user_law')
self.modelDiftl0.addItem(self.tr('material law'), 'thermal_law')
if mdl_gas != 'off' or mdl_coal != 'off':
self.modelDiftl0.addItem(self.tr('predefined law'),
'predefined_law')
self.modelPhas.addItem(self.tr('liquid'), 'liquid')
self.modelPhas.addItem(self.tr('gas'), 'gas')
self.scalar = ""
scalar_list = self.mdl.m_sca.getUserScalarNameList()
for s in self.mdl.m_sca.getScalarsVarianceList():
if s in scalar_list: scalar_list.remove(s)
if scalar_list != []:
self.scalar = scalar_list[0]
for scalar in scalar_list:
self.modelNameDiff.addItem(scalar)
# Validators
validatorP0 = DoubleValidator(self.lineEditP0, min=0.0)
self.lineEditP0.setValidator(validatorP0)
validatorT0 = DoubleValidator(self.lineEditT0, min=0.0)
validatorT0.setExclusiveMin(True)
self.lineEditT0.setValidator(validatorT0)
validatorOxydant = DoubleValidator(self.lineEditOxydant, min=0.0)
validatorOxydant.setExclusiveMin(True)
self.lineEditOxydant.setValidator(validatorOxydant)
validatorFuel = DoubleValidator(self.lineEditFuel, min=0.0)
validatorFuel.setExclusiveMin(True)
self.lineEditFuel.setValidator(validatorFuel)
validatorMM = DoubleValidator(self.lineEditMassMolar, min=0.0)
validatorMM.setExclusiveMin(True)
self.lineEditMassMolar.setValidator(validatorMM)
validatorRho = DoubleValidator(self.lineEditRho, min=0.0)
validatorMu = DoubleValidator(self.lineEditMu, min=0.0)
validatorCp = DoubleValidator(self.lineEditCp, min=0.0)
validatorAl = DoubleValidator(self.lineEditAl, min=0.0)
validatorDiff = DoubleValidator(self.lineEditDiff, min=0.0)
validatorViscv0 = DoubleValidator(self.lineEditViscv0, min=0.0)
validatorDiftl0 = DoubleValidator(self.lineEditDiftl0, min=0.0)
validatorRho.setExclusiveMin(True)
validatorMu.setExclusiveMin(True)
validatorCp.setExclusiveMin(True)
validatorAl.setExclusiveMin(True)
validatorDiff.setExclusiveMin(True)
validatorDiftl0.setExclusiveMin(True)
self.lineEditRho.setValidator(validatorRho)
self.lineEditMu.setValidator(validatorMu)
self.lineEditCp.setValidator(validatorCp)
self.lineEditAl.setValidator(validatorAl)
self.lineEditDiff.setValidator(validatorDiff)
self.lineEditViscv0.setValidator(validatorViscv0)
self.lineEditDiftl0.setValidator(validatorDiftl0)
# Connections
self.lineEditP0.textChanged[str].connect(self.slotPressure)
self.lineEditT0.textChanged[str].connect(self.slotTemperature)
self.lineEditOxydant.textChanged[str].connect(self.slotTempOxydant)
self.lineEditFuel.textChanged[str].connect(self.slotTempFuel)
self.lineEditMassMolar.textChanged[str].connect(self.slotMassemol)
self.comboBoxRho.currentIndexChanged[str].connect(self.slotStateRho)
self.comboBoxMu.currentIndexChanged[str].connect(self.slotStateMu)
self.comboBoxCp.currentIndexChanged[str].connect(self.slotStateCp)
self.comboBoxAl.currentIndexChanged[str].connect(self.slotStateAl)
self.comboBoxDiff.currentIndexChanged[str].connect(self.slotStateDiff)
self.comboBoxNameDiff.activated[str].connect(self.slotNameDiff)
self.comboBoxViscv0.currentIndexChanged[str].connect(
self.slotStateViscv0)
self.comboBoxMaterial.activated[str].connect(self.slotMaterial)
self.comboBoxMethod.activated[str].connect(self.slotMethod)
self.comboBoxPhas.activated[str].connect(self.slotPhas)
self.lineEditRho.textChanged[str].connect(self.slotRho)
self.lineEditMu.textChanged[str].connect(self.slotMu)
self.lineEditCp.textChanged[str].connect(self.slotCp)
self.lineEditAl.textChanged[str].connect(self.slotAl)
self.lineEditDiff.textChanged[str].connect(self.slotDiff)
self.lineEditDiftl0.textChanged[str].connect(self.slotDiftl0)
self.lineEditViscv0.textChanged[str].connect(self.slotViscv0)
self.pushButtonRho.clicked.connect(self.slotFormulaRho)
self.pushButtonMu.clicked.connect(self.slotFormulaMu)
self.pushButtonCp.clicked.connect(self.slotFormulaCp)
self.pushButtonAl.clicked.connect(self.slotFormulaAl)
self.pushButtonDiff.clicked.connect(self.slotFormulaDiff)
self.pushButtonViscv0.clicked.connect(self.slotFormulaViscv0)
self.initializeWidget()
self.case.undoStartGlobal()
def __init__(self, parent, case):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_Turbulence.__init__(self)
self.setupUi(self)
self.case = case
self.case.undoStopGlobal()
self.mdl = TurbulenceModel(self.case)
# Dico
self.dicoM2V = {
"none": 'none',
"mixing_length": 'mixing length',
"k-epsilon": 'k-epsilon',
"rij-epsilon_ssg": 'Rij-epsilon SSG',
"rij-epsilon_ebrsm": 'Rij-epsilon EBRSM',
"k-epsilon_linear_production": 'k-epsilon linear production',
"les_smagorinsky": 'LES (Smagorinsky)',
"les_wale": 'LES (WALE)',
"tchen": 'Tchen',
"q2-q12": 'Q2-Q12',
"r2-q12": 'R2-Q12',
"r2-r12-tchen": 'R2-R12 Tchen',
"separate_phase": 'separate phase',
"separate_phase_cond": 'separate phase cond',
"small_inclusions": 'small inclusions',
"large_inclusions": 'large inclusions',
"sgdh": 'SGDH',
"ggdh": 'GGDH'
}
self.dicoV2M = {
"none": 'none',
"mixing length": 'mixing_length',
"k-epsilon": 'k-epsilon',
"Rij-epsilon SSG": 'rij-epsilon_ssg',
"Rij-epsilon EBRSM": 'rij-epsilon_ebrsm',
"k-epsilon linear production": 'k-epsilon_linear_production',
"LES (Smagorinsky)": 'les_smagorinsky',
"LES (WALE)": 'les_wale',
"Tchen": 'tchen',
"Q2-Q12": 'q2-q12',
"R2-Q12": 'r2-q12',
"R2-R12 Tchen": 'r2-r12-tchen',
"separate phase": 'separate_phase',
"separate phase cond": 'separate_phase_cond',
"small inclusions": 'small_inclusions',
"large inclusions": 'large_inclusions',
"SGDH": 'sgdh',
"GGDH": 'ggdh'
}
# Validators
validatorMix = DoubleValidator(self.lineEditMixingLength, min=0.0)
validatorMix.setExclusiveMin(False)
self.lineEditMixingLength.setValidator(validatorMix)
self.tableModelTurbulence = StandardItemModelTurbulence(
self.mdl, self.case, self.dicoM2V, self.dicoV2M)
self.tableViewTurbulence.setModel(self.tableModelTurbulence)
self.tableViewTurbulence.resizeColumnsToContents()
self.tableViewTurbulence.resizeRowsToContents()
if QT_API == "PYQT4":
self.tableViewTurbulence.verticalHeader().setResizeMode(
QHeaderView.ResizeToContents)
self.tableViewTurbulence.horizontalHeader().setResizeMode(
QHeaderView.ResizeToContents)
self.tableViewTurbulence.horizontalHeader().setResizeMode(
0, QHeaderView.Stretch)
elif QT_API == "PYQT5":
self.tableViewTurbulence.verticalHeader().setSectionResizeMode(
QHeaderView.ResizeToContents)
self.tableViewTurbulence.horizontalHeader().setSectionResizeMode(
QHeaderView.ResizeToContents)
self.tableViewTurbulence.horizontalHeader().setSectionResizeMode(
0, QHeaderView.Stretch)
self.tableViewTurbulence.setSelectionBehavior(
QAbstractItemView.SelectRows)
self.tableViewTurbulence.setSelectionMode(
QAbstractItemView.SingleSelection)
delegateTurbulence = TurbulenceDelegate(self.tableViewTurbulence,
self.mdl, self.dicoM2V,
self.dicoV2M)
delegateTurbFlux = TurbFluxDelegate(self.tableViewTurbulence, self.mdl,
self.dicoM2V, self.dicoV2M)
delegateCoupling = CouplingDelegate(self.tableViewTurbulence, self.mdl,
self.dicoM2V, self.dicoV2M)
self.tableViewTurbulence.setItemDelegateForColumn(
2, delegateTurbulence)
self.tableViewTurbulence.setItemDelegateForColumn(3, delegateTurbFlux)
self.tableViewTurbulence.setItemDelegateForColumn(4, delegateCoupling)
# Combo models
self.modelContinuousCoupling = ComboModel(
self.comboBoxContinuousCoupling, 1, 1)
self.modelContinuousCoupling.addItem(self.tr('none'), 'none')
if self.mdl.getHeatMassTransferStatus() == "off":
self.modelContinuousCoupling.addItem(self.tr("separate phases"),
"separate_phase")
else:
self.modelContinuousCoupling.addItem(
self.tr("separate phases + cond"), "separate_phase_cond")
# hide groupBoxMixingLength
self.groupBoxMixingLength.hide()
# Connect signals to slots
self.tableModelTurbulence.dataChanged.connect(self.dataChanged)
self.lineEditMixingLength.textChanged[str].connect(
self.slotMixingLength)
self.tableViewTurbulence.clicked.connect(self.slotChangeSelection)
self.comboBoxContinuousCoupling.activated[str].connect(
self.slotContinuousCoupling)
# hide/show groupBoxContinuousCoupling
if len(self.mdl.getContinuousFieldList()) >= 2:
self.groupBoxContinuousCoupling.show()
model = self.mdl.getContinuousCouplingModel()
self.modelContinuousCoupling.setItem(str_model=model)
else:
self.groupBoxContinuousCoupling.hide()
for fieldId in self.mdl.getFieldIdList():
self.tableModelTurbulence.newItem(fieldId)
self.case.undoStartGlobal()
def __init__(self, parent, case):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_FluidCharacteristicsForm.__init__(self)
self.setupUi(self)
self.case = case
self.case.undoStopGlobal()
self.mdl = FluidCharacteristicsModel(self.case)
self.notebook = NotebookModel(self.case)
self.m_th = ThermalScalarModel(self.case)
s = self.m_th.getThermalScalarName()
tsm = self.mdl.tsm
# Particular Widget init. taking into account chosen fluid model
mdl_atmo, mdl_joule, mdl_thermal, mdl_gas, mdl_coal, mdl_comp, mdl_hgn=\
self.mdl.getThermoPhysicalModel()
# Combo models
self.modelRho = ComboModel(self.comboBoxRho, 2, 1)
self.modelMu = ComboModel(self.comboBoxMu, 2, 1)
self.modelCp = ComboModel(self.comboBoxCp, 2, 1)
self.modelAl = ComboModel(self.comboBoxAl, 2, 1)
self.modelDiff = ComboModel(self.comboBoxDiff, 2, 1)
self.modelNameDiff = ComboModel(self.comboBoxNameDiff, 1, 1)
self.modelViscv0 = ComboModel(self.comboBoxViscv0, 3, 1)
self.modelDiftl0 = ComboModel(self.comboBoxDiftl0, 3, 1)
self.modelMaterial = ComboModel(self.comboBoxMaterial, 1, 1)
self.modelMethod = ComboModel(self.comboBoxMethod, 1, 1)
self.modelReference = ComboModel(self.comboBoxReference, 1, 1)
if mdl_joule == 'off':
self.modelRho.addItem(self.tr('constant'), 'constant')
self.modelRho.addItem(self.tr('material law'), 'thermal_law')
if mdl_atmo != 'off':
self.modelRho.addItem(self.tr('predefined law'), 'predefined_law')
elif mdl_hgn != "off":
self.modelRho.addItem(self.tr('linear mixture law'),
'predefined_law')
elif mdl_joule != 'off':
self.modelRho.addItem(self.tr('predefined law'), 'predefined_law')
elif mdl_comp != 'off':
self.modelRho.addItem(self.tr('predefined law'), 'predefined_law')
elif mdl_gas != 'off' or mdl_coal != 'off':
self.modelRho.addItem(self.tr('predefined law'), 'predefined_law')
self.modelRho.addItem(self.tr('user law'), 'user_law')
if mdl_joule == 'off':
self.modelMu.addItem(self.tr('constant'), 'constant')
self.modelMu.addItem(self.tr('material law'), 'thermal_law')
if mdl_joule != 'off':
self.modelMu.addItem(self.tr('predefined law'), 'predefined_law')
if mdl_hgn != "off":
self.modelMu.addItem(self.tr('linear mixture law'),
'predefined_law')
self.modelMu.addItem(self.tr('user law'), 'user_law')
if mdl_joule == 'off':
self.modelCp.addItem(self.tr('constant'), 'constant')
self.modelCp.addItem(self.tr('material law'), 'thermal_law')
if mdl_joule != 'off':
self.modelCp.addItem(self.tr('predefined law'), 'predefined_law')
self.modelCp.addItem(self.tr('user law'), 'user_law')
if mdl_joule == 'off':
self.modelAl.addItem(self.tr('constant'), 'constant')
self.modelAl.addItem(self.tr('material law'), 'thermal_law')
if mdl_joule != 'off':
self.modelAl.addItem(self.tr('predefined law'), 'predefined_law')
self.modelAl.addItem(self.tr('user law'), 'user_law')
self.modelDiff.addItem(self.tr('constant'), 'constant')
self.modelDiff.addItem(self.tr('user law'), 'user_law')
self.modelViscv0.addItem(self.tr('constant'), 'constant')
self.modelViscv0.addItem(self.tr('user law'), 'user_law')
self.modelViscv0.addItem(self.tr('material law'), 'thermal_law')
self.modelDiftl0.addItem(self.tr('constant'), 'constant')
self.modelDiftl0.addItem(self.tr('user law'), 'user_law')
self.modelDiftl0.addItem(self.tr('material law'), 'thermal_law')
if mdl_gas != 'off' or mdl_coal != 'off':
self.modelDiftl0.addItem(self.tr('predefined law'),
'predefined_law')
self.scalar = ""
scalar_list = self.mdl.m_sca.getUserScalarNameList()
for s in self.mdl.m_sca.getScalarsVarianceList():
if s in scalar_list: scalar_list.remove(s)
if scalar_list != []:
self.scalar = scalar_list[0]
for scalar in scalar_list:
self.modelNameDiff.addItem(scalar)
# Validators
validatorP0 = DoubleValidator(self.lineEditP0, min=0.0)
self.lineEditP0.setValidator(validatorP0)
validatorT0 = DoubleValidator(self.lineEditT0, min=0.0)
validatorT0.setExclusiveMin(True)
self.lineEditT0.setValidator(validatorT0)
validatorOxydant = DoubleValidator(self.lineEditOxydant, min=0.0)
validatorOxydant.setExclusiveMin(True)
self.lineEditOxydant.setValidator(validatorOxydant)
validatorFuel = DoubleValidator(self.lineEditFuel, min=0.0)
validatorFuel.setExclusiveMin(True)
self.lineEditFuel.setValidator(validatorFuel)
validatorMM = DoubleValidator(self.lineEditMassMolar, min=0.0)
validatorMM.setExclusiveMin(True)
self.lineEditMassMolar.setValidator(validatorMM)
validatorRho = DoubleValidator(self.lineEditRho, min=0.0)
validatorRho1 = DoubleValidator(self.lineEditRho1, min=0.0)
validatorRho2 = DoubleValidator(self.lineEditRho2, min=0.0)
validatorMu = DoubleValidator(self.lineEditMu, min=0.0)
validatorMu1 = DoubleValidator(self.lineEditMu1, min=0.0)
validatorMu2 = DoubleValidator(self.lineEditMu2, min=0.0)
validatorCp = DoubleValidator(self.lineEditCp, min=0.0)
validatorAl = DoubleValidator(self.lineEditAl, min=0.0)
validatorDiff = DoubleValidator(self.lineEditDiff, min=0.0)
validatorViscv0 = DoubleValidator(self.lineEditViscv0, min=0.0)
validatorDiftl0 = DoubleValidator(self.lineEditDiftl0, min=0.0)
validatorRho.setExclusiveMin(True)
validatorRho1.setExclusiveMin(True)
validatorRho2.setExclusiveMin(True)
validatorMu.setExclusiveMin(True)
validatorMu1.setExclusiveMin(True)
validatorMu2.setExclusiveMin(True)
validatorCp.setExclusiveMin(True)
validatorAl.setExclusiveMin(True)
validatorDiff.setExclusiveMin(True)
validatorDiftl0.setExclusiveMin(True)
self.lineEditRho.setValidator(validatorRho)
self.lineEditRho1.setValidator(validatorRho1)
self.lineEditRho2.setValidator(validatorRho2)
self.lineEditMu.setValidator(validatorMu)
self.lineEditMu1.setValidator(validatorMu1)
self.lineEditMu2.setValidator(validatorMu2)
self.lineEditCp.setValidator(validatorCp)
self.lineEditAl.setValidator(validatorAl)
self.lineEditDiff.setValidator(validatorDiff)
self.lineEditViscv0.setValidator(validatorViscv0)
self.lineEditDiftl0.setValidator(validatorDiftl0)
# Connections
self.lineEditP0.textChanged[str].connect(self.slotPressure)
self.lineEditT0.textChanged[str].connect(self.slotTemperature)
self.lineEditOxydant.textChanged[str].connect(self.slotTempOxydant)
self.lineEditFuel.textChanged[str].connect(self.slotTempFuel)
self.lineEditMassMolar.textChanged[str].connect(self.slotMassemol)
self.comboBoxRho.currentIndexChanged[str].connect(self.slotStateRho)
self.comboBoxMu.currentIndexChanged[str].connect(self.slotStateMu)
self.comboBoxCp.currentIndexChanged[str].connect(self.slotStateCp)
self.comboBoxAl.currentIndexChanged[str].connect(self.slotStateAl)
self.comboBoxDiff.currentIndexChanged[str].connect(self.slotStateDiff)
self.comboBoxNameDiff.activated[str].connect(self.slotNameDiff)
self.comboBoxViscv0.currentIndexChanged[str].connect(
self.slotStateViscv0)
self.comboBoxMaterial.activated[str].connect(self.slotMaterial)
self.comboBoxMethod.activated[str].connect(self.slotMethod)
self.comboBoxReference.activated[str].connect(self.slotReference)
self.lineEditRho.textChanged[str].connect(self.slotRho)
self.lineEditRho1.textChanged[str].connect(self.slotRho1)
self.lineEditRho2.textChanged[str].connect(self.slotRho2)
self.lineEditMu.textChanged[str].connect(self.slotMu)
self.lineEditMu1.textChanged[str].connect(self.slotMu1)
self.lineEditMu2.textChanged[str].connect(self.slotMu2)
self.lineEditCp.textChanged[str].connect(self.slotCp)
self.lineEditAl.textChanged[str].connect(self.slotAl)
self.lineEditDiff.textChanged[str].connect(self.slotDiff)
self.lineEditDiftl0.textChanged[str].connect(self.slotDiftl0)
self.lineEditViscv0.textChanged[str].connect(self.slotViscv0)
self.pushButtonRho.clicked.connect(self.slotFormulaRho)
self.pushButtonMu.clicked.connect(self.slotFormulaMu)
self.pushButtonCp.clicked.connect(self.slotFormulaCp)
self.pushButtonAl.clicked.connect(self.slotFormulaAl)
self.pushButtonDiff.clicked.connect(self.slotFormulaDiff)
self.pushButtonViscv0.clicked.connect(self.slotFormulaViscv0)
self.initializeWidget()
self.case.undoStartGlobal()
class TimeStepView(QWidget, Ui_TimeStepForm):
"""
"""
def __init__(self, parent, case, tree):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_TimeStepForm.__init__(self)
self.setupUi(self)
self.case = case
self.case.undoStopGlobal()
self.mdl = TimeStepModel(self.case)
self.browser = tree
# Combo model
self.modelTimeOptions = ComboModel(self.comboBoxOptions, 4, 1)
self.modelTimeOptions.addItem(self.tr("Constant"), '0')
self.modelTimeOptions.addItem(self.tr("Time varying (adaptive)"), '1')
self.modelTimeOptions.addItem(
self.tr("Space & time varying (pseudo-steady)"), '2')
self.modelTimeOptions.addItem(
self.tr("Steady (constant relaxation coefficient)"), '-1')
self.modelNTERUP = ComboModel(self.comboBoxNTERUP, 3, 1)
self.modelNTERUP.addItem(self.tr("SIMPLE"), 'simple')
self.modelNTERUP.addItem(self.tr("SIMPLEC"), 'simplec')
self.modelNTERUP.addItem(self.tr("Inner iterations"), 'piso')
self.comboBoxNTERUP.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.modelTimeStop = ComboModel(self.comboBoxStopCrit, 2, 1)
self.modelTimeStop.addItem(self.tr("Number of time steps"),
"iterations")
self.modelTimeStop.addItem(self.tr("Physical time (s)"),
"maximum_time")
self.modelTimeStop.addItem(self.tr("Additional time steps"),
"iterations_add")
self.modelTimeStop.addItem(self.tr("Additional physical time (s)"),
"maximum_time_add")
# Connections
self.comboBoxOptions.activated[str].connect(self.slotTimePassing)
self.lineEditDTREF.textChanged[str].connect(self.slotTimeStep)
self.lineEditRELXST.textChanged[str].connect(self.slotRelaxCoef)
self.lineEditCOUMAX.textChanged[str].connect(self.slotTimeOptionCOUMAX)
self.lineEditFOUMAX.textChanged[str].connect(self.slotTimeOptionFOUMAX)
self.lineEditCDTMIN.textChanged[str].connect(self.slotTimeOptionCDTMIN)
self.lineEditCDTMAX.textChanged[str].connect(self.slotTimeOptionCDTMAX)
self.lineEditVARRDT.textChanged[str].connect(self.slotTimeOptionVARRDT)
self.checkBoxIPTLRO.clicked.connect(self.slotThermalTimeStep)
self.comboBoxNTERUP.activated[str].connect(self.slotNTERUP)
self.spinBoxNTERUP.valueChanged[int].connect(self.slotNTERUP2)
self.comboBoxStopCrit.activated[str].connect(self.slotStopCritModel)
self.lineEditStop.textChanged[str].connect(self.slotStopCritValue)
# Validators
validatorDTREF = DoubleValidator(self.lineEditDTREF, min=0.0)
validatorDTREF.setExclusiveMin(True)
validatorRELXST = DoubleValidator(self.lineEditRELXST,
min=0.0,
max=1.0)
validatorRELXST.setExclusiveMin(True)
validatorCOUMAX = DoubleValidator(self.lineEditCOUMAX, min=0.0)
validatorCOUMAX.setExclusiveMin(True)
validatorFOUMAX = DoubleValidator(self.lineEditFOUMAX, min=0.0)
validatorFOUMAX.setExclusiveMin(True)
validatorCDTMIN = DoubleValidator(self.lineEditCDTMIN,
min=0.0,
max=1.0)
validatorCDTMIN.setExclusiveMin(True)
validatorCDTMAX = DoubleValidator(self.lineEditCDTMAX, min=1.0)
validatorVARRDT = DoubleValidator(self.lineEditVARRDT, min=0.0)
validatorVARRDT.setExclusiveMin(True)
self.lineEditDTREF.setValidator(validatorDTREF)
self.lineEditRELXST.setValidator(validatorRELXST)
self.lineEditCOUMAX.setValidator(validatorCOUMAX)
self.lineEditFOUMAX.setValidator(validatorFOUMAX)
self.lineEditCDTMIN.setValidator(validatorCDTMIN)
self.lineEditCDTMAX.setValidator(validatorCDTMAX)
self.lineEditVARRDT.setValidator(validatorVARRDT)
self.validatorNTABS = IntValidator(self.lineEditStop, min=0)
self.validatorTABS = DoubleValidator(self.lineEditStop, min=0.0)
# Initialization
idtvar = self.mdl.getTimePassing()
idtvar_p = idtvar
# Constraints on time step from Turbulence model
from code_saturne.model.TurbulenceModel import TurbulenceModel
model = TurbulenceModel(self.case).getTurbulenceModel()
del TurbulenceModel
if model in ('LES_Smagorinsky', 'LES_dynamique', 'LES_WALE'):
idtvar = 0
self.modelTimeOptions.disableItem(str_model='1')
self.modelTimeOptions.disableItem(str_model='2')
self.modelTimeOptions.disableItem(str_model='-1')
# Constraints on time step from Lagrangian model
from code_saturne.model.LagrangianModel import LagrangianModel
model = LagrangianModel(self.case).getLagrangianModel()
if model in ['one_way', 'two_way']:
if idtvar not in [0, 1]:
idtvar = 0
self.modelTimeOptions.disableItem(str_model='2')
self.modelTimeOptions.disableItem(str_model='-1')
if model == 'two_way':
idtvar = 0
self.modelTimeOptions.disableItem(str_model='1')
# Constraints on time step from compressible model
from code_saturne.model.CompressibleModel import CompressibleModel
model = CompressibleModel(self.case).getCompressibleModel()
if model != 'off':
if idtvar not in [0, 1]:
idtvar = 0
self.modelTimeOptions.disableItem(str_model='2')
self.modelTimeOptions.disableItem(str_model='-1')
self.labelNTERUP.setText(
"Velocity-Pressure algorithm\nsub-iterations on Navier-Stokes")
self.comboBoxNTERUP.hide()
self.spinBoxNTERUP.show()
# Constraints on time step from groundwater model
from code_saturne.model.GroundwaterModel import GroundwaterModel
model = GroundwaterModel(self.case).getGroundwaterModel()
if model != 'off':
if idtvar not in [0, 1]:
idtvar = 0
self.modelTimeOptions.disableItem(str_model='1')
self.modelTimeOptions.disableItem(str_model='2')
self.modelTimeOptions.disableItem(str_model='-1')
# Change time step option if required by model constraints
if idtvar_p != idtvar:
self.mdl.setTimePassing(idtvar)
if self.mdl.thermalCase():
if self.mdl.getThermalTimeStep() == 'on':
self.checkBoxIPTLRO.setChecked(True)
else:
self.checkBoxIPTLRO.setChecked(False)
else:
self.labelIPTLRO.hide()
self.checkBoxIPTLRO.hide()
self.mdl.RemoveThermalTimeStepNode()
self.__setTimePassingDisplay(idtvar)
self.__setStopCritDisplay()
self.case.undoStartGlobal()
def __init__(self, parent, case, tree):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_NumericalParamGlobalForm.__init__(self)
self.setupUi(self)
self.case = case
self.case.undoStopGlobal()
self.model = NumericalParamGlobalModel(self.case)
self.browser = tree
self.labelSRROM.hide()
self.lineEditSRROM.hide()
self.line_5.hide()
# Combo models
self.modelEXTRAG = ComboModel(self.comboBoxEXTRAG,2,1)
self.modelIMRGRA = ComboModel(self.comboBoxIMRGRA,5,1)
self.modelNTERUP = ComboModel(self.comboBoxNTERUP,3,1)
self.modelEXTRAG.addItem(self.tr("Neumann 1st order"), 'neumann')
self.modelEXTRAG.addItem(self.tr("Extrapolation"), 'extrapolation')
self.modelIMRGRA.addItem(self.tr("Iterative handling of non-orthogonalities"),'0')
self.modelIMRGRA.addItem(self.tr("Least squares method over neighboring cells"),'1')
self.modelIMRGRA.addItem(self.tr("Least squares method over extended cell neighborhood"),'2')
self.modelIMRGRA.addItem(self.tr("Least squares method over partial extended cell neighborhood"),'3')
self.modelIMRGRA.addItem(self.tr("Iterative method with least squares initialization"),'4')
self.modelNTERUP.addItem(self.tr("SIMPLE"), 'simple')
self.modelNTERUP.addItem(self.tr("SIMPLEC"),'simplec')
self.modelNTERUP.addItem(self.tr("PISO"),'piso')
self.comboBoxEXTRAG.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.comboBoxNTERUP.setSizeAdjustPolicy(QComboBox.AdjustToContents)
# Connections
self.connect(self.checkBoxIVISSE, SIGNAL("clicked()"), self.slotIVISSE)
self.connect(self.checkBoxIPUCOU, SIGNAL("clicked()"), self.slotIPUCOU)
self.connect(self.checkBoxICFGRP, SIGNAL("clicked()"), self.slotICFGRP)
self.connect(self.checkBoxImprovedPressure, SIGNAL("clicked()"), self.slotImprovedPressure)
self.connect(self.comboBoxEXTRAG, SIGNAL("activated(const QString&)"), self.slotEXTRAG)
self.connect(self.lineEditRELAXP, SIGNAL("textChanged(const QString &)"), self.slotRELAXP)
self.connect(self.comboBoxIMRGRA, SIGNAL("activated(const QString&)"), self.slotIMRGRA)
self.connect(self.lineEditSRROM, SIGNAL("textChanged(const QString &)"), self.slotSRROM)
self.connect(self.comboBoxNTERUP, SIGNAL("activated(const QString&)"), self.slotNTERUP)
self.connect(self.spinBoxNTERUP, SIGNAL("valueChanged(int)"), self.slotNTERUP2)
# Validators
validatorRELAXP = DoubleValidator(self.lineEditRELAXP, min=0., max=1.)
validatorRELAXP.setExclusiveMin(True)
validatorSRROM = DoubleValidator(self.lineEditSRROM, min=0., max=1.)
validatorSRROM.setExclusiveMin(True)
self.lineEditRELAXP.setValidator(validatorRELAXP)
self.lineEditSRROM.setValidator(validatorSRROM)
if self.model.getTransposedGradient() == 'on':
self.checkBoxIVISSE.setChecked(True)
else:
self.checkBoxIVISSE.setChecked(False)
if self.model.getVelocityPressureCoupling() == 'on':
self.checkBoxIPUCOU.setChecked(True)
else:
self.checkBoxIPUCOU.setChecked(False)
import code_saturne.Pages.FluidCharacteristicsModel as FluidCharacteristics
fluid = FluidCharacteristics.FluidCharacteristicsModel(self.case)
modl_atmo, modl_joul, modl_thermo, modl_gas, modl_coal, modl_comp = fluid.getThermoPhysicalModel()
if self.model.getHydrostaticPressure() == 'on':
self.checkBoxImprovedPressure.setChecked(True)
else:
self.checkBoxImprovedPressure.setChecked(False)
self.lineEditRELAXP.setText(str(self.model.getPressureRelaxation()))
self.modelEXTRAG.setItem(str_model=self.model.getWallPressureExtrapolation())
self.modelIMRGRA.setItem(str_model=str(self.model.getGradientReconstruction()))
if modl_joul != 'off' or modl_gas != 'off' or modl_coal != 'off':
self.labelSRROM.show()
self.lineEditSRROM.show()
self.lineEditSRROM.setText(str(self.model.getDensityRelaxation()))
self.line_5.show()
algo = self.model.getVelocityPressureAlgorithm()
status = SteadyManagementModel(self.case).getSteadyFlowManagement()
if status == 'on':
self.modelNTERUP.enableItem(str_model = 'simple')
self.modelNTERUP.disableItem(str_model = 'piso')
else:
self.modelNTERUP.disableItem(str_model = 'simple')
self.modelNTERUP.enableItem(str_model = 'piso')
self.modelNTERUP.setItem(str_model=algo)
if algo == 'piso':
self.spinBoxNTERUP.show()
else:
self.spinBoxNTERUP.hide()
if modl_comp != 'off':
self.labelICFGRP.show()
self.checkBoxICFGRP.show()
self.line_4.show()
if self.model.getHydrostaticEquilibrium() == 'on':
self.checkBoxICFGRP.setChecked(True)
else:
self.checkBoxICFGRP.setChecked(False)
self.checkBoxIPUCOU.hide()
self.labelIPUCOU.hide()
self.lineEditRELAXP.hide()
self.labelRELAXP.hide()
self.checkBoxImprovedPressure.hide()
self.labelImprovedPressure.hide()
self.line_2.hide()
self.line_5.hide()
self.line_7.hide()
self.line_8.hide()
self.labelNTERUP.setText("Velocity-Pressure algorithm\nsub-iterations on Navier-Stokes")
self.comboBoxNTERUP.hide()
self.spinBoxNTERUP.show()
else:
self.labelICFGRP.hide()
self.checkBoxICFGRP.hide()
self.line_4.hide()
self.checkBoxIPUCOU.show()
self.labelIPUCOU.show()
self.lineEditRELAXP.show()
self.labelRELAXP.show()
self.checkBoxImprovedPressure.show()
self.labelImprovedPressure.show()
self.line_2.show()
self.line_5.show()
self.line_7.show()
self.line_8.show()
value = self.model.getPisoSweepNumber()
self.spinBoxNTERUP.setValue(value)
# Update the Tree files and folders
self.browser.configureTree(self.case)
self.case.undoStartGlobal()
class PreprocessingView(QWidget, Ui_PreprocessingForm):
"""
"""
def __init__(self, parent, case, stbar):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_PreprocessingForm.__init__(self)
self.setupUi(self)
self.stbar = stbar
self.case = case
self.case.undoStopGlobal()
self.mdl = SolutionDomainModel(self.case)
# 2) Meshe preprocessing layout
# 2.2) Connections
self.groupBoxWarp.clicked[bool].connect(self.slotFacesCutting)
self.lineEditWarp.textChanged[str].connect(self.slotWarpParam)
self.groupBoxMeshSmooth.clicked[bool].connect(self.slotMeshSmooth)
self.lineEditMeshSmooth.textChanged[str].connect(
self.slotMeshSmoothParam)
# 2.3) Set up validators
validatorWarp = DoubleValidator(self.lineEditWarp, min=0.0)
self.lineEditWarp.setValidator(validatorWarp)
validatorSmooth = DoubleValidator(self.lineEditMeshSmooth,
min=0.0,
max=90.0)
self.lineEditMeshSmooth.setValidator(validatorSmooth)
# 2.4) Faces to join selection (Custom Widgets)
model = StandardItemModelFaces(self, self.mdl, 'face_joining')
self.widgetFacesJoin.modelFaces = model
self.widgetFacesJoin.tableView.setModel(model)
# 2.5) Thin wall
self.tableModelThinWall = StandardItemModelThinWall(self, self.mdl)
self.tableViewThinWall.setModel(self.tableModelThinWall)
if QT_API == "PYQT4":
self.tableViewThinWall.horizontalHeader().setResizeMode(
0, QHeaderView.Stretch)
self.tableViewThinWall.horizontalHeader().setResizeMode(
1, QHeaderView.Stretch)
elif QT_API == "PYQT5":
self.tableViewThinWall.horizontalHeader().setSectionResizeMode(
0, QHeaderView.Stretch)
self.tableViewThinWall.horizontalHeader().setSectionResizeMode(
1, QHeaderView.Stretch)
self.tableViewThinWall.resizeColumnsToContents()
self.tableViewThinWall.resizeRowsToContents()
self.tableViewThinWall.setSelectionBehavior(
QAbstractItemView.SelectRows)
self.tableViewThinWall.setSelectionMode(
QAbstractItemView.SingleSelection)
delegateLabel = MeshNumberDelegate(self.tableViewThinWall)
delegateSupport = LineEditDelegateSelector(self.tableViewThinWall)
self.tableViewThinWall.setItemDelegateForColumn(0, delegateLabel)
self.tableViewThinWall.setItemDelegateForColumn(1, delegateSupport)
# Connections
self.pushButtonAddThinWall.clicked.connect(self.slotAddThinWall)
self.pushButtonDeleteThinWall.clicked.connect(self.slotDeleteThinWall)
# load values
for tw in range(self.mdl.getThinWallSelectionsCount()):
self.tableModelThinWall.newItem(tw)
# 2.5) Extrude
self.tableModelExtrude = StandardItemModelExtrude(self, self.mdl)
self.tableViewExtrude.setModel(self.tableModelExtrude)
if QT_API == "PYQT4":
self.tableViewExtrude.horizontalHeader().setResizeMode(
4, QHeaderView.Stretch)
elif QT_API == "PYQT5":
self.tableViewExtrude.horizontalHeader().setSectionResizeMode(
4, QHeaderView.Stretch)
self.tableViewExtrude.resizeColumnsToContents()
self.tableViewExtrude.resizeRowsToContents()
self.tableViewExtrude.setSelectionBehavior(
QAbstractItemView.SelectRows)
self.tableViewExtrude.setSelectionMode(
QAbstractItemView.SingleSelection)
delegateLabel = MeshNumberDelegate(self.tableViewExtrude)
delegateLayer = IntDelegate(self.tableViewExtrude)
delegateSupport = LineEditDelegateSelector(self.tableViewExtrude)
delegateFloat = FloatDelegate(self.tableViewExtrude)
self.tableViewExtrude.setItemDelegateForColumn(0, delegateLabel) # Id
self.tableViewExtrude.setItemDelegateForColumn(
1, delegateLayer) # nlayers
self.tableViewExtrude.setItemDelegateForColumn(
2, delegateFloat) # thickness
self.tableViewExtrude.setItemDelegateForColumn(3,
delegateFloat) # reason
self.tableViewExtrude.setItemDelegateForColumn(
4, delegateSupport) # criteria
# Connections
self.pushButtonAddExtrude.clicked.connect(self.slotAddExtrude)
self.pushButtonDeleteExtrude.clicked.connect(self.slotDeleteExtrude)
# load values
for tw in range(self.mdl.getExtrudeSelectionsCount()):
self.tableModelExtrude.newItem(tw)
# 3) Periodicities
self.perio_mode = ""
# Model for periodicities
model = StandardItemModelFaces(self, self.mdl, 'face_periodicity')
self.widgetFacesPerio.modelFaces = model
self.widgetFacesPerio.tableView.setModel(model)
# Combo model for type of periodicity
self.modelComboPeriod = ComboModel(self.comboBoxPeriodicity, 3, 1)
self.modelComboPeriod.addItem(self.tr("Periodicity by translation"),
"translation")
self.modelComboPeriod.addItem(
self.tr(
"Periodicity by rotation (defined by angle and direction)"),
"rotation")
self.modelComboPeriod.addItem(
self.tr("Composite periodicity (defined by matrix)"), "mixed")
# Display
self.groupBoxMode.hide()
self.groupBoxTranslation.hide()
self.groupBoxRotation.hide()
self.groupBoxMixed.hide()
# Set up validators
# 4)
self.lineEditTX.setValidator(DoubleValidator(self.lineEditTX))
self.lineEditTY.setValidator(DoubleValidator(self.lineEditTY))
self.lineEditTZ.setValidator(DoubleValidator(self.lineEditTZ))
self.lineEditAngle.setValidator(DoubleValidator(self.lineEditAngle))
self.lineEditDX.setValidator(DoubleValidator(self.lineEditDX))
self.lineEditDY.setValidator(DoubleValidator(self.lineEditDY))
self.lineEditDZ.setValidator(DoubleValidator(self.lineEditDZ))
self.lineEditX1.setValidator(DoubleValidator(self.lineEditX1))
self.lineEditY1.setValidator(DoubleValidator(self.lineEditY1))
self.lineEditZ1.setValidator(DoubleValidator(self.lineEditZ1))
self.lineEditM11.setValidator(DoubleValidator(self.lineEditM11))
self.lineEditM12.setValidator(DoubleValidator(self.lineEditM12))
self.lineEditM13.setValidator(DoubleValidator(self.lineEditM13))
self.lineEditM14.setValidator(DoubleValidator(self.lineEditM14))
self.lineEditM21.setValidator(DoubleValidator(self.lineEditM21))
self.lineEditM22.setValidator(DoubleValidator(self.lineEditM22))
self.lineEditM23.setValidator(DoubleValidator(self.lineEditM23))
self.lineEditM24.setValidator(DoubleValidator(self.lineEditM24))
self.lineEditM31.setValidator(DoubleValidator(self.lineEditM31))
self.lineEditM32.setValidator(DoubleValidator(self.lineEditM32))
self.lineEditM33.setValidator(DoubleValidator(self.lineEditM33))
self.lineEditM34.setValidator(DoubleValidator(self.lineEditM34))
# Connections
selectionModel = self.widgetFacesPerio.tableView.selectionModel()
selectionModel.selectionChanged.connect(self.slotUpdatePeriodicity)
self.widgetFacesPerio.pushButtonDelete.clicked.connect(
self.slotDeletePeriodicity)
self.comboBoxPeriodicity.activated[str].connect(
self.slotPeriodicityMode)
self.lineEditTX.textChanged[str].connect(self.slotTranslationX)
self.lineEditTY.textChanged[str].connect(self.slotTranslationY)
self.lineEditTZ.textChanged[str].connect(self.slotTranslationZ)
self.lineEditAngle.textChanged[str].connect(self.slotAngleRotation)
self.lineEditDX.textChanged[str].connect(self.slotRotationX)
self.lineEditDY.textChanged[str].connect(self.slotRotationY)
self.lineEditDZ.textChanged[str].connect(self.slotRotationZ)
self.lineEditX1.textChanged[str].connect(self.slotCenterRotationX1)
self.lineEditY1.textChanged[str].connect(self.slotCenterRotationY1)
self.lineEditZ1.textChanged[str].connect(self.slotCenterRotationZ1)
self.lineEditM11.textChanged[str].connect(self.slotMatrix11)
self.lineEditM12.textChanged[str].connect(self.slotMatrix12)
self.lineEditM13.textChanged[str].connect(self.slotMatrix13)
self.lineEditM14.textChanged[str].connect(self.slotMatrix14)
self.lineEditM21.textChanged[str].connect(self.slotMatrix21)
self.lineEditM22.textChanged[str].connect(self.slotMatrix22)
self.lineEditM23.textChanged[str].connect(self.slotMatrix23)
self.lineEditM24.textChanged[str].connect(self.slotMatrix24)
self.lineEditM31.textChanged[str].connect(self.slotMatrix31)
self.lineEditM32.textChanged[str].connect(self.slotMatrix32)
self.lineEditM33.textChanged[str].connect(self.slotMatrix33)
self.lineEditM34.textChanged[str].connect(self.slotMatrix34)
self.tabWidget.currentChanged[int].connect(self.slotchanged)
# Warped faces cutting
if self.mdl.getCutStatus() == 'on':
self.groupBoxWarp.setChecked(True)
self.slotFacesCutting(True)
else:
self.groupBoxWarp.setChecked(False)
self.slotFacesCutting(False)
v = self.mdl.getCutAngle()
self.warp = v
self.lineEditWarp.setText(str(self.warp))
# Mesh Smoothing
if self.mdl.getSmoothingStatus() == 'on':
self.groupBoxMeshSmooth.setChecked(True)
self.slotMeshSmooth(True)
else:
self.groupBoxMeshSmooth.setChecked(False)
self.slotMeshSmooth(False)
v = self.mdl.getSmoothAngle()
self.smooth = v
self.lineEditMeshSmooth.setText(str(self.smooth))
# tab Widget
self.tabWidget.setCurrentIndex(self.case['current_tab'])
self.case.undoStartGlobal()
def __init__(self, parent, case, stbar):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_ElectricalForm.__init__(self)
self.setupUi(self)
self.case = case
self.stbar = stbar
self.case.undoStopGlobal()
self.model = ElectricalModel(self.case)
# Combo model
self.modelJoule = ComboModel(self.comboBoxJouleModel, 4, 1)
self.modelJoule.addItem(self.tr("AC/DC"), "AC/DC")
self.modelJoule.addItem(self.tr("three-phase"), "three-phase")
self.modelJoule.addItem(self.tr("AC/DC with Transformer coupling"), "AC/DC+Transformer")
self.modelJoule.addItem(self.tr("three-phase with Transformer coupling"), "three-phase+Transformer")
self.modelJoule.disableItem(str_model="AC/DC+Transformer")
self.modelJoule.disableItem(str_model="three-phase+Transformer")
self.modelScaling = ComboModel(self.comboBoxScalingModel, 3, 1)
self.modelScaling.addItem(self.tr("general case"), "general_case")
self.modelScaling.addItem(self.tr("plane define"), "plane_define")
self.modelScaling.addItem(self.tr("user define"), "user")
self.modelDirection = ComboModel(self.comboBoxDirection, 3, 1)
self.modelDirection.addItem(self.tr("X"), "X")
self.modelDirection.addItem(self.tr("Y"), "Y")
self.modelDirection.addItem(self.tr("Z"), "Z")
# Connections
self.connect(self.pushButtonPropertiesData, SIGNAL("pressed()"), self.__slotSearchPropertiesData)
self.connect(self.lineEditSRROM, SIGNAL("textChanged(const QString &)"), self.slotSRROM)
self.connect(self.lineEditPower, SIGNAL("textChanged(const QString &)"), self.slotPower)
self.connect(self.lineEditCurrent, SIGNAL("textChanged(const QString &)"), self.slotCurrent)
self.connect(self.checkBoxScaling, SIGNAL("clicked()"), self.slotScaling)
self.connect(self.comboBoxJouleModel, SIGNAL("activated(const QString&)"), self.slotJouleModel)
self.connect(self.comboBoxScalingModel, SIGNAL("activated(const QString&)"), self.slotScalingModel)
self.connect(self.comboBoxDirection, SIGNAL("clicked()"), self.slotDirection)
self.connect(self.lineEditPlaneDefinitionA, SIGNAL("textChanged(const QString &)"), self.slotPlaneDefA)
self.connect(self.lineEditPlaneDefinitionB, SIGNAL("textChanged(const QString &)"), self.slotPlaneDefB)
self.connect(self.lineEditPlaneDefinitionC, SIGNAL("textChanged(const QString &)"), self.slotPlaneDefC)
self.connect(self.lineEditPlaneDefinitionD, SIGNAL("textChanged(const QString &)"), self.slotPlaneDefD)
self.connect(self.lineEditEpsilon, SIGNAL("textChanged(const QString &)"), self.slotPlaneDefEpsilon)
# Validators
validatorSRROM = DoubleValidator(self.lineEditSRROM, min=0.0, max=1.0)
validatorSRROM.setExclusiveMin(False)
validatorPower = DoubleValidator(self.lineEditPower, min=0.0)
validatorPower.setExclusiveMin(False)
validatorCurrent = DoubleValidator(self.lineEditCurrent, min=0.0)
validatorCurrent.setExclusiveMin(False)
validatorDefinitionA = DoubleValidator(self.lineEditPlaneDefinitionA)
validatorDefinitionB = DoubleValidator(self.lineEditPlaneDefinitionB)
validatorDefinitionC = DoubleValidator(self.lineEditPlaneDefinitionC)
validatorDefinitionD = DoubleValidator(self.lineEditPlaneDefinitionD)
validatorEpsilon = DoubleValidator(self.lineEditEpsilon)
self.lineEditSRROM.setValidator(validatorSRROM)
self.lineEditPower.setValidator(validatorPower)
self.lineEditCurrent.setValidator(validatorCurrent)
self.lineEditPlaneDefinitionA.setValidator(validatorDefinitionA)
self.lineEditPlaneDefinitionB.setValidator(validatorDefinitionB)
self.lineEditPlaneDefinitionC.setValidator(validatorDefinitionC)
self.lineEditPlaneDefinitionD.setValidator(validatorDefinitionD)
self.lineEditEpsilon.setValidator(validatorEpsilon)
# Initialize widget
self.__initializeWidget()
self.case.undoStartGlobal()
def createEditor(self, parent, option, index):
editor = QLineEdit(parent)
validator = DoubleValidator(editor, min=0.)
validator.setExclusiveMin(True)
editor.setValidator(validator)
return editor
def __init__(self, parent, case):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_TimeStepForm.__init__(self)
self.setupUi(self)
self.case = case
self.case.undoStopGlobal()
self.mdl = TimeStepModel(self.case)
# Combo model
self.modelTimeOptions = ComboModel(self.comboBoxOptions,2,1)
self.modelTimeOptions.addItem(self.tr("Constant"), '0')
self.modelTimeOptions.addItem(self.tr("Variable"), '1')
# Connections
self.connect(self.comboBoxOptions, SIGNAL("activated(const QString&)"), self.slotTimePassing)
self.connect(self.lineEditDTREF, SIGNAL("textChanged(const QString &)"), self.slotTimeStep)
self.connect(self.lineEditNTMABS, SIGNAL("textChanged(const QString &)"), self.slotIter)
self.connect(self.lineEditCOUMAX, SIGNAL("textChanged(const QString &)"), self.slotTimeOptionCOUMAX)
self.connect(self.lineEditFOUMAX, SIGNAL("textChanged(const QString &)"), self.slotTimeOptionFOUMAX)
self.connect(self.lineEditCDTMIN, SIGNAL("textChanged(const QString &)"), self.slotTimeOptionCDTMIN)
self.connect(self.lineEditCDTMAX, SIGNAL("textChanged(const QString &)"), self.slotTimeOptionCDTMAX)
self.connect(self.lineEditVARRDT, SIGNAL("textChanged(const QString &)"), self.slotTimeOptionVARRDT)
self.connect(self.checkBoxIPTLRO, SIGNAL("clicked()"), self.slotThermalTimeStep)
self.connect(self.checkBoxINPDT0, SIGNAL("clicked()"), self.slotZeroTimeStep)
# Validators
validatorDTREF = DoubleValidator(self.lineEditDTREF, min=0.0)
validatorDTREF.setExclusiveMin(True)
validatorNTMABS = IntValidator(self.lineEditNTMABS, min=1)
validatorCOUMAX = DoubleValidator(self.lineEditCOUMAX, min=0.0)
validatorCOUMAX.setExclusiveMin(True)
validatorFOUMAX = DoubleValidator(self.lineEditFOUMAX, min=0.0)
validatorFOUMAX.setExclusiveMin(True)
validatorCDTMIN = DoubleValidator(self.lineEditCDTMIN, min=0.0, max=1.0)
validatorCDTMIN.setExclusiveMin(True)
validatorCDTMAX = DoubleValidator(self.lineEditCDTMAX, min=1.0)
validatorVARRDT = DoubleValidator(self.lineEditVARRDT, min=0.0, max=1.0)
validatorVARRDT.setExclusiveMin(True)
self.lineEditDTREF.setValidator(validatorDTREF)
self.lineEditNTMABS.setValidator(validatorNTMABS)
self.lineEditCOUMAX.setValidator(validatorCOUMAX)
self.lineEditFOUMAX.setValidator(validatorFOUMAX)
self.lineEditCDTMIN.setValidator(validatorCDTMIN)
self.lineEditCDTMAX.setValidator(validatorCDTMAX)
self.lineEditVARRDT.setValidator(validatorVARRDT)
# Initialization
status = SteadyManagementModel(self.case).getSteadyFlowManagement()
if status == 'on':
self.comboBoxOptions.hide()
self.mdl.setTimePassing(2)
courant_max = self.mdl.getOptions('max_courant_num')
fourier_max = self.mdl.getOptions('max_fourier_num')
time_step_min_factor = self.mdl.getOptions('time_step_min_factor')
time_step_max_factor = self.mdl.getOptions('time_step_max_factor')
time_step_var = self.mdl.getOptions('time_step_var')
self.lineEditCOUMAX.setText(str(courant_max))
self.lineEditFOUMAX.setText(str(fourier_max))
self.lineEditCDTMIN.setText(str(time_step_min_factor))
self.lineEditCDTMAX.setText(str(time_step_max_factor))
self.lineEditVARRDT.setText(str(time_step_var))
self.groupBoxLabels.show()
else:
self.comboBoxOptions.show()
idtvar = self.mdl.getTimePassing()
self.modelTimeOptions.setItem(str_model=str(idtvar))
from code_saturne.Pages.TurbulenceModel import TurbulenceModel
model = TurbulenceModel(self.case).getTurbulenceModel()
del TurbulenceModel
if model in ('LES_Smagorinsky', 'LES_dynamique', 'LES_WALE'):
idtvar = 0
self.modelTimeOptions.setItem(str_model=str(idtvar))
self.modelTimeOptions.disableItem(str_model='0')
self.modelTimeOptions.disableItem(str_model='1')
text = self.comboBoxOptions.currentText()
self.slotTimePassing(text)
dtref = self.mdl.getTimeStep()
self.lineEditDTREF.setText(str(dtref))
ntmabs = self.mdl.getIterationsNumber()
self.lineEditNTMABS.setText(str(ntmabs))
if self.mdl.thermalCase():
if self.mdl.getThermalTimeStep() == 'on':
self.checkBoxIPTLRO.setChecked(True)
else:
self.checkBoxIPTLRO.setChecked(False)
else:
self.lineIPTLRO.hide()
self.labelIPTLRO.hide()
self.checkBoxIPTLRO.hide()
self.mdl.RemoveThermalTimeStepNode()
if self.mdl.getZeroTimeStep() == 'on':
self.checkBoxINPDT0.setChecked(True)
else:
self.checkBoxINPDT0.setChecked(False)
self.case.undoStartGlobal()
def __init__(self, parent, case):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_ImmersedBoundariesNeptune.__init__(self)
self.setupUi(self)
self.case = case
self.case.undoStopGlobal()
self.ibm = ImmersedBoundariesModel(self.case)
self.current_obj = None
# Models
self.modelFSI = StandardItemModelFSI(self.ibm)
self.tableViewFSI.setModel(self.modelFSI)
for obj in range(1, self.ibm.getNumberOfFSIObjects() + 1):
self.modelFSI.addItem(self.ibm.getObjectName(obj),
self.ibm.getObjectInteraction(obj))
if QT_API == "PYQT4":
self.tableViewFSI.verticalHeader().setResizeMode(
QHeaderView.ResizeToContents)
self.tableViewFSI.horizontalHeader().setResizeMode(
QHeaderView.ResizeToContents)
# self.tableViewFSI.horizontalHeader().setResizeMode(2, QHeaderView.Stretch)
elif QT_API == "PYQT5":
self.tableViewFSI.verticalHeader().setSectionResizeMode(
QHeaderView.ResizeToContents)
self.tableViewFSI.horizontalHeader().setSectionResizeMode(
QHeaderView.ResizeToContents)
# self.tableViewFSI.horizontalHeader().setSectionResizeMode(2, QHeaderView.Stretch)
self.modelFSI.dataChanged.connect(self.dataChanged)
delegateObjectLabel = FSIObjectNameDelegate(self.tableViewFSI)
self.tableViewFSI.setItemDelegateForColumn(0, delegateObjectLabel)
delegateObjectType = FSITypeDelegate(self.tableViewFSI, self.ibm)
self.tableViewFSI.setItemDelegateForColumn(1, delegateObjectType)
self.checkBoxActivate.stateChanged.connect(self.slotCheckActivate)
self.tableViewFSI.clicked[QModelIndex].connect(
self.slotChangedSelection)
for ind in ['Explicit', 'MEDCoupling']:
eval('self.radioButton' + ind +
'.toggled.connect(self.slotRadioButton)')
# Connections
self.pushButtonAddFSI.clicked.connect(self.slotAddFSI)
self.pushButtonDeleteFSI.clicked.connect(self.slotDeleteFSI)
self.pushButtonExplicit.clicked.connect(self.slotExplicitFormula)
validatorDensity = DoubleValidator(self.lineEditObjDensity, min=0.0)
self.lineEditObjDensity.setValidator(validatorDensity)
self.lineEditObjDensity.textChanged[str].connect(self.slotObjDensity)
validatorStiffness = DoubleValidator(self.lineEditObjStiffness,
min=0.0)
self.lineEditObjStiffness.setValidator(validatorStiffness)
self.lineEditObjStiffness.textChanged[str].connect(
self.slotObjStiffness)
validatorDamping = DoubleValidator(self.lineEditObjDamping, min=0.0)
self.lineEditObjDamping.setValidator(validatorDamping)
self.lineEditObjDamping.textChanged[str].connect(self.slotObjDamping)
self.lineEditXInit.textChanged[str].connect(self.slotObjXinit)
self.lineEditYInit.textChanged[str].connect(self.slotObjYinit)
self.lineEditZInit.textChanged[str].connect(self.slotObjZinit)
self.lineEditXEq.textChanged[str].connect(self.slotObjXeq)
self.lineEditYEq.textChanged[str].connect(self.slotObjYeq)
self.lineEditZEq.textChanged[str].connect(self.slotObjZeq)
self.lineEditVelXInit.textChanged[str].connect(self.slotObjVelXinit)
self.lineEditVelYInit.textChanged[str].connect(self.slotObjVelYinit)
self.lineEditVelZInit.textChanged[str].connect(self.slotObjVelZinit)
self.lineEditAccXInit.textChanged[str].connect(self.slotObjAccXinit)
self.lineEditAccYInit.textChanged[str].connect(self.slotObjAccYinit)
self.lineEditAccZInit.textChanged[str].connect(self.slotObjAccZinit)
# Check for MEDCoupling presence
import cs_config
cfg = cs_config.config()
self.has_medcoupling = cfg.libs['medcoupling'].have == 'yes'
# deactivated for the moment
self.has_medcoupling = False
self.radioButtonMEDCoupling.setEnabled(self.has_medcoupling)
if self.ibm.getMethod(
) == 'medcoupling' and self.has_medcoupling == False:
self.setMethod('explicit')
# Show/hide widgets on start
if self.ibm.getOnOff() == 'off':
self.groupBoxMethod.hide()
self.groupBoxObjects.hide()
self.groupBoxObjProperties.hide()
self.groupBoxExplicit.hide()
self.groupBoxMEDCoupling.hide()
else:
self.groupBoxMethod.show()
self.groupBoxObjects.show()
if self.ibm.getMethod() == 'explicit':
self.groupBoxExplicit.show()
else:
self.groupBoxMEDCoupling.show()
self.updatePageView()
self.case.undoStartGlobal()
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)
class NumericalParamGlobalView(QWidget, Ui_NumericalParamGlobalForm):
"""
"""
def __init__(self, parent, case, tree):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_NumericalParamGlobalForm.__init__(self)
self.setupUi(self)
self.case = case
self.case.undoStopGlobal()
self.model = NumericalParamGlobalModel(self.case)
self.browser = tree
self.labelSRROM.hide()
self.lineEditSRROM.hide()
# Combo models
self.modelGradientType = ComboModel(self.comboBoxGradientType, 5, 1)
self.modelGradientType.addItem(self.tr("Automatic"), 'default')
self.modelGradientType.addItem(
self.tr("Iterative handling of non-orthogonalities"), 'green_iter')
self.modelGradientType.addItem(self.tr("Least squares"), 'lsq')
self.modelGradientType.addItem(
self.tr("Green-Gauss with least squares gradient face values"),
'green_lsq')
self.modelGradientType.addItem(
self.tr("Green-Gauss with vertex interpolated face values"),
'green_vtx')
self.modelExtNeighbors = ComboModel(self.comboBoxExtNeighbors, 7, 1)
self.modelExtNeighbors.addItem(self.tr("Automatic"), 'default')
self.modelExtNeighbors.addItem(self.tr("None (face adjacent only)"),
'none')
self.modelExtNeighbors.addItem(self.tr("Full (all vertex adjacent)"),
'complete')
self.modelExtNeighbors.addItem(
self.tr("Opposite adjacent cell centers"), 'cell_center_opposite')
self.modelExtNeighbors.addItem(self.tr("Opposite face centers"),
'face_center_opposite')
self.modelExtNeighbors.addItem(self.tr("Aligned with face centers"),
'face_center_aligned')
self.modelExtNeighbors.addItem(
self.tr("Non-orthogonal faces threshold (legacy)"),
'non_ortho_max')
# Connections
self.checkBoxIVISSE.clicked.connect(self.slotIVISSE)
self.checkBoxIPUCOU.clicked.connect(self.slotIPUCOU)
self.checkBoxImprovedPressure.clicked.connect(
self.slotImprovedPressure)
self.checkBoxICFGRP.clicked.connect(self.slotICFGRP)
self.lineEditRELAXP.textChanged[str].connect(self.slotRELAXP)
self.comboBoxGradientType.activated[str].connect(self.slotGradientType)
self.comboBoxExtNeighbors.activated[str].connect(self.slotExtNeighbors)
self.lineEditSRROM.textChanged[str].connect(self.slotSRROM)
# Validators
validatorRELAXP = DoubleValidator(self.lineEditRELAXP, min=0., max=1.)
validatorRELAXP.setExclusiveMin(True)
validatorSRROM = DoubleValidator(self.lineEditSRROM, min=0., max=1.)
validatorSRROM.setExclusiveMax(True)
self.lineEditRELAXP.setValidator(validatorRELAXP)
self.lineEditSRROM.setValidator(validatorSRROM)
if self.model.getTransposedGradient() == 'on':
self.checkBoxIVISSE.setChecked(True)
else:
self.checkBoxIVISSE.setChecked(False)
if self.model.getVelocityPressureCoupling() == 'on':
self.checkBoxIPUCOU.setChecked(True)
else:
self.checkBoxIPUCOU.setChecked(False)
import code_saturne.model.FluidCharacteristicsModel as FluidCharacteristics
fluid = FluidCharacteristics.FluidCharacteristicsModel(self.case)
modl_atmo, modl_joul, modl_thermo, modl_gas, modl_coal, modl_comp, modl_hgn = \
fluid.getThermoPhysicalModel()
if self.model.getHydrostaticPressure() == 'on':
self.checkBoxImprovedPressure.setChecked(True)
else:
self.checkBoxImprovedPressure.setChecked(False)
self.lineEditRELAXP.setText(str(self.model.getPressureRelaxation()))
self.modelGradientType.setItem(
str_model=str(self.model.getGradientReconstruction()))
self.modelExtNeighbors.setItem(
str_model=str(self.model.getExtendedNeighborType()))
if self.model.getGradientReconstruction() == 'green_iter':
self.labelExtNeighbors.hide()
self.comboBoxExtNeighbors.hide()
if modl_joul != 'off' or modl_gas != 'off' or modl_coal != 'off':
self.labelSRROM.show()
self.lineEditSRROM.show()
self.lineEditSRROM.setText(str(self.model.getDensityRelaxation()))
if modl_comp != 'off':
self.checkBoxICFGRP.show()
if self.model.getHydrostaticEquilibrium() == 'on':
self.checkBoxICFGRP.setChecked(True)
else:
self.checkBoxICFGRP.setChecked(False)
self.checkBoxIPUCOU.hide()
self.lineEditRELAXP.hide()
self.labelRELAXP.hide()
self.checkBoxImprovedPressure.hide()
else:
self.checkBoxICFGRP.hide()
self.checkBoxIPUCOU.show()
self.lineEditRELAXP.show()
self.labelRELAXP.show()
self.checkBoxImprovedPressure.show()
# Update the Tree files and folders
self.browser.configureTree(self.case)
self.case.undoStartGlobal()
class ThermalRadiationView(QWidget, Ui_ThermalRadiationForm):
"""
Class to open Thermal Scalar Transport Page.
"""
def __init__(self, parent, case, tree):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_ThermalRadiationForm.__init__(self)
self.setupUi(self)
self.browser = tree
self.case = case
self.case.undoStopGlobal()
self.mdl = ThermalRadiationModel(self.case)
# Combo models
self.modelRadModel = ComboModel(self.comboBoxRadModel, 3, 1)
self.modelDirection = ComboModel(self.comboBoxQuadrature, 8, 1)
self.modelAbsorption = ComboModel(self.comboBoxAbsorption, 3, 1)
self.modelRadModel.addItem("No radiative transfers", 'off')
self.modelRadModel.addItem("Discrete ordinates method", 'dom')
self.modelRadModel.addItem("P-1 Model", 'p-1')
self.modelDirection.addItem("24 directions (S4)", "1")
self.modelDirection.addItem("48 directions (S6)", "2")
self.modelDirection.addItem("80 directions (S8)", "3")
self.modelDirection.addItem("32 directions (T2)", "4")
self.modelDirection.addItem("128 directions (T4)", "5")
self.modelDirection.addItem("8n^2 directions (Tn)", "6")
self.modelDirection.addItem("120 directions (LC11)", "7")
self.modelDirection.addItem("48 directions (DCT020-2468)", "8")
# Connections
self.comboBoxRadModel.activated[str].connect(self.slotRadiativeTransfer)
self.radioButtonOn.clicked.connect(self.slotStartRestart)
self.radioButtonOff.clicked.connect(self.slotStartRestart)
self.comboBoxQuadrature.activated[str].connect(self.slotDirection)
self.lineEditNdirec.textChanged[str].connect(self.slotNdirec)
self.comboBoxAbsorption.activated[str].connect(self.slotTypeCoefficient)
self.lineEditCoeff.textChanged[str].connect(self.slotAbsorptionCoefficient)
self.toolButtonAdvanced.clicked.connect(self.slotAdvancedOptions)
# Validator
validatorCoeff = DoubleValidator(self.lineEditCoeff, min=0.0)
self.lineEditCoeff.setValidator(validatorCoeff)
validatorNdir = IntValidator(self.lineEditNdirec, min=2)
self.lineEditNdirec.setValidator(validatorNdir)
self.modelAbsorption.addItem('constant', 'constant')
self.modelAbsorption.addItem('user function (cs_user_rad_transfer_absorption)', 'variable')
self.modelAbsorption.addItem('user law', 'formula')
self.modelAbsorption.addItem('H2O and CO2 mixing (Modak)', 'modak')
coal_or_gas = "off"
from code_saturne.Pages.CoalCombustionModel import CoalCombustionModel
coal_or_gas = CoalCombustionModel(self.case).getCoalCombustionModel("only")
del CoalCombustionModel
if coal_or_gas == "off":
from code_saturne.Pages.GasCombustionModel import GasCombustionModel
coal_or_gas = GasCombustionModel(self.case).getGasCombustionModel()
del GasCombustionModel
if coal_or_gas != "off":
self.modelAbsorption.disableItem(str_model='variable')
self.modelAbsorption.enableItem(str_model='modak')
else:
self.modelAbsorption.disableItem(str_model='modak')
self.modelAbsorption.enableItem(str_model='variable')
self.modelAbsorption.disableItem(str_model='formula')
# Initialization
self.modelRadModel.setItem(str_model=self.mdl.getRadiativeModel())
self.slotRadiativeTransfer()
if self.mdl.getRestart() == 'on':
self.radioButtonOn.setChecked(True)
self.radioButtonOff.setChecked(False)
else:
self.radioButtonOn.setChecked(False)
self.radioButtonOff.setChecked(True)
value = self.mdl.getTypeCoeff()
self.modelAbsorption.setItem(str_model=value)
self.slotTypeCoefficient(self.modelAbsorption.dicoM2V[value])
self.pushButtonCoeffFormula.setEnabled(False)
self.lineEditCoeff.setText(str(self.mdl.getAbsorCoeff()))
self.case.undoStartGlobal()
def __init__(self, parent, case):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_LagrangianBoundariesForm.__init__(self)
self.setupUi(self)
self.case = case
self.case.undoStopGlobal()
self.model = LagrangianBoundariesModel(self.case)
self.modelBoundaries = StandardItemModelBoundaries(self.case, self.model)
self.tableViewBoundaries.setModel(self.modelBoundaries)
self.tableViewBoundaries.setAlternatingRowColors(True)
self.tableViewBoundaries.horizontalHeader().setResizeMode(QHeaderView.Stretch)
delegateInteraction = ParticleBoundaryInteractionDelegate(self.tableViewBoundaries)
delegateClassNumber = ValueDelegate(self.tableViewBoundaries)
self.tableViewBoundaries.setItemDelegateForColumn(2,delegateInteraction)
self.tableViewBoundaries.setItemDelegateForColumn(3,delegateClassNumber)
self.modelIPOIT = ComboModel(self.comboBoxIPOIT,3,1)
self.modelIPOIT.addItem(self.tr("Volumic flow rate"), "rate")
self.modelIPOIT.addItem(self.tr("Statistical weight set by values"), "prescribed")
self.modelIPOIT.addItem(self.tr("User defined statistical weight"), "subroutine")
self.modelIJUVW = ComboModel(self.comboBoxIJUVW,4,1)
self.modelIJUVW.addItem(self.tr("Fluid velocity"), "fluid")
self.modelIJUVW.addItem(self.tr("Normal direction velocity"), "norm")
self.modelIJUVW.addItem(self.tr("Velocity given by values"), "components")
self.modelIJUVW.addItem(self.tr("User defined velocity"), "subroutine")
self.modelIJRTP = ComboModel(self.comboBoxIJRTP,2,1)
self.modelIJRTP.addItem(self.tr("Temperature set by values"), "prescribed")
self.modelIJRTP.addItem(self.tr("User defined temperature"), "subroutine")
self.modelIJRDP = ComboModel(self.comboBoxIJRDP,2,1)
self.modelIJRDP.addItem(self.tr("Diameter set by values"), "prescribed")
self.modelIJRDP.addItem(self.tr("User defined diameter"), "subroutine")
self.modelIRAWCL = ComboModel(self.comboBoxIRAWCL,2,1)
self.modelIRAWCL.addItem(self.tr("Raw coal"), "raw_coal_as_received")
self.modelIRAWCL.addItem(self.tr("User defined"), "subroutine")
self.connect(self.tableViewBoundaries, SIGNAL("clicked(const QModelIndex &)"), self.slotSelectBoundary)
self.connect(self.modelBoundaries, SIGNAL("dataChanged(const QModelIndex &, const QModelIndex &)"), self.dataChanged)
self.connect(self.spinBoxICLAS, SIGNAL("valueChanged(int)"), self.slotICLAS)
self.connect(self.lineEditIJNBP, SIGNAL("textChanged(const QString &)"), self.slotIJNBP)
self.connect(self.lineEditIJFRE, SIGNAL("textChanged(const QString &)"), self.slotIJFRE)
self.connect(self.lineEditICLST, SIGNAL("textChanged(const QString &)"), self.slotICLST)
self.connect(self.lineEditIDEBT, SIGNAL("textChanged(const QString &)"), self.slotIDEBT)
self.connect(self.comboBoxIPOIT, SIGNAL("activated(const QString&)"), self.slotIPOITChoice)
self.connect(self.lineEditIPOIT, SIGNAL("textChanged(const QString &)"), self.slotIPOIT)
self.connect(self.lineEditIROPT, SIGNAL("textChanged(const QString &)"), self.slotIROPT)
self.connect(self.comboBoxIJUVW, SIGNAL("activated(const QString&)"), self.slotIJUVW)
self.connect(self.lineEditIUNO, SIGNAL("textChanged(const QString &)"), self.slotIUNO)
self.connect(self.lineEditIUPT, SIGNAL("textChanged(const QString &)"), self.slotIUPT)
self.connect(self.lineEditIVPT, SIGNAL("textChanged(const QString &)"), self.slotIVPT)
self.connect(self.lineEditIWPT, SIGNAL("textChanged(const QString &)"), self.slotIWPT)
self.connect(self.comboBoxIJRTP, SIGNAL("activated(const QString&)"), self.slotIJRTP)
self.connect(self.lineEditITPT, SIGNAL("textChanged(const QString &)"), self.slotITPT)
self.connect(self.lineEditICPT, SIGNAL("textChanged(const QString &)"), self.slotICPT)
self.connect(self.lineEditIEPSI, SIGNAL("textChanged(const QString &)"), self.slotIEPSI)
self.connect(self.comboBoxIJRDP, SIGNAL("activated(const QString&)"), self.slotIJRDP)
self.connect(self.lineEditIDPT, SIGNAL("textChanged(const QString &)"), self.slotIDPT)
self.connect(self.lineEditIVDPT, SIGNAL("textChanged(const QString &)"), self.slotIVDPT)
self.connect(self.lineEditINUCHL, SIGNAL("textChanged(const QString &)"), self.slotINUCHL)
self.connect(self.lineEditIHPT, SIGNAL("textChanged(const QString &)"), self.slotIHPT)
self.connect(self.comboBoxIRAWCL, SIGNAL("activated(const QString&)"), self.slotIRAWCL)
# Validators
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)
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.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)
self._hideAllWidgets()
self.case.undoStartGlobal()
class ElectricalView(QWidget, Ui_ElectricalForm):
"""
"""
def __init__(self, parent, case, stbar):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_ElectricalForm.__init__(self)
self.setupUi(self)
self.case = case
self.stbar = stbar
self.case.undoStopGlobal()
self.model = ElectricalModel(self.case)
# Combo model
self.modelJoule = ComboModel(self.comboBoxJouleModel, 4, 1)
self.modelJoule.addItem(self.tr("AC/DC"), "AC/DC")
self.modelJoule.addItem(self.tr("three-phase"), "three-phase")
self.modelJoule.addItem(self.tr("AC/DC with Transformer coupling"),
"AC/DC+Transformer")
self.modelJoule.addItem(
self.tr("three-phase with Transformer coupling"),
"three-phase+Transformer")
self.modelJoule.disableItem(str_model="AC/DC+Transformer")
self.modelJoule.disableItem(str_model="three-phase+Transformer")
self.modelScaling = ComboModel(self.comboBoxScalingModel, 3, 1)
self.modelScaling.addItem(self.tr("general case"), "general_case")
self.modelScaling.addItem(self.tr("plane define"), "plane_define")
self.modelScaling.addItem(self.tr("user define"), "user")
self.modelDirection = ComboModel(self.comboBoxDirection, 3, 1)
self.modelDirection.addItem(self.tr("X"), "X")
self.modelDirection.addItem(self.tr("Y"), "Y")
self.modelDirection.addItem(self.tr("Z"), "Z")
# Connections
self.lineEditPower.textChanged[str].connect(self.slotPower)
self.lineEditCurrent.textChanged[str].connect(self.slotCurrent)
self.checkBoxScaling.clicked.connect(self.slotScaling)
self.comboBoxJouleModel.activated[str].connect(self.slotJouleModel)
self.comboBoxScalingModel.activated[str].connect(self.slotScalingModel)
self.comboBoxDirection.activated[str].connect(self.slotDirection)
self.lineEditPlaneDefinitionA.textChanged[str].connect(
self.slotPlaneDefA)
self.lineEditPlaneDefinitionB.textChanged[str].connect(
self.slotPlaneDefB)
self.lineEditPlaneDefinitionC.textChanged[str].connect(
self.slotPlaneDefC)
self.lineEditPlaneDefinitionD.textChanged[str].connect(
self.slotPlaneDefD)
self.lineEditEpsilon.textChanged[str].connect(self.slotPlaneDefEpsilon)
# Validators
validatorPower = DoubleValidator(self.lineEditPower, min=0.0)
validatorPower.setExclusiveMin(False)
validatorCurrent = DoubleValidator(self.lineEditCurrent, min=0.0)
validatorCurrent.setExclusiveMin(False)
validatorDefinitionA = DoubleValidator(self.lineEditPlaneDefinitionA)
validatorDefinitionB = DoubleValidator(self.lineEditPlaneDefinitionB)
validatorDefinitionC = DoubleValidator(self.lineEditPlaneDefinitionC)
validatorDefinitionD = DoubleValidator(self.lineEditPlaneDefinitionD)
validatorEpsilon = DoubleValidator(self.lineEditEpsilon)
self.lineEditPower.setValidator(validatorPower)
self.lineEditCurrent.setValidator(validatorCurrent)
self.lineEditPlaneDefinitionA.setValidator(validatorDefinitionA)
self.lineEditPlaneDefinitionB.setValidator(validatorDefinitionB)
self.lineEditPlaneDefinitionC.setValidator(validatorDefinitionC)
self.lineEditPlaneDefinitionD.setValidator(validatorDefinitionD)
self.lineEditEpsilon.setValidator(validatorEpsilon)
# Initialize widget
self.__initializeWidget()
self.case.undoStartGlobal()
def __init__(self, parent, case):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_LagrangianBoundariesForm.__init__(self)
self.setupUi(self)
self.case = case
self.case.undoStopGlobal()
self.model = LagrangianBoundariesModel(self.case)
self.modelBoundaries = StandardItemModelBoundaries(
self.case, self.model)
self.tableViewBoundaries.setModel(self.modelBoundaries)
self.tableViewBoundaries.setAlternatingRowColors(True)
if QT_API == "PYQT4":
self.tableViewBoundaries.horizontalHeader().setResizeMode(
QHeaderView.Stretch)
elif QT_API == "PYQT5":
self.tableViewBoundaries.horizontalHeader().setSectionResizeMode(
QHeaderView.Stretch)
delegateInteraction = ParticleBoundaryInteractionDelegate(
self.tableViewBoundaries)
delegateSetNumber = ValueDelegate(self.tableViewBoundaries)
self.tableViewBoundaries.setItemDelegateForColumn(
2, delegateInteraction)
self.tableViewBoundaries.setItemDelegateForColumn(3, delegateSetNumber)
self.modelIPOIT = ComboModel(self.comboBoxIPOIT, 3, 1)
self.modelIPOIT.addItem(self.tr("Mass flow rate"), "rate")
self.modelIPOIT.addItem(self.tr("Statistical weight set by values"),
"prescribed")
self.modelIJUVW = ComboModel(self.comboBoxIJUVW, 4, 1)
self.modelIJUVW.addItem(self.tr("Fluid velocity"), "fluid")
self.modelIJUVW.addItem(self.tr("Normal direction velocity"), "norm")
self.modelIJUVW.addItem(self.tr("Velocity given by values"),
"components")
self.modelIJRTP = ComboModel(self.comboBoxIJRTP, 2, 1)
self.modelIJRTP.addItem(self.tr("Fluid temperature"), "fluid")
self.modelIJRTP.addItem(self.tr("Temperature set by values"),
"prescribed")
self.tableViewBoundaries.clicked[QModelIndex].connect(
self.slotSelectBoundary)
self.modelBoundaries.dataChanged.connect(self.dataChanged)
self.spinBoxICLAS.valueChanged[int].connect(self.slotICLAS)
self.lineEditIJNBP.textChanged[str].connect(self.slotIJNBP)
self.lineEditIJFRE.textChanged[str].connect(self.slotIJFRE)
self.lineEditICLST.textChanged[str].connect(self.slotICLST)
self.lineEditIDEBT.textChanged[str].connect(self.slotIDEBT)
self.comboBoxIPOIT.activated[str].connect(self.slotIPOITChoice)
self.lineEditIPOIT.textChanged[str].connect(self.slotIPOIT)
self.lineEditIROPT.textChanged[str].connect(self.slotIROPT)
self.lineEditIRCOLM.textChanged[str].connect(self.slotIRCOLM)
self.comboBoxIJUVW.activated[str].connect(self.slotIJUVW)
self.lineEditIUNO.textChanged[str].connect(self.slotIUNO)
self.lineEditIUPT.textChanged[str].connect(self.slotIUPT)
self.lineEditIVPT.textChanged[str].connect(self.slotIVPT)
self.lineEditIWPT.textChanged[str].connect(self.slotIWPT)
self.comboBoxIJRTP.activated[str].connect(self.slotIJRTP)
self.lineEditITPT.textChanged[str].connect(self.slotITPT)
self.lineEditICPT.textChanged[str].connect(self.slotICPT)
self.lineEditIEPSI.textChanged[str].connect(self.slotIEPSI)
self.lineEditIDPT.textChanged[str].connect(self.slotIDPT)
self.lineEditIVDPT.textChanged[str].connect(self.slotIVDPT)
self.lineEditINUCHL.textChanged[str].connect(self.slotINUCHL)
self.lineEditIHPT.textChanged[str].connect(self.slotIHPT)
# Validators
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)
self._hideAllWidgets()
self.case.undoStartGlobal()
def __init__(self, parent=None, case=None):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_TurbulenceForm.__init__(self)
self.setupUi(self)
self.case = case
self.case.undoStopGlobal()
self.model = TurbulenceModel(self.case)
# Combo model
self.modelTurbModel = ComboModel(self.comboBoxTurbModel,10,1)
self.modelTurbModel.addItem(self.tr("No model (i.e. laminar flow)"), "off")
self.modelTurbModel.addItem(self.tr("Mixing length"), "mixing_length")
self.modelTurbModel.addItem(self.tr("k-epsilon"), "k-epsilon")
self.modelTurbModel.addItem(self.tr("k-epsilon Linear Production"), "k-epsilon-PL")
self.modelTurbModel.addItem(self.tr("Rij-epsilon LRR"), "Rij-epsilon")
self.modelTurbModel.addItem(self.tr("Rij-epsilon SSG"), "Rij-SSG")
self.modelTurbModel.addItem(self.tr("Rij-epsilon EBRSM"), "Rij-EBRSM")
self.modelTurbModel.addItem(self.tr("v2f BL-v2/k"), "v2f-BL-v2/k")
self.modelTurbModel.addItem(self.tr("k-omega SST"), "k-omega-SST")
self.modelTurbModel.addItem(self.tr("Spalart-Allmaras"), "Spalart-Allmaras")
self.modelTurbModel.addItem(self.tr("LES (Smagorinsky)"), "LES_Smagorinsky")
self.modelTurbModel.addItem(self.tr("LES (classical dynamic model)"), "LES_dynamique")
self.modelTurbModel.addItem(self.tr("LES (WALE)"), "LES_WALE")
# Connections
self.connect(self.comboBoxTurbModel, SIGNAL("activated(const QString&)"), self.slotTurbulenceModel)
self.connect(self.pushButtonAdvanced, SIGNAL("clicked()"), self.slotAdvancedOptions)
self.connect(self.lineEditLength, SIGNAL("textChanged(const QString &)"), self.slotLengthScale)
# Frames display
self.frameAdvanced.hide()
self.frameLength.hide()
# Validator
validator = DoubleValidator(self.lineEditLength, min=0.0)
validator.setExclusiveMin(True)
self.lineEditLength.setValidator(validator)
# Update the turbulence models list with the calculation features
for turb in self.model.turbulenceModels():
if turb not in self.model.turbulenceModelsList():
self.modelTurbModel.disableItem(str_model=turb)
# Select the turbulence model
model = self.model.getTurbulenceModel()
self.modelTurbModel.setItem(str_model=model)
self.slotTurbulenceModel(self.comboBoxTurbModel.currentText())
# Length scale
l_scale = self.model.getLengthScale()
self.lineEditLength.setText(str(l_scale))
self.case.undoStartGlobal()
