def setup(self, case):
"""
Setup the widget
"""
self.__case = case
self.__boundary = None
self.__case.undoStopGlobal()
self.mdl = CompressibleModel(self.__case)
# Connections
self.comboBoxTypeOutlet.activated[str].connect(self.slotOutletType)
self.lineEditPressure.textChanged[str].connect(self.slotPressureValue)
# Combo models
self.modelTypeOutlet = ComboModel(self.comboBoxTypeOutlet, 2, 1)
self.modelTypeOutlet.addItem(self.tr("supersonic outlet"),
'supersonic_outlet')
self.modelTypeOutlet.addItem(self.tr("subsonic outlet"),
'subsonic_outlet')
# Validators
validatorP = DoubleValidator(self.lineEditPressure, min=0.0)
# Apply validators
self.lineEditPressure.setValidator(validatorP)
self.__case.undoStartGlobal()
def showWidget(self, boundary):
"""
Show the widget
"""
self.__boundary = boundary
checked = False
hide = False
mdl = CompressibleModel(self.__case)
if mdl.getCompressibleModel() != "off":
hide = True
if not hide and self.__boundary.getMappedInletStatus() == "on":
checked = True
if checked:
self.groupBoxMappedInlet.setChecked(True)
else:
self.groupBoxMappedInlet.setChecked(False)
self.__slotMappedInlet(checked)
if hide:
self.hide()
else:
self.show()
def setup(self, case):
"""
Setup the widget
"""
self.__case = case
self.__boundary = None
self.__case.undoStopGlobal()
self.mdl = CompressibleModel(self.__case)
# Connections
self.connect(self.comboBoxTypeOutlet, SIGNAL("activated(const QString&)"), self.slotOutletType)
self.connect(self.lineEditPressure, SIGNAL("textChanged(const QString &)"), self.slotPressureValue)
# Combo models
self.modelTypeOutlet = ComboModel(self.comboBoxTypeOutlet, 2, 1)
self.modelTypeOutlet.addItem(self.tr("supersonic outlet"), 'supersonic_outlet')
self.modelTypeOutlet.addItem(self.tr("subsonic outlet"), 'subsonic_outlet')
# Validators
validatorP = DoubleValidator(self.lineEditPressure, min = 0.0)
# Apply validators
self.lineEditPressure.setValidator(validatorP)
self.__case.undoStartGlobal()
def __init__(self, parent, case, tree):
"""
Constructor.
"""
QWidget.__init__(self, parent)
Ui_AnalysisFeaturesForm.__init__(self)
self.setupUi(self)
self.case = case
self.browser = tree
self.case.undoStopGlobal()
self.lagr = LagrangianModel(self.case)
self.turb = TurbulenceModel(self.case)
self.gas = GasCombustionModel(self.case)
self.pcoal = CoalCombustionModel(self.case)
self.elect = ElectricalModel(self.case)
self.scal = DefineUserScalarsModel(self.case)
self.std = SteadyManagementModel(self.case)
self.atmo = AtmosphericFlowsModel(self.case)
self.comp = CompressibleModel(self.case)
self.darc = DarcyModel(self.case)
# Set models and number of elements for combo boxes
self.modelSteadyFlow = QtPage.ComboModel(self.comboBoxSteadyFlow,2,1)
self.modelLagrangian = QtPage.ComboModel(self.comboBoxLagrangian,2,1)
self.modelAtmospheric = QtPage.ComboModel(self.comboBoxAtmospheric,4,1)
self.modelGasCombustionModel = QtPage.ComboModel(self.comboBoxGasCombustionModel,3,1)
self.modelPulverizedCoal = QtPage.ComboModel(self.comboBoxPulverizedCoal,3,1)
self.modelJouleEffect = QtPage.ComboModel(self.comboBoxJouleEffect,3,1)
self.modelCompressible = QtPage.ComboModel(self.comboBoxCompressible,3,1)
self.modelDarcy = QtPage.ComboModel(self.comboBoxDarcy,2,1)
self.modelSteadyFlow.addItem(self.tr("steady flow"), "on")
self.modelSteadyFlow.addItem(self.tr("unsteady flow"), "off")
self.modelLagrangian.addItem(self.tr("off"), "single_phase")
self.modelLagrangian.addItem(self.tr("particles and droplets tracking"), "lagrangian")
self.modelAtmospheric.addItem(self.tr("off" ), "off")
self.modelAtmospheric.addItem(self.tr("constant density"), "constant")
self.modelAtmospheric.addItem(self.tr("dry atmosphere" ), "dry")
self.modelAtmospheric.addItem(self.tr("humid atmosphere"), "humid")
self.modelGasCombustionModel.addItem(self.tr("off"), "off")
self.modelGasCombustionModel.addItem(self.tr("perfect premixed flame (Eddy Break-Up)"), "ebu")
self.modelGasCombustionModel.addItem(self.tr("infinitely fast chemistry diffusion flame"), "d3p")
self.modelGasCombustionModel.addItem(self.tr("partial premixed flame (Libby_Williams)"), "lwp")
self.modelPulverizedCoal.addItem(self.tr("off"), "off")
self.modelPulverizedCoal.addItem(self.tr("homogeneous approach"), "homogeneous_fuel")
self.modelPulverizedCoal.addItem(self.tr("homogeneous approach with moisture"), "homogeneous_fuel_moisture")
self.modelPulverizedCoal.addItem(self.tr("homogeneous approach with moisture with Lagrangian transport"), "homogeneous_fuel_moisture_lagr")
self.modelJouleEffect.addItem(self.tr("off"), "off")
self.modelJouleEffect.addItem(self.tr("Joule Effect"), "joule")
self.modelJouleEffect.addItem(self.tr("Joule Effect and Laplace Forces"), "arc")
self.modelCompressible.addItem(self.tr("off"), 'off')
self.modelCompressible.addItem(self.tr("Perfect gas with constant gamma"), 'constant_gamma')
self.modelCompressible.addItem(self.tr("Perfect gas with variable gamma"), 'variable_gamma')
#self.modelCompressible.addItem(self.tr("Van Der Waals"), 'van_der_waals')
self.modelDarcy.addItem(self.tr("off"), 'off')
self.modelDarcy.addItem(self.tr("Darcy model"), 'darcy')
# Connect signals to slots
self.connect(self.comboBoxSteadyFlow, SIGNAL("activated(const QString&)"), self.slotSteadyFlow)
self.connect(self.comboBoxLagrangian, SIGNAL("activated(const QString&)"), self.slotLagrangian)
self.connect(self.comboBoxAtmospheric, SIGNAL("activated(const QString&)"), self.slotAtmospheric)
self.connect(self.comboBoxGasCombustionModel, SIGNAL("activated(const QString&)"), self.slotGasCombustionModel)
self.connect(self.comboBoxPulverizedCoal, SIGNAL("activated(const QString&)"), self.slotPulverizedCoal)
self.connect(self.comboBoxJouleEffect, SIGNAL("activated(const QString&)"), self.slotJouleEffect)
self.connect(self.comboBoxCompressible, SIGNAL("activated(const QString&)"), self.slotCompressibleModel)
self.connect(self.comboBoxDarcy, SIGNAL("activated(const QString&)"), self.slotDarcyModel)
# Initialize Widgets
val = self.std.getSteadyFlowManagement()
if val == 'on':
self.modelSteadyFlow.setItem(str_model='on')
self.modelLagrangian.disableItem(str_model='lagrangian')
else:
self.modelSteadyFlow.setItem(str_model='off')
self.modelLagrangian.enableItem(str_model='lagrangian')
val = self.lagr.getLagrangianStatus()
if val == 'off':
self.modelLagrangian.setItem(str_model='single_phase')
self.modelSteadyFlow.enableItem(str_model='on')
else:
self.modelLagrangian.setItem(str_model='lagrangian')
self.modelSteadyFlow.disableItem(str_model='on')
#self.modelLagrangian.disableItem(str_model='lagrangian')
val = self.atmo.getAtmosphericFlowsModel()
self.modelAtmospheric.setItem(str_model=val)
model = self.gas.getGasCombustionModel()
self.modelGasCombustionModel.setItem(str_model=model)
elec = self.elect.getElectricalModel()
self.modelJouleEffect.setItem(str_model=elec)
compressible = self.comp.getCompressibleModel()
self.modelCompressible.setItem(str_model=compressible)
self.modelCompressible.disableItem(str_model='variable_gamma')
if compressible != 'off':
self.modelSteadyFlow.setItem(str_model='off')
self.comboBoxSteadyFlow.setEnabled(False)
self.comboBoxLagrangian.setEnabled(False)
if self.std.getSteadyFlowManagement() == 'on':
self.comboBoxCompressible.setEnabled(False)
# Multi-phase flow and coal combustion
coal = self.pcoal.getCoalCombustionModel()
self.modelPulverizedCoal.setItem(str_model=coal)
if coal == 'homogeneous_fuel_moisture_lagr':
self.modelLagrangian.setItem(str_model='lagrangian')
self.modelLagrangian.disableItem(str_model='single_phase')
if self.lagr.getLagrangianStatus() == 'off':
self.modelLagrangian.setItem(str_model='single_phase')
self.modelPulverizedCoal.enableItem(str_model='homogeneous_fuel')
self.modelPulverizedCoal.enableItem(str_model='homogeneous_fuel_moisture')
self.modelPulverizedCoal.disableItem(str_model='homogeneous_fuel_moisture_lagr')
else:
self.modelLagrangian.setItem(str_model='lagrangian')
self.modelPulverizedCoal.disableItem(str_model='homogeneous_fuel')
self.modelPulverizedCoal.disableItem(str_model='homogeneous_fuel_moisture')
self.modelPulverizedCoal.enableItem(str_model='homogeneous_fuel_moisture_lagr')
# Compatibility between turbulence model and multi-phases flow model
if self.turb.getTurbulenceModel() not in \
('off', 'k-epsilon', 'k-epsilon-PL',
'Rij-epsilon', 'Rij-SSG', 'Rij-EBRSM', 'v2f-BL-v2/k',
'k-omega-SST', 'Spalart-Allmaras'):
self.modelLagrangian.setItem(str_model='single_phase')
self.comboBoxLagrangian.setEnabled(False)
# Compatibility between turbulence model and reactive flow models
if self.turb.getTurbulenceModel() not in ('k-epsilon',
'k-epsilon-PL',
'Rij-epsilon',
'Rij-SSG',
'Rij-EBRSM',
'v2f-BL-v2/k',
'k-omega-SST',
'Spalart-Allmaras'):
self.modelGasCombustionModel.setItem(str_model='off')
self.modelPulverizedCoal.setItem(str_model='off')
self.modelJouleEffect.setItem(str_model='off')
self.modelGasCombustionModel.disableItem(str_model='ebu')
self.modelGasCombustionModel.disableItem(str_model='d3p')
self.modelGasCombustionModel.disableItem(str_model='lwp')
self.modelPulverizedCoal.disableItem(str_model='homogeneous_fuel')
self.modelPulverizedCoal.disableItem(str_model='homogeneous_fuel_moisture')
self.modelPulverizedCoal.disableItem(str_model='homogeneous_fuel_moisture_lagr')
self.comboBoxGasCombustionModel.setEnabled(False)
self.comboBoxPulverizedCoal.setEnabled(False)
# Update the QComboBox
flame = self.gas.getGasCombustionModel()
coal = self.pcoal.getCoalCombustionModel()
joule = self.elect.getElectricalModel()
atmospheric = self.atmo.getAtmosphericFlowsModel()
compressible = self.comp.getCompressibleModel()
darcy = self.darc.getDarcyModel()
self.modelGasCombustionModel.setItem(str_model=flame)
self.modelPulverizedCoal.setItem(str_model=coal)
self.modelJouleEffect.setItem(str_model=joule)
self.modelAtmospheric.setItem(str_model=atmospheric)
self.modelCompressible.setItem(str_model=compressible)
self.modelDarcy.setItem(str_model=darcy)
# If one model is turned on, the others are turned off
if (flame, coal, joule, atmospheric, compressible, darcy) != ('off', 'off', 'off', 'off', 'off', 'off'):
if flame == 'off':
self.comboBoxGasCombustionModel.setEnabled(False)
if coal == 'off':
self.comboBoxPulverizedCoal.setEnabled(False)
if joule == 'off':
self.comboBoxJouleEffect.setEnabled(False)
if atmospheric == 'off':
self.comboBoxAtmospheric.setEnabled(False)
if compressible == 'off':
self.comboBoxCompressible.setEnabled(False)
if darcy == 'off':
self.comboBoxDarcy.setEnabled(False)
if darcy != 'off':
self.comboBoxSteadyFlow.setEnabled(False)
self.comboBoxLagrangian.setEnabled(False)
# Update the Tree files and folders
self.browser.configureTree(self.case)
self.case.undoStartGlobal()
class AnalysisFeaturesView(QWidget, Ui_AnalysisFeaturesForm):
"""
Class to open Calculation Features Page.
"""
def __init__(self, parent, case, tree):
"""
Constructor.
"""
QWidget.__init__(self, parent)
Ui_AnalysisFeaturesForm.__init__(self)
self.setupUi(self)
self.case = case
self.browser = tree
self.case.undoStopGlobal()
self.lagr = LagrangianModel(self.case)
self.turb = TurbulenceModel(self.case)
self.gas = GasCombustionModel(self.case)
self.pcoal = CoalCombustionModel(self.case)
self.elect = ElectricalModel(self.case)
self.scal = DefineUserScalarsModel(self.case)
self.std = SteadyManagementModel(self.case)
self.atmo = AtmosphericFlowsModel(self.case)
self.comp = CompressibleModel(self.case)
self.darc = DarcyModel(self.case)
# Set models and number of elements for combo boxes
self.modelSteadyFlow = QtPage.ComboModel(self.comboBoxSteadyFlow,2,1)
self.modelLagrangian = QtPage.ComboModel(self.comboBoxLagrangian,2,1)
self.modelAtmospheric = QtPage.ComboModel(self.comboBoxAtmospheric,4,1)
self.modelGasCombustionModel = QtPage.ComboModel(self.comboBoxGasCombustionModel,3,1)
self.modelPulverizedCoal = QtPage.ComboModel(self.comboBoxPulverizedCoal,3,1)
self.modelJouleEffect = QtPage.ComboModel(self.comboBoxJouleEffect,3,1)
self.modelCompressible = QtPage.ComboModel(self.comboBoxCompressible,3,1)
self.modelDarcy = QtPage.ComboModel(self.comboBoxDarcy,2,1)
self.modelSteadyFlow.addItem(self.tr("steady flow"), "on")
self.modelSteadyFlow.addItem(self.tr("unsteady flow"), "off")
self.modelLagrangian.addItem(self.tr("off"), "single_phase")
self.modelLagrangian.addItem(self.tr("particles and droplets tracking"), "lagrangian")
self.modelAtmospheric.addItem(self.tr("off" ), "off")
self.modelAtmospheric.addItem(self.tr("constant density"), "constant")
self.modelAtmospheric.addItem(self.tr("dry atmosphere" ), "dry")
self.modelAtmospheric.addItem(self.tr("humid atmosphere"), "humid")
self.modelGasCombustionModel.addItem(self.tr("off"), "off")
self.modelGasCombustionModel.addItem(self.tr("perfect premixed flame (Eddy Break-Up)"), "ebu")
self.modelGasCombustionModel.addItem(self.tr("infinitely fast chemistry diffusion flame"), "d3p")
self.modelGasCombustionModel.addItem(self.tr("partial premixed flame (Libby_Williams)"), "lwp")
self.modelPulverizedCoal.addItem(self.tr("off"), "off")
self.modelPulverizedCoal.addItem(self.tr("homogeneous approach"), "homogeneous_fuel")
self.modelPulverizedCoal.addItem(self.tr("homogeneous approach with moisture"), "homogeneous_fuel_moisture")
self.modelPulverizedCoal.addItem(self.tr("homogeneous approach with moisture with Lagrangian transport"), "homogeneous_fuel_moisture_lagr")
self.modelJouleEffect.addItem(self.tr("off"), "off")
self.modelJouleEffect.addItem(self.tr("Joule Effect"), "joule")
self.modelJouleEffect.addItem(self.tr("Joule Effect and Laplace Forces"), "arc")
self.modelCompressible.addItem(self.tr("off"), 'off')
self.modelCompressible.addItem(self.tr("Perfect gas with constant gamma"), 'constant_gamma')
self.modelCompressible.addItem(self.tr("Perfect gas with variable gamma"), 'variable_gamma')
#self.modelCompressible.addItem(self.tr("Van Der Waals"), 'van_der_waals')
self.modelDarcy.addItem(self.tr("off"), 'off')
self.modelDarcy.addItem(self.tr("Darcy model"), 'darcy')
# Connect signals to slots
self.connect(self.comboBoxSteadyFlow, SIGNAL("activated(const QString&)"), self.slotSteadyFlow)
self.connect(self.comboBoxLagrangian, SIGNAL("activated(const QString&)"), self.slotLagrangian)
self.connect(self.comboBoxAtmospheric, SIGNAL("activated(const QString&)"), self.slotAtmospheric)
self.connect(self.comboBoxGasCombustionModel, SIGNAL("activated(const QString&)"), self.slotGasCombustionModel)
self.connect(self.comboBoxPulverizedCoal, SIGNAL("activated(const QString&)"), self.slotPulverizedCoal)
self.connect(self.comboBoxJouleEffect, SIGNAL("activated(const QString&)"), self.slotJouleEffect)
self.connect(self.comboBoxCompressible, SIGNAL("activated(const QString&)"), self.slotCompressibleModel)
self.connect(self.comboBoxDarcy, SIGNAL("activated(const QString&)"), self.slotDarcyModel)
# Initialize Widgets
val = self.std.getSteadyFlowManagement()
if val == 'on':
self.modelSteadyFlow.setItem(str_model='on')
self.modelLagrangian.disableItem(str_model='lagrangian')
else:
self.modelSteadyFlow.setItem(str_model='off')
self.modelLagrangian.enableItem(str_model='lagrangian')
val = self.lagr.getLagrangianStatus()
if val == 'off':
self.modelLagrangian.setItem(str_model='single_phase')
self.modelSteadyFlow.enableItem(str_model='on')
else:
self.modelLagrangian.setItem(str_model='lagrangian')
self.modelSteadyFlow.disableItem(str_model='on')
#self.modelLagrangian.disableItem(str_model='lagrangian')
val = self.atmo.getAtmosphericFlowsModel()
self.modelAtmospheric.setItem(str_model=val)
model = self.gas.getGasCombustionModel()
self.modelGasCombustionModel.setItem(str_model=model)
elec = self.elect.getElectricalModel()
self.modelJouleEffect.setItem(str_model=elec)
compressible = self.comp.getCompressibleModel()
self.modelCompressible.setItem(str_model=compressible)
self.modelCompressible.disableItem(str_model='variable_gamma')
if compressible != 'off':
self.modelSteadyFlow.setItem(str_model='off')
self.comboBoxSteadyFlow.setEnabled(False)
self.comboBoxLagrangian.setEnabled(False)
if self.std.getSteadyFlowManagement() == 'on':
self.comboBoxCompressible.setEnabled(False)
# Multi-phase flow and coal combustion
coal = self.pcoal.getCoalCombustionModel()
self.modelPulverizedCoal.setItem(str_model=coal)
if coal == 'homogeneous_fuel_moisture_lagr':
self.modelLagrangian.setItem(str_model='lagrangian')
self.modelLagrangian.disableItem(str_model='single_phase')
if self.lagr.getLagrangianStatus() == 'off':
self.modelLagrangian.setItem(str_model='single_phase')
self.modelPulverizedCoal.enableItem(str_model='homogeneous_fuel')
self.modelPulverizedCoal.enableItem(str_model='homogeneous_fuel_moisture')
self.modelPulverizedCoal.disableItem(str_model='homogeneous_fuel_moisture_lagr')
else:
self.modelLagrangian.setItem(str_model='lagrangian')
self.modelPulverizedCoal.disableItem(str_model='homogeneous_fuel')
self.modelPulverizedCoal.disableItem(str_model='homogeneous_fuel_moisture')
self.modelPulverizedCoal.enableItem(str_model='homogeneous_fuel_moisture_lagr')
# Compatibility between turbulence model and multi-phases flow model
if self.turb.getTurbulenceModel() not in \
('off', 'k-epsilon', 'k-epsilon-PL',
'Rij-epsilon', 'Rij-SSG', 'Rij-EBRSM', 'v2f-BL-v2/k',
'k-omega-SST', 'Spalart-Allmaras'):
self.modelLagrangian.setItem(str_model='single_phase')
self.comboBoxLagrangian.setEnabled(False)
# Compatibility between turbulence model and reactive flow models
if self.turb.getTurbulenceModel() not in ('k-epsilon',
'k-epsilon-PL',
'Rij-epsilon',
'Rij-SSG',
'Rij-EBRSM',
'v2f-BL-v2/k',
'k-omega-SST',
'Spalart-Allmaras'):
self.modelGasCombustionModel.setItem(str_model='off')
self.modelPulverizedCoal.setItem(str_model='off')
self.modelJouleEffect.setItem(str_model='off')
self.modelGasCombustionModel.disableItem(str_model='ebu')
self.modelGasCombustionModel.disableItem(str_model='d3p')
self.modelGasCombustionModel.disableItem(str_model='lwp')
self.modelPulverizedCoal.disableItem(str_model='homogeneous_fuel')
self.modelPulverizedCoal.disableItem(str_model='homogeneous_fuel_moisture')
self.modelPulverizedCoal.disableItem(str_model='homogeneous_fuel_moisture_lagr')
self.comboBoxGasCombustionModel.setEnabled(False)
self.comboBoxPulverizedCoal.setEnabled(False)
# Update the QComboBox
flame = self.gas.getGasCombustionModel()
coal = self.pcoal.getCoalCombustionModel()
joule = self.elect.getElectricalModel()
atmospheric = self.atmo.getAtmosphericFlowsModel()
compressible = self.comp.getCompressibleModel()
darcy = self.darc.getDarcyModel()
self.modelGasCombustionModel.setItem(str_model=flame)
self.modelPulverizedCoal.setItem(str_model=coal)
self.modelJouleEffect.setItem(str_model=joule)
self.modelAtmospheric.setItem(str_model=atmospheric)
self.modelCompressible.setItem(str_model=compressible)
self.modelDarcy.setItem(str_model=darcy)
# If one model is turned on, the others are turned off
if (flame, coal, joule, atmospheric, compressible, darcy) != ('off', 'off', 'off', 'off', 'off', 'off'):
if flame == 'off':
self.comboBoxGasCombustionModel.setEnabled(False)
if coal == 'off':
self.comboBoxPulverizedCoal.setEnabled(False)
if joule == 'off':
self.comboBoxJouleEffect.setEnabled(False)
if atmospheric == 'off':
self.comboBoxAtmospheric.setEnabled(False)
if compressible == 'off':
self.comboBoxCompressible.setEnabled(False)
if darcy == 'off':
self.comboBoxDarcy.setEnabled(False)
if darcy != 'off':
self.comboBoxSteadyFlow.setEnabled(False)
self.comboBoxLagrangian.setEnabled(False)
# Update the Tree files and folders
self.browser.configureTree(self.case)
self.case.undoStartGlobal()
def __activateComboBox(self):
"""
Private Method.
Change to NORMAL the state of the reactive flow OptionMenu buttons.
"""
self.comboBoxSteadyFlow.setEnabled(True)
self.comboBoxLagrangian.setEnabled(True)
self.comboBoxGasCombustionModel.setEnabled(True)
self.comboBoxPulverizedCoal.setEnabled(True)
self.comboBoxJouleEffect.setEnabled(True)
self.comboBoxAtmospheric.setEnabled(True)
self.comboBoxCompressible.setEnabled(True)
self.comboBoxDarcy.setEnabled(True)
if self.turb.getTurbulenceModel() not in ('k-epsilon',
'k-epsilon-PL',
'Rij-epsilon',
'Rij-SSG',
'Rij-EBRSM',
'v2f-BL-v2/k',
'k-omega-SST',
'Spalart-Allmaras'):
self.comboBoxGasCombustionModel.setEnabled(False)
self.comboBoxPulverizedCoal.setEnabled(False)
self.comboBoxCompressible.setEnabled(False)
def __disableComboBox(self):
"""
Private Method.
Change to DISABLED the state of the reactive flow OptionMenu buttons.
"""
#self.comboBoxSteadyFlow.setEnabled(False)
#self.comboBoxLagrangian.setEnabled(False)
self.comboBoxGasCombustionModel.setEnabled(False)
self.comboBoxPulverizedCoal.setEnabled(False)
self.comboBoxJouleEffect.setEnabled(False)
self.comboBoxAtmospheric.setEnabled(False)
self.comboBoxCompressible.setEnabled(False)
self.comboBoxDarcy.setEnabled(False)
# Update the Tree files and folders
self.browser.configureTree(self.case)
def __stringModelFromCombo(self, name):
"""
Private Method.
Method to get the current item from a QComboBox and returns
the correct string for the model
"""
if not name in ['SteadyFlow',
'Lagrangian',
'Atmospheric',
'GasCombustionModel',
'PulverizedCoal',
'JouleEffect',
'Compressible',
'Darcy']:
log.debug("__stringModelFromCombo() Incorrect name for QComboBox name")
string = ""
else:
combo = eval('self.comboBox' + name)
dico = eval('self.model' + name + '.dicoV2M')
string = dico[str(combo.currentText())]
return string
@pyqtSignature("const QString&")
def slotSteadyFlow(self, text):
"""
Private slot.
Configure tree and update xmlfile beyond the steady or unsteady flow type.
"""
log.debug("slotSteadyFlow")
steady = self.__stringModelFromCombo('SteadyFlow')
if steady == 'on':
self.modelLagrangian.disableItem(str_model='lagrangian')
self.comboBoxCompressible.setEnabled(False)
else:
self.modelLagrangian.enableItem(str_model='lagrangian')
self.comboBoxCompressible.setEnabled(True)
self.std.setSteadyFlowManagement(steady)
self.browser.configureTree(self.case)
@pyqtSignature("const QString&")
def slotLagrangian(self, text):
"""
Private slot.
Put value beyond the multi-phase flow treatment is choosen or not.
"""
if self.__stringModelFromCombo('Lagrangian') == 'single_phase':
val = 'off'
else:
val = 'on'
if val == 'off':
self.modelSteadyFlow.enableItem(str_model='on')
self.modelPulverizedCoal.enableItem(str_model='homogeneous_fuel')
self.modelPulverizedCoal.enableItem(str_model='homogeneous_fuel_moisture')
self.modelPulverizedCoal.disableItem(str_model='homogeneous_fuel_moisture_lagr')
else:
self.modelSteadyFlow.disableItem(str_model='on')
self.modelPulverizedCoal.disableItem(str_model='homogeneous_fuel')
self.modelPulverizedCoal.disableItem(str_model='homogeneous_fuel_moisture')
self.modelPulverizedCoal.enableItem(str_model='homogeneous_fuel_moisture_lagr')
self.lagr.setLagrangianStatus(val)
self.browser.configureTree(self.case)
@pyqtSignature("const QString&")
def slotAtmospheric(self, text):
"""
Called when the comboBoxAtmospheric changed
"""
self.__activateComboBox()
model = self.__stringModelFromCombo('Atmospheric')
self.atmo.setAtmosphericFlowsModel(model)
if model != 'off':
self.__disableComboBox()
self.comboBoxAtmospheric.setEnabled(True)
self.browser.configureTree(self.case)
@pyqtSignature("const QString&")
def slotGasCombustionModel(self, text):
"""
Private slot.
Binding method for gas combustion models.
"""
self.__activateComboBox()
model = self.__stringModelFromCombo('GasCombustionModel')
self.gas.setGasCombustionModel(model)
if model != 'off':
self.__disableComboBox()
self.comboBoxGasCombustionModel.setEnabled(True)
self.browser.configureTree(self.case)
@pyqtSignature("const QString&")
def slotPulverizedCoal(self, text):
"""
Private slot.
Binding method for pulverized coal combustion models
"""
self.__activateComboBox()
model = self.__stringModelFromCombo('PulverizedCoal')
self.pcoal.setCoalCombustionModel(model)
if model == 'homogeneous_fuel_moisture_lagr':
self.modelLagrangian.disableItem(str_model='single_phase')
else:
self.modelLagrangian.enableItem(str_model='single_phase')
if model != 'off':
self.__disableComboBox()
self.comboBoxPulverizedCoal.setEnabled(True)
self.browser.configureTree(self.case)
@pyqtSignature("const QString&")
def slotJouleEffect(self, text):
"""
Private slot.
Binding method for electrical models
"""
self.__activateComboBox()
model = self.__stringModelFromCombo('JouleEffect')
self.elect.setElectricalModel(model)
if model != 'off':
self.__disableComboBox()
self.comboBoxJouleEffect.setEnabled(True)
self.browser.configureTree(self.case)
@pyqtSignature("const QString&")
def slotCompressibleModel(self, text):
"""
Private slot.
Binding method for gas compressible models.
"""
self.__activateComboBox()
model = self.__stringModelFromCombo('Compressible')
self.comp.setCompressibleModel(model)
if model != 'off':
self.__disableComboBox()
self.modelSteadyFlow.setItem(str_model='off')
self.comboBoxSteadyFlow.setEnabled(False)
self.comboBoxLagrangian.setEnabled(False)
self.comboBoxCompressible.setEnabled(True)
else:
self.comboBoxSteadyFlow.setEnabled(True)
self.comboBoxLagrangian.setEnabled(True)
if self.turb.getTurbulenceModel() not in ('k-epsilon',
'k-epsilon-PL',
'Rij-epsilon',
'Rij-SSG',
'Rij-EBRSM',
'v2f-BL-v2/k',
'k-omega-SST',
'Spalart-Allmaras'):
self.comboBoxGasCombustionModel.setEnabled(False)
self.comboBoxPulverizedCoal.setEnabled(False)
self.browser.configureTree(self.case)
@pyqtSignature("const QString&")
def slotDarcyModel(self, text):
"""
Called when the comboBoxDarcy changed
"""
self.__activateComboBox()
model = self.__stringModelFromCombo('Darcy')
self.darc.setDarcyModel(model)
if model != 'off':
self.__disableComboBox()
self.comboBoxDarcy.setEnabled(True)
self.comboBoxSteadyFlow.setEnabled(False)
self.comboBoxLagrangian.setEnabled(False)
title = self.tr("Warning")
msg = self.tr("Darcy module is under development")
QMessageBox.information(self, title, msg)
else:
self.comboBoxCompressible.setEnabled(True)
self.comboBoxGasCombustionModel.setEnabled(True)
self.comboBoxPulverizedCoal.setEnabled(True)
self.browser.configureTree(self.case)
def tr(self, text):
"""
"""
return text
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()
class BoundaryConditionsVelocityInletView(QWidget, Ui_BoundaryConditionsVelocityInletForm):
"""
Boundary condition for velocity in inlet, without particular physics.
"""
def __init__(self, parent):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_BoundaryConditionsVelocityInletForm.__init__(self)
self.setupUi(self)
self.thermodynamic_list = ['Pressure', 'Density', 'Temperature', 'Energy']
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 showWidget(self, boundary):
"""
Show the widget
"""
self.__boundary = boundary
# Initialize velocity
choice = self.__boundary.getVelocityChoice()
self.modelVelocity.setItem(str_model=choice)
self.__updateLabel()
if choice[-7:] == "formula":
self.pushButtonVelocityFormula.setEnabled(True)
self.lineEditVelocity.setEnabled(False)
else:
self.pushButtonVelocityFormula.setEnabled(False)
self.lineEditVelocity.setEnabled(True)
v = self.__boundary.getVelocity()
self.lineEditVelocity.setText(str(v))
# Initialize direction
choice = self.__boundary.getDirectionChoice()
self.modelDirection.setItem(str_model=choice)
text = self.modelDirection.dicoM2V[choice]
if choice == "formula":
self.pushButtonDirectionFormula.setEnabled(True)
self.frameDirectionCoordinates.hide()
elif choice == "coordinates":
self.pushButtonDirectionFormula.setEnabled(False)
self.frameDirectionCoordinates.show()
v = self.__boundary.getDirection('direction_x')
self.lineEditDirectionX.setText(str(v))
v = self.__boundary.getDirection('direction_y')
self.lineEditDirectionY.setText(str(v))
v = self.__boundary.getDirection('direction_z')
self.lineEditDirectionZ.setText(str(v))
elif choice == "normal":
self.pushButtonDirectionFormula.setEnabled(False)
self.frameDirectionCoordinates.hide()
self.initialize()
def initialize(self):
"""
Initialize widget for compressible
"""
self.comboBoxVelocity.show()
self.lineEditVelocity.show()
self.labelUnitVelocity.show()
self.pushButtonVelocityFormula.show()
# Initialize thermodynamic value
if self.mdl.getCompressibleModel() != 'off':
inlet_type = self.__boundary.getInletType()
self.modelTypeInlet.setItem(str_model = inlet_type)
self.__boundary.setInletType(inlet_type)
if inlet_type == 'imposed_inlet':
self.groupBoxThermodynamic.show()
self.frameDensity.hide()
for name in self.thermodynamic_list:
__checkBox = getattr(self, "checkBox" + name)
__lineEdit = getattr(self, "lineEdit" + name)
__checkBox.setChecked(False)
__checkBox.setEnabled(False)
__lineEdit.setEnabled(False)
__lineEdit.clear()
box_list = self.__boundary.getCheckedBoxList()
if len(box_list) == 0:
for name in self.thermodynamic_list:
__checkBox = getattr(self, "checkBox" + name)
__lineEdit = getattr(self, "lineEdit" + name)
__checkBox.setEnabled(True)
elif len(box_list) == 1:
for name in self.thermodynamic_list:
__checkBox = getattr(self, "checkBox" + name)
__lineEdit = getattr(self, "lineEdit" + name)
__checkBox.setEnabled(True)
box = box_list[0]
if box == 'Temperature':
self.checkBoxEnergy.setEnabled(False)
elif box == 'Energy':
self.checkBoxTemperature.setEnabled(False)
__checkBox = getattr(self, "checkBox" + box)
__checkBox.setChecked(True)
__lineEdit = getattr(self, "lineEdit" + box)
__lineEdit.setEnabled(True)
v1 = self.__boundary.getListValue()[0]
__lineEdit.setText(str(v1))
elif len(box_list) == 2:
v1,v2 = self.__boundary.getListValue()
for name in box_list:
__checkBox = getattr(self, "checkBox" + name)
__lineEdit = getattr(self, "lineEdit" + name)
__checkBox.setEnabled(True)
__checkBox.setChecked(True)
__lineEdit.setEnabled(True)
if v1 >= 0.:
__lineEdit.setText(str(v1))
else:
__lineEdit.setText(str(v2))
v1 = -1.
elif inlet_type == 'subsonic_inlet_PH':
self.comboBoxVelocity.hide()
self.lineEditVelocity.hide()
self.labelUnitVelocity.hide()
self.pushButtonVelocityFormula.hide()
self.groupBoxThermodynamic.hide()
self.frameDensity.show()
pressure = self.__boundary.getThermoValue('total_pressure')
self.lineEditTotalPressure.setText(str(pressure))
enthalpy = self.__boundary.getThermoValue('enthalpy')
self.lineEditTotalEnthalpy.setText(str(enthalpy))
else:
self.groupBoxCompressible.hide()
# Initialize temperature and mean mixture fraction
model = self.gas.getGasCombustionModel()
if model != 'off':
self.groupBoxGasCombustion.show()
inlet_type = self.__boundary.getInletGasCombustionType()
self.modelTypeInletGasComb.setItem(str_model = inlet_type)
if model == 'd3p':
self.lineEditTemperatureGasComb.hide()
self.labelTemperature_2.hide()
self.labelUnitTemp.hide()
self.lineEditFraction.setEnabled(False)
f = self.__boundary.setMeanMixtureFraction(1)
self.lineEditFraction.setText(str(1) if inlet_type == 'oxydant' else str(0))
else :
self.lineEditTemperatureGasComb.show()
self.labelTemperature_2.show()
self.labelUnitTemp.show()
t = self.__boundary.getGasCombustionTemperature()
self.lineEditTemperatureGasComb.setText(str(t))
self.lineEditFraction.setEnabled(True)
f = self.__boundary.getMeanMixtureFraction()
self.lineEditFraction.setText(str(f))
else:
self.groupBoxGasCombustion.hide()
self.show()
def hideWidget(self):
"""
Hide all
"""
self.hide()
@pyqtSlot(str)
def __slotChoiceVelocity(self, text):
"""
Private slot.
Input the velocity boundary type choice (norm, ).
@type text: C{QString}
@param text: velocity boundary type choice.
"""
c = self.modelVelocity.dicoV2M[str(text)]
log.debug("slotChoiceVelocity: %s " % c)
self.__boundary.setVelocityChoice(c)
if c[-7:] == "formula":
self.pushButtonVelocityFormula.setEnabled(True)
exp = self.__boundary.getVelocity()
if exp:
self.pushButtonVelocityFormula.setStyleSheet("background-color: green")
self.pushButtonVelocityFormula.setToolTip(exp)
else:
self.pushButtonVelocityFormula.setStyleSheet("background-color: red")
self.lineEditVelocity.setEnabled(False)
self.lineEditVelocity.setText("")
else:
self.pushButtonVelocityFormula.setEnabled(False)
self.pushButtonVelocityFormula.setStyleSheet("background-color: None")
self.lineEditVelocity.setEnabled(True)
v = self.__boundary.getVelocity()
self.lineEditVelocity.setText(str(v))
self.__updateLabel()
def __updateLabel(self):
"""
Update the unit for the velocity specification.
"""
c = self.__boundary.getVelocityChoice()
if c in ('norm', 'norm_formula'):
self.labelUnitVelocity.setText(str('m/s'))
elif c in ('flow1', 'flow1_formula'):
self.labelUnitVelocity.setText(str('kg/s'))
elif c in ('flow2', 'flow2_formula'):
self.labelUnitVelocity.setText(str('m<sup>3</sup>/s'))
@pyqtSlot(str)
def __slotVelocityValue(self, text):
"""
Private slot.
New value associated to the velocity boundary type.
@type text: C{QString}
@param text: value
"""
if self.lineEditVelocity.validator().state == QValidator.Acceptable:
v = from_qvariant(text, float)
self.__boundary.setVelocity(v)
@pyqtSlot()
def __slotVelocityFormula(self):
"""
"""
exp = self.__boundary.getVelocity()
c = self.__boundary.getVelocityChoice()
if c == 'norm_formula':
exa = "u_norm = 1.0;"
req = [('u_norm', 'Norm of the velocity')]
elif c == 'flow1_formula':
exa = "q_m = 1.0;"
req = [('q_m', 'mass flow rate')]
elif c == 'flow2_formula':
exa = "q_v = 1.0;"
req = [('q_v', 'volumic flow rate')]
sym = [('x', "X face's gravity center"),
('y', "Y face's gravity center"),
('z', "Z face's gravity center"),
('dt', 'time step'),
('t', 'current time'),
('iter', 'number of iteration')]
for (nme, val) in self.notebook.getNotebookList():
sym.append((nme, 'value (notebook) = ' + str(val)))
dialog = QMeiEditorView(self,
check_syntax = self.__case['package'].get_check_syntax(),
expression = exp,
required = req,
symbols = sym,
examples = exa)
if dialog.exec_():
result = dialog.get_result()
log.debug("slotFormulaVelocity -> %s" % str(result))
self.__boundary.setVelocity(str(result))
self.pushButtonVelocityFormula.setStyleSheet("background-color: green")
self.pushButtonVelocityFormula.setToolTip(result)
@pyqtSlot(str)
def __slotChoiceDirection(self, text):
"""
Input the direction type choice.
"""
c = self.modelDirection.dicoV2M[str(text)]
log.debug("slotChoiceVelocity: %s " % c)
self.__boundary.setDirectionChoice(c)
if c == "formula":
self.pushButtonDirectionFormula.setEnabled(True)
exp = self.__boundary.getDirection('direction_formula')
if exp:
self.pushButtonDirectionFormula.setStyleSheet("background-color: green")
self.pushButtonDirectionFormula.setToolTip(exp)
else:
self.pushButtonDirectionFormula.setStyleSheet("background-color: red")
self.frameDirectionCoordinates.hide()
elif c == "coordinates":
self.pushButtonDirectionFormula.setEnabled(False)
self.pushButtonDirectionFormula.setStyleSheet("background-color: None")
self.frameDirectionCoordinates.show()
v = self.__boundary.getDirection('direction_x')
self.lineEditDirectionX.setText(str(v))
v = self.__boundary.getDirection('direction_y')
self.lineEditDirectionY.setText(str(v))
v = self.__boundary.getDirection('direction_z')
self.lineEditDirectionZ.setText(str(v))
elif c == "normal":
self.pushButtonDirectionFormula.setEnabled(False)
self.pushButtonDirectionFormula.setStyleSheet("background-color: None")
self.frameDirectionCoordinates.hide()
@pyqtSlot(str)
def __slotDirX(self, text):
"""
INPUT value into direction of inlet flow
"""
if self.sender().validator().state == QValidator.Acceptable:
value = from_qvariant(text, float)
self.__boundary.setDirection('direction_x', value)
@pyqtSlot(str)
def __slotDirY(self, text):
"""
INPUT value into direction of inlet flow
"""
if self.sender().validator().state == QValidator.Acceptable:
value = from_qvariant(text, float)
self.__boundary.setDirection('direction_y', value)
@pyqtSlot(str)
def __slotDirZ(self, text):
"""
INPUT value into direction of inlet flow
"""
if self.sender().validator().state == QValidator.Acceptable:
value = from_qvariant(text, float)
self.__boundary.setDirection('direction_z', value)
@pyqtSlot()
def __slotDirectionFormula(self):
"""
"""
exp = self.__boundary.getDirection('direction_formula')
req = [('dir_x', 'Direction of the flow along X'),
('dir_y', 'Direction of the flow along Y'),
('dir_z', 'Direction of the flow along Z')]
exa = "dir_x = 3.0;\ndir_y = 1.0;\ndir_z = 0.0;\n"
sym = [('x', "X face's gravity center"),
('y', "Y face's gravity center"),
('z', "Z face's gravity center"),
('dt', 'time step'),
('t', 'current time'),
('iter', 'number of iteration')]
for (nme, val) in self.notebook.getNotebookList():
sym.append((nme, 'value (notebook) = ' + str(val)))
dialog = QMeiEditorView(self,
check_syntax = self.__case['package'].get_check_syntax(),
expression = exp,
required = req,
symbols = sym,
examples = exa)
if dialog.exec_():
result = dialog.get_result()
log.debug("slotFormulaDirection -> %s" % str(result))
self.__boundary.setDirection('direction_formula', str(result))
self.pushButtonDirectionFormula.setToolTip(result)
self.pushButtonDirectionFormula.setStyleSheet("background-color: green")
@pyqtSlot(str)
def __slotInletType(self, text):
"""
INPUT inlet type : 'oxydant'/'fuel' or 'burned'/'unburned'
"""
value = self.modelTypeInlet.dicoV2M[str(text)]
log.debug("__slotInletType value = %s " % value)
self.__boundary.setInletType(value)
self.initialize()
@pyqtSlot()
def __slotPressure(self):
"""
Pressure selected or not for the initialisation.
"""
if self.checkBoxPressure.isChecked():
self.__boundary.setThermoStatus('pressure', "on")
else:
self.__boundary.setThermoStatus('pressure', "off")
self.initialize()
@pyqtSlot()
def __slotDensity(self):
"""
Density selected or not for the initialisation.
"""
if self.checkBoxDensity.isChecked():
self.__boundary.setThermoStatus('density', "on")
else:
self.__boundary.setThermoStatus('density', "off")
self.initialize()
@pyqtSlot()
def __slotTemperature(self):
"""
Temperature selected or not for the initialisation.
"""
if self.checkBoxTemperature.isChecked():
self.__boundary.setThermoStatus('temperature', "on")
else:
self.__boundary.setThermoStatus('temperature', "off")
self.initialize()
@pyqtSlot()
def __slotEnergy(self):
"""
Energy selected or not for the initialisation.
"""
if self.checkBoxEnergy.isChecked():
self.__boundary.setThermoStatus('energy', "on")
else:
self.__boundary.setThermoStatus('energy', "off")
self.initialize()
@pyqtSlot(str)
def __slotPressureValue(self, text):
"""
INPUT inlet Pressure
"""
if self.sender().validator().state == QValidator.Acceptable:
t = from_qvariant(text, float)
self.__boundary.setThermoValue('pressure', t)
@pyqtSlot(str)
def __slotDensityValue(self, text):
"""
INPUT inlet Density
"""
if self.sender().validator().state == QValidator.Acceptable:
t = from_qvariant(text, float)
self.__boundary.setThermoValue('density', t)
@pyqtSlot(str)
def __slotTemperatureValue(self, text):
"""
INPUT inlet Temperature
"""
if self.sender().validator().state == QValidator.Acceptable:
t = from_qvariant(text, float)
self.__boundary.setThermoValue('temperature', t)
@pyqtSlot(str)
def __slotEnergyValue(self, text):
"""
INPUT inlet Energy
"""
if self.sender().validator().state == QValidator.Acceptable:
t = from_qvariant(text, float)
self.__boundary.setThermoValue('energy', t)
@pyqtSlot(str)
def __slotTotalPressure(self, text):
"""
INPUT inlet total pressure
"""
if self.sender().validator().state == QValidator.Acceptable:
t = from_qvariant(text, float)
self.__boundary.setThermoValue('total_pressure', t)
@pyqtSlot(str)
def __slotTotalEnthalpy(self, text):
"""
INPUT inlet total enthalpy
"""
if self.sender().validator().state == QValidator.Acceptable:
t = from_qvariant(text, float)
self.__boundary.setThermoValue('enthalpy', t)
@pyqtSlot(str)
def __slotTemperatureGasComb(self, text):
"""
INPUT inlet temperature
"""
if self.sender().validator().state == QValidator.Acceptable:
t = from_qvariant(text, float)
self.__boundary.setGasCombustionTemperature(t)
@pyqtSlot(str)
def __slotMeanMixtureFraction(self, text):
"""
INPUT inlet mean mixutre fraction
"""
if self.sender().validator().state == QValidator.Acceptable:
f = from_qvariant(text, float)
self.__boundary.setMeanMixtureFraction(f)
@pyqtSlot(str)
def __slotInletTypeGasComb(self, text):
"""
INPUT inlet type : 'oxydant'/'fuel' or 'burned'/'unburned'
"""
value = self.modelTypeInletGasComb.dicoV2M[str(text)]
log.debug("__slotInletTypeGasComb value = %s " % value)
self.__boundary.setInletGasCombustionType(value)
self.initialize()
def tr(self, text):
"""
Translation
"""
return text
def __init__(self, parent, case, stbar):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_InitializationForm.__init__(self)
self.setupUi(self)
self.case = case
self.parent = parent
self.case.undoStopGlobal()
self.init = InitializationModel(self.case)
self.turb = TurbulenceModel(self.case)
self.therm = ThermalScalarModel(self.case)
self.th_sca = DefineUserScalarsModel(self.case)
self.comp = CompressibleModel(self.case)
self.volzone = LocalizationModel('VolumicZone', self.case)
# create group to control hide/show options
self.turb_group = [self.labelTurbulence, self.pushButtonTurbulence,
self.comboBoxTurbulence]
self.thermal_group = [self.labelThermal, self.pushButtonThermal]
self.species_group = [self.labelSpecies, self.comboBoxSpecies, self.pushButtonSpecies]
self.meteo_group = [self.labelMeteo, self.comboBoxMeteo, self.pushButtonMeteo]
self.thermodynamic_list = ['Pressure', 'Density', 'Temperature', 'Energy']
# 1/ Combo box models
self.modelZone = ComboModel(self.comboBoxZone, 1, 1)
if self.comp.getCompressibleModel() != 'off':
self.groupBoxThermodynamic.show()
else:
self.groupBoxThermodynamic.hide()
self.zone = ""
zones = self.volzone.getZones()
for zone in zones:
if zone.getNature()['initialization'] == "on":
label = zone.getLabel()
name = str(zone.getCodeNumber())
self.modelZone.addItem(self.tr(label), name)
if label == "all_cells":
self.zone = name
if not self.zone:
self.zone = name
self.modelZone.setItem(str_model = self.zone)
self.modelTurbulence = ComboModel(self.comboBoxTurbulence, 2, 1)
self.modelTurbulence.addItem(self.tr("Initialization by formula"), 'formula')
self.modelTurbulence.addItem(self.tr("Initialization by reference value(s)"), 'reference_value')
# 2/ Connections
self.connect(self.comboBoxZone, SIGNAL("activated(const QString&)"), self.slotZone)
self.connect(self.comboBoxTurbulence, SIGNAL("activated(const QString&)"), self.slotChoice)
self.connect(self.comboBoxSpecies, SIGNAL("activated(const QString&)"), self.slotSpeciesChoice)
self.connect(self.comboBoxMeteo, SIGNAL("activated(const QString&)"), self.slotMeteoChoice)
self.connect(self.checkBoxPressure, SIGNAL("clicked()"), self.slotPressure)
self.connect(self.checkBoxDensity, SIGNAL("clicked()"), self.slotDensity)
self.connect(self.checkBoxTemperature, SIGNAL("clicked()"), self.slotTemperature)
self.connect(self.checkBoxEnergy, SIGNAL("clicked()"), self.slotEnergy)
self.connect(self.pushButtonVelocity, SIGNAL("clicked()"), self.slotVelocityFormula)
self.connect(self.pushButtonThermal, SIGNAL("clicked()"), self.slotThermalFormula)
self.connect(self.pushButtonTurbulence, SIGNAL("clicked()"), self.slotTurbulenceFormula)
self.connect(self.pushButtonSpecies, SIGNAL("clicked()"), self.slotSpeciesFormula)
self.connect(self.pushButtonMeteo, SIGNAL("clicked()"), self.slotMeteoFormula)
self.connect(self.pushButtonPressure, SIGNAL("clicked()"), self.slotPressureFormula)
self.connect(self.pushButtonDensity, SIGNAL("clicked()"), self.slotDensityFormula)
self.connect(self.pushButtonTemperature,SIGNAL("clicked()"), self.slotTemperatureFormula)
self.connect(self.pushButtonEnergy, SIGNAL("clicked()"), self.slotEnergyFormula)
self.connect(self.pushButtonPressure_2, SIGNAL("clicked()"), self.slotPressureFormula)
choice = self.init.getInitialTurbulenceChoice(self.zone)
self.modelTurbulence.setItem(str_model = choice)
# species treatment
self.modelSpecies = ComboModel(self.comboBoxSpecies, 1, 1)
self.scalar = ""
scalar_list = self.th_sca.getUserScalarNameList()
for s in self.th_sca.getScalarsVarianceList():
if s in scalar_list: scalar_list.remove(s)
if scalar_list != []:
self.scalar = scalar_list[0]
for item in self.species_group:
item.show()
for scalar in scalar_list:
self.modelSpecies.addItem(self.tr(scalar), scalar)
self.modelSpecies.setItem(str_model = self.scalar)
setGreenColor(self.pushButtonSpecies, True)
else:
for item in self.species_group:
item.hide()
# meteo
self.modelMeteo = ComboModel(self.comboBoxMeteo, 1, 1)
self.scalar_meteo = ""
scalar_meteo_list = DefineUserScalarsModel( self.case).getMeteoScalarsNameList()
if scalar_meteo_list != None and scalar_meteo_list != []:
self.scalar_meteo = scalar_meteo_list[0]
for item in self.meteo_group:
item.show()
for scalar in scalar_meteo_list:
self.modelMeteo.addItem(self.tr(scalar), scalar)
self.modelMeteo.setItem(str_model = self.scalar_meteo)
setGreenColor(self.pushButtonMeteo, True)
else:
for item in self.meteo_group:
item.hide()
if DarcyModel(self.case).getDarcyModel() == "off":
self.labelpressure.hide()
self.pushButtonPressure_2.hide()
else:
setGreenColor(self.pushButtonPressure_2, True)
# Initialize widget
self.initializeVariables(self.zone)
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)
# Connections
self.connect(self.comboBoxVelocity, SIGNAL("activated(const QString&)"), self.__slotChoiceVelocity)
self.connect(self.lineEditVelocity, SIGNAL("textChanged(const QString &)"), self.__slotVelocityValue)
self.connect(self.comboBoxDirection, SIGNAL("activated(const QString&)"), self.__slotChoiceDirection)
self.connect(self.lineEditDirectionX, SIGNAL("textChanged(const QString &)"), self.__slotDirX)
self.connect(self.lineEditDirectionY, SIGNAL("textChanged(const QString &)"), self.__slotDirY)
self.connect(self.lineEditDirectionZ, SIGNAL("textChanged(const QString &)"), self.__slotDirZ)
self.connect(self.comboBoxTypeInlet, SIGNAL("activated(const QString&)"), self.__slotInletType)
self.connect(self.checkBoxPressure, SIGNAL("clicked()"), self.__slotPressure)
self.connect(self.checkBoxDensity, SIGNAL("clicked()"), self.__slotDensity)
self.connect(self.checkBoxTemperature, SIGNAL("clicked()"), self.__slotTemperature)
self.connect(self.checkBoxEnergy, SIGNAL("clicked()"), self.__slotEnergy)
self.connect(self.lineEditPressure, SIGNAL("textChanged(const QString &)"), self.__slotPressureValue)
self.connect(self.lineEditDensity, SIGNAL("textChanged(const QString &)"), self.__slotDensityValue)
self.connect(self.lineEditTotalPressure, SIGNAL("textChanged(const QString &)"), self.__slotTotalPressure)
self.connect(self.lineEditTotalEnthalpy, SIGNAL("textChanged(const QString &)"), self.__slotTotalEnthalpy)
self.connect(self.lineEditTemperature, SIGNAL("textChanged(const QString &)"), self.__slotTemperatureValue)
self.connect(self.lineEditEnergy, SIGNAL("textChanged(const QString &)"), self.__slotEnergyValue)
self.connect(self.comboBoxTypeInletGasComb, SIGNAL("activated(const QString&)"), self.__slotInletTypeGasComb)
self.connect(self.lineEditTemperatureGasComb, SIGNAL("textChanged(const QString &)"), self.__slotTemperatureGasComb)
self.connect(self.lineEditFraction, SIGNAL("textChanged(const QString &)"), 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.connect(self.pushButtonVelocityFormula, SIGNAL("clicked()"), self.__slotVelocityFormula)
self.connect(self.pushButtonDirectionFormula, SIGNAL("clicked()"), self.__slotDirectionFormula)
self.__case.undoStartGlobal()
class InitializationView(QWidget, Ui_InitializationForm):
"""
"""
def __init__(self, parent, case, stbar):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_InitializationForm.__init__(self)
self.setupUi(self)
self.case = case
self.parent = parent
self.case.undoStopGlobal()
self.init = InitializationModel(self.case)
self.turb = TurbulenceModel(self.case)
self.therm = ThermalScalarModel(self.case)
self.th_sca = DefineUserScalarsModel(self.case)
self.comp = CompressibleModel(self.case)
self.volzone = LocalizationModel('VolumicZone', self.case)
# create group to control hide/show options
self.turb_group = [self.labelTurbulence, self.pushButtonTurbulence,
self.comboBoxTurbulence]
self.thermal_group = [self.labelThermal, self.pushButtonThermal]
self.species_group = [self.labelSpecies, self.comboBoxSpecies, self.pushButtonSpecies]
self.meteo_group = [self.labelMeteo, self.comboBoxMeteo, self.pushButtonMeteo]
self.thermodynamic_list = ['Pressure', 'Density', 'Temperature', 'Energy']
# 1/ Combo box models
self.modelZone = ComboModel(self.comboBoxZone, 1, 1)
if self.comp.getCompressibleModel() != 'off':
self.groupBoxThermodynamic.show()
else:
self.groupBoxThermodynamic.hide()
self.zone = ""
zones = self.volzone.getZones()
for zone in zones:
if zone.getNature()['initialization'] == "on":
label = zone.getLabel()
name = str(zone.getCodeNumber())
self.modelZone.addItem(self.tr(label), name)
if label == "all_cells":
self.zone = name
if not self.zone:
self.zone = name
self.modelZone.setItem(str_model = self.zone)
self.modelTurbulence = ComboModel(self.comboBoxTurbulence, 2, 1)
self.modelTurbulence.addItem(self.tr("Initialization by formula"), 'formula')
self.modelTurbulence.addItem(self.tr("Initialization by reference value(s)"), 'reference_value')
# 2/ Connections
self.connect(self.comboBoxZone, SIGNAL("activated(const QString&)"), self.slotZone)
self.connect(self.comboBoxTurbulence, SIGNAL("activated(const QString&)"), self.slotChoice)
self.connect(self.comboBoxSpecies, SIGNAL("activated(const QString&)"), self.slotSpeciesChoice)
self.connect(self.comboBoxMeteo, SIGNAL("activated(const QString&)"), self.slotMeteoChoice)
self.connect(self.checkBoxPressure, SIGNAL("clicked()"), self.slotPressure)
self.connect(self.checkBoxDensity, SIGNAL("clicked()"), self.slotDensity)
self.connect(self.checkBoxTemperature, SIGNAL("clicked()"), self.slotTemperature)
self.connect(self.checkBoxEnergy, SIGNAL("clicked()"), self.slotEnergy)
self.connect(self.pushButtonVelocity, SIGNAL("clicked()"), self.slotVelocityFormula)
self.connect(self.pushButtonThermal, SIGNAL("clicked()"), self.slotThermalFormula)
self.connect(self.pushButtonTurbulence, SIGNAL("clicked()"), self.slotTurbulenceFormula)
self.connect(self.pushButtonSpecies, SIGNAL("clicked()"), self.slotSpeciesFormula)
self.connect(self.pushButtonMeteo, SIGNAL("clicked()"), self.slotMeteoFormula)
self.connect(self.pushButtonPressure, SIGNAL("clicked()"), self.slotPressureFormula)
self.connect(self.pushButtonDensity, SIGNAL("clicked()"), self.slotDensityFormula)
self.connect(self.pushButtonTemperature,SIGNAL("clicked()"), self.slotTemperatureFormula)
self.connect(self.pushButtonEnergy, SIGNAL("clicked()"), self.slotEnergyFormula)
self.connect(self.pushButtonPressure_2, SIGNAL("clicked()"), self.slotPressureFormula)
choice = self.init.getInitialTurbulenceChoice(self.zone)
self.modelTurbulence.setItem(str_model = choice)
# species treatment
self.modelSpecies = ComboModel(self.comboBoxSpecies, 1, 1)
self.scalar = ""
scalar_list = self.th_sca.getUserScalarNameList()
for s in self.th_sca.getScalarsVarianceList():
if s in scalar_list: scalar_list.remove(s)
if scalar_list != []:
self.scalar = scalar_list[0]
for item in self.species_group:
item.show()
for scalar in scalar_list:
self.modelSpecies.addItem(self.tr(scalar), scalar)
self.modelSpecies.setItem(str_model = self.scalar)
setGreenColor(self.pushButtonSpecies, True)
else:
for item in self.species_group:
item.hide()
# meteo
self.modelMeteo = ComboModel(self.comboBoxMeteo, 1, 1)
self.scalar_meteo = ""
scalar_meteo_list = DefineUserScalarsModel( self.case).getMeteoScalarsNameList()
if scalar_meteo_list != None and scalar_meteo_list != []:
self.scalar_meteo = scalar_meteo_list[0]
for item in self.meteo_group:
item.show()
for scalar in scalar_meteo_list:
self.modelMeteo.addItem(self.tr(scalar), scalar)
self.modelMeteo.setItem(str_model = self.scalar_meteo)
setGreenColor(self.pushButtonMeteo, True)
else:
for item in self.meteo_group:
item.hide()
if DarcyModel(self.case).getDarcyModel() == "off":
self.labelpressure.hide()
self.pushButtonPressure_2.hide()
else:
setGreenColor(self.pushButtonPressure_2, True)
# Initialize widget
self.initializeVariables(self.zone)
self.case.undoStartGlobal()
@pyqtSignature("const QString&")
def slotZone(self, text):
"""
INPUT label for choice of zone
"""
self.zone = self.modelZone.dicoV2M[str(text)]
self.initializeVariables(self.zone)
@pyqtSignature("const QString&")
def slotChoice(self, text):
"""
INPUT choice of method of initialization
"""
choice = self.modelTurbulence.dicoV2M[str(text)]
log.debug("slotChoice choice = %s "%str(choice))
self.init.setInitialTurbulenceChoice(self.zone, choice)
turb_model = self.turb.getTurbulenceModel()
self.initializeVariables(self.zone)
@pyqtSignature("const QString&")
def slotMeteoChoice(self, text):
"""
INPUT label for choice of zone
"""
self.scalar_meteo= self.modelMeteo.dicoV2M[str(text)]
self.initializeVariables(self.zone)
setGreenColor(self.pushButtonMeteo, True)
@pyqtSignature("const QString&")
def slotSpeciesChoice(self, text):
"""
INPUT label for choice of zone
"""
self.scalar= self.modelSpecies.dicoV2M[str(text)]
self.initializeVariables(self.zone)
setGreenColor(self.pushButtonSpecies, True)
@pyqtSignature("const QString&")
def slotVelocityFormula(self):
"""
"""
exp = self.init.getVelocityFormula(self.zone)
if not exp:
exp = self.init.getDefaultVelocityFormula()
exa = """#example: \n""" + self.init.getDefaultVelocityFormula()
req = [('velocity[0]', "velocity"),
('velocity[1]', "velocity"),
('velocity[2]', "velocity")]
sym = [('x', 'cell center coordinate'),
('y', 'cell center coordinate'),
('z', 'cell center coordinate')]
dialog = QMeiEditorView(self,
check_syntax = self.case['package'].get_check_syntax(),
expression = exp,
required = req,
symbols = sym,
examples = exa)
if dialog.exec_():
result = dialog.get_result()
log.debug("slotFormulaVelocity -> %s" % str(result))
self.init.setVelocityFormula(self.zone, result)
setGreenColor(self.sender(), False)
@pyqtSignature("")
def slotTurbulenceFormula(self):
"""
INPUT user formula
"""
turb_model = self.turb.getTurbulenceModel()
exa = """#example \n""" + self.init.getDefaultTurbFormula(turb_model)
exp = self.init.getTurbFormula(self.zone, turb_model)
sym = [('rho0', 'density (reference value)'),
('mu0', 'viscosity (reference value)'),
('cp0', 'specific heat (reference value)'),
('lambda0', 'thermal conductivity (reference value)'),
('x','cell center coordinate'),
('y','cell center coordinate'),
('z','cell center coordinate'),
('uref','reference velocity'),
('almax','reference length')]
if turb_model in ('k-epsilon', 'k-epsilon-PL'):
req = [('k', "turbulent energy"),
('epsilon', "turbulent dissipation")]
elif turb_model in ('Rij-epsilon', 'Rij-SSG'):
req = [('r11', "Reynolds stress R11"),
('r22', "Reynolds stress R22"),
('r33', "Reynolds stress R33"),
('r12', "Reynolds stress R12"),
('r23', "Reynolds stress R23"),
('r13', "Reynolds stress R13"),
('epsilon', "turbulent dissipation")]
elif turb_model == 'Rij-EBRSM':
req = [('r11', "Reynolds stress R11"),
('r22', "Reynolds stress R22"),
('r33', "Reynolds stress R33"),
('r12', "Reynolds stress R12"),
('r23', "Reynolds stress R23"),
('r13', "Reynolds stress R13"),
('epsilon', "turbulent dissipation"),
('alpha', "alpha")]
elif turb_model == 'v2f-BL-v2/k':
req = [('k', "turbulent energy"),
('epsilon', "turbulent dissipation"),
('phi', "variable phi in v2f model"),
('alpha', "variable alpha in v2f model")]
elif turb_model == 'k-omega-SST':
req = [('k', "turbulent energy"),
('omega', "specific dissipation rate")]
elif turb_model == 'Spalart-Allmaras':
req = [('nu_tilda', "nusa")]
dialog = QMeiEditorView(self,
check_syntax = self.case['package'].get_check_syntax(),
expression = exp,
required = req,
symbols = sym,
examples = exa)
if dialog.exec_():
result = dialog.get_result()
log.debug("slotFormulaTurb -> %s" % str(result))
self.init.setTurbFormula(self.zone, result)
setGreenColor(self.sender(), False)
@pyqtSignature("const QString&")
def slotThermalFormula(self):
"""
Input the initial formula of thermal scalar
"""
exp = self.init.getThermalFormula(self.zone)
if not exp:
exp = self.init.getDefaultThermalFormula()
exa = """#example \n""" + self.init.getDefaultThermalFormula()
if self.therm.getThermalScalarModel() == "enthalpy":
req = [('enthalpy', 'enthalpy')]
elif self.therm.getThermalScalarModel() == "total_energy":
req = [('total_energy', 'total energy')]
else:
req = [('temperature', 'temperature')]
sym = [('x', 'cell center coordinate'),
('y', 'cell center coordinate'),
('z', 'cell center coordinate')]
dialog = QMeiEditorView(self,
check_syntax = self.case['package'].get_check_syntax(),
expression = exp,
required = req,
symbols = sym,
examples = exa)
if dialog.exec_():
result = dialog.get_result()
log.debug("slotFormulaThermal -> %s" % str(result))
self.init.setThermalFormula(self.zone, result)
setGreenColor(self.sender(), False)
@pyqtSignature("const QString&")
def slotSpeciesFormula(self):
"""
Input the initial formula of species
"""
exp = self.init.getSpeciesFormula(self.zone, self.scalar)
name = self.th_sca.getScalarName(self.scalar)
if not exp:
exp = str(name)+""" = 0;\n"""
exa = """#example: \n""" + str(name)+""" = 0;\n"""
req = [(str(name), str(name))]
sym = [('x', 'cell center coordinate'),
('y', 'cell center coordinate'),
('z', 'cell center coordinate')]
dialog = QMeiEditorView(self,
check_syntax = self.case['package'].get_check_syntax(),
expression = exp,
required = req,
symbols = sym,
examples = exa)
if dialog.exec_():
result = dialog.get_result()
log.debug("slotFormulaSpecies -> %s" % str(result))
self.init.setSpeciesFormula(self.zone, self.scalar, result)
setGreenColor(self.sender(), False)
@pyqtSignature("const QString&")
def slotMeteoFormula(self):
"""
"""
exp = self.init.getMeteoFormula(self.zone, self.scalar_meteo)
name = self.scalar_meteo
if not exp:
exp = str(name)+""" = 0;\n"""
exa = """#example: \n""" + str(name)+""" = 0;\n"""
req = [(str(name), str(name))]
sym = [('x', 'cell center coordinate'),
('y', 'cell center coordinate'),
('z', 'cell center coordinate')]
dialog = QMeiEditorView(self,
check_syntax = self.case['package'].get_check_syntax(),
expression = exp,
required = req,
symbols = sym,
examples = exa)
if dialog.exec_():
result = dialog.get_result()
log.debug("slotFormulaMeteo -> %s" % str(result))
self.init.setMeteoFormula(self.zone, self.scalar_meteo, result)
setGreenColor(self.sender(), False)
@pyqtSignature("")
def slotPressure(self):
"""
Pressure selected or not for the initialisation.
"""
if self.checkBoxPressure.isChecked():
self.init.setPressureStatus(self.zone,"on")
box_list = self.init.getCheckedBoxList(self.zone)
self.pushButtonPressure.setEnabled(True)
setGreenColor(self.pushButtonPressure,True)
if len(box_list) == 2:
for name in self.thermodynamic_list:
if name not in box_list:
__checkBox = getattr(self, "checkBox" + name)
__checkBox.setEnabled(False)
else:
self.init.setPressureStatus(self.zone,"off")
box_list = self.init.getCheckedBoxList(self.zone)
self.pushButtonPressure.setEnabled(False)
setGreenColor(self.pushButtonPressure,False)
if len(box_list) == 1:
for name in self.thermodynamic_list:
if name != 'Pressure':
__checkBox = getattr(self, "checkBox" + name)
__checkBox.setEnabled(True)
if box_list[0] =='Energy':
self.checkBoxTemperature.setEnabled(False)
if box_list[0] =='Temperature':
self.checkBoxEnergy.setEnabled(False)
@pyqtSignature("")
def slotDensity(self):
"""
Density selected or not for the initialisation.
"""
if self.checkBoxDensity.isChecked():
self.init.setDensityStatus(self.zone,"on")
box_list = self.init.getCheckedBoxList(self.zone)
self.pushButtonDensity.setEnabled(True)
setGreenColor(self.pushButtonDensity,True)
if len(box_list) == 2:
for name in self.thermodynamic_list:
if name not in box_list:
__checkBox = getattr(self, "checkBox" + name)
__checkBox.setEnabled(False)
else:
self.init.setDensityStatus(self.zone,"off")
box_list = self.init.getCheckedBoxList(self.zone)
self.pushButtonDensity.setEnabled(False)
setGreenColor(self.pushButtonDensity,False)
if len(box_list) == 1:
for name in self.thermodynamic_list:
if name != 'Density':
__checkBox = getattr(self, "checkBox" + name)
__checkBox.setEnabled(True)
if box_list[0] =='Energy':
self.checkBoxTemperature.setEnabled(False)
if box_list[0] =='Temperature':
self.checkBoxEnergy.setEnabled(False)
@pyqtSignature("")
def slotTemperature(self):
"""
Temperature selected or not for the initialisation.
"""
if self.checkBoxTemperature.isChecked():
self.init.setTemperatureStatus(self.zone,"on")
box_list = self.init.getCheckedBoxList(self.zone)
self.pushButtonTemperature.setEnabled(True)
setGreenColor(self.pushButtonTemperature,True)
if len(box_list) == 2:
for name in self.thermodynamic_list:
if name not in box_list:
__checkBox = getattr(self, "checkBox" + name)
__checkBox.setEnabled(False)
self.checkBoxEnergy.setEnabled(False)
else:
self.init.setTemperatureStatus(self.zone,"off")
box_list = self.init.getCheckedBoxList(self.zone)
self.pushButtonTemperature.setEnabled(False)
setGreenColor(self.pushButtonTemperature,False)
if len(box_list) == 1:
for name in self.thermodynamic_list:
if name != 'Temperature':
__checkBox = getattr(self, "checkBox" + name)
__checkBox.setEnabled(True)
self.checkBoxEnergy.setEnabled(True)
@pyqtSignature("")
def slotEnergy(self):
"""
Energy selected or not for the initialisation.
"""
if self.checkBoxEnergy.isChecked():
self.init.setEnergyStatus(self.zone,"on")
box_list = self.init.getCheckedBoxList(self.zone)
self.pushButtonEnergy.setEnabled(True)
setGreenColor(self.pushButtonEnergy,True)
if len(box_list) == 2:
for name in self.thermodynamic_list:
if name not in box_list:
__checkBox = getattr(self, "checkBox" + name)
__Button = getattr(self, "pushButton" + name)
__checkBox.setEnabled(False)
__Button.setEnabled(False)
setGreenColor(__Button,False)
if len(box_list) == 1:
self.checkBoxTemperature.setEnabled(False)
else:
self.init.setEnergyStatus(self.zone,"off")
box_list = self.init.getCheckedBoxList(self.zone)
self.pushButtonEnergy.setEnabled(False)
setGreenColor(self.pushButtonEnergy,False)
if len(box_list) == 1:
for name in self.thermodynamic_list:
if name != 'Energy':
__checkBox = getattr(self, "checkBox" + name)
__Button = getattr(self, "pushButton" + name)
__checkBox.setEnabled(True)
__Button.setEnabled(False)
setGreenColor(__Button,False)
self.checkBoxTemperature.setEnabled(True)
@pyqtSignature("const QString&")
def slotPressureFormula(self):
"""
Input the initial Pressure formula
"""
exp = self.init.getPressureFormula(self.zone)
if not exp:
exp = """p0 = 0.;
g = 9.81;
ro = 1.17862;
pressure = p0 + g * ro * z;\n"""
exa = """#example: """
req = [('pressure', 'pressure')]
sym = [('x', 'cell center coordinate'),
('y', 'cell center coordinate'),
('z', 'cell center coordinate')]
dialog = QMeiEditorView(self,
check_syntax = self.case['package'].get_check_syntax(),
expression = exp,
required = req,
symbols = sym,
examples = exa)
if dialog.exec_():
result = dialog.get_result()
log.debug("slotPressureFormula -> %s" % str(result))
self.init.setPressureFormula(self.zone, result)
setGreenColor(self.pushButtonPressure_2, False)
@pyqtSignature("const QString&")
def slotDensityFormula(self):
"""
Input the initial Density formula
"""
exp = self.init.getDensityFormula(self.zone)
if not exp:
exp = """density = 0;\n"""
exa = """#example: """
req = [('density', 'density')]
sym = [('x', 'cell center coordinate'),
('y', 'cell center coordinate'),
('z', 'cell center coordinate')]
dialog = QMeiEditorView(self,
check_syntax = self.case['package'].get_check_syntax(),
expression = exp,
required = req,
symbols = sym,
examples = exa)
if dialog.exec_():
result = dialog.get_result()
log.debug("slotDensityFormula -> %s" % str(result))
self.init.setDensityFormula(self.zone, result)
setGreenColor(self.pushButtonDensity, False)
@pyqtSignature("const QString&")
def slotTemperatureFormula(self):
"""
Input the initial Temperature formula
"""
exp = self.init.getTemperatureFormula(self.zone)
if not exp:
exp = """temperature = 0;\n"""
exa = """#example: """
req = [('temperature', 'temperature')]
sym = [('x', 'cell center coordinate'),
('y', 'cell center coordinate'),
('z', 'cell center coordinate')]
dialog = QMeiEditorView(self,
check_syntax = self.case['package'].get_check_syntax(),
expression = exp,
required = req,
symbols = sym,
examples = exa)
if dialog.exec_():
result = dialog.get_result()
log.debug("slotTemperatureFormula -> %s" % str(result))
self.init.setTemperatureFormula(self.zone, result)
setGreenColor(self.pushButtonTemperature, False)
@pyqtSignature("const QString&")
def slotEnergyFormula(self):
"""
Input the initial Energy formula
"""
exp = self.init.getEnergyFormula(self.zone)
if not exp:
exp = """total_energy = 0;\n"""
exa = """#example: """
req = [('total_energy', 'Energy')]
sym = [('x', 'cell center coordinate'),
('y', 'cell center coordinate'),
('z', 'cell center coordinate')]
dialog = QMeiEditorView(self,
check_syntax = self.case['package'].get_check_syntax(),
expression = exp,
required = req,
symbols = sym,
examples = exa)
if dialog.exec_():
result = dialog.get_result()
log.debug("slotEnergyFormula -> %s" % str(result))
self.init.setEnergyFormula(self.zone, result)
setGreenColor(self.pushButtonEnergy, False)
def initializeVariables(self, zone):
"""
Initialize variables when a new volumic zone is choosen
"""
# Initialisation of Turbulence
turb_model = self.turb.getTurbulenceModel()
if turb_model not in ('k-epsilon',
'k-epsilon-PL',
'Rij-epsilon',
'Rij-SSG',
'Rij-EBRSM',
'v2f-BL-v2/k',
'k-omega-SST',
'Spalart-Allmaras'):
for item in self.turb_group:
item.hide()
else:
for item in self.turb_group:
item.show()
turb_init = self.init.getInitialTurbulenceChoice(self.zone)
self.modelTurbulence.setItem(str_model = turb_init)
if turb_init == 'formula':
self.pushButtonTurbulence.setEnabled(True)
turb_formula = self.init.getTurbFormula(zone, turb_model)
if not turb_formula:
turb_formula = self.init.getDefaultTurbFormula(turb_model)
self.init.setTurbFormula(zone, turb_formula)
setGreenColor(self.pushButtonTurbulence, True)
else:
self.pushButtonTurbulence.setEnabled(False)
setGreenColor(self.pushButtonTurbulence, False)
#velocity
velocity_formula = self.init.getVelocityFormula(zone)
if not velocity_formula:
velocity_formula = self.init.getDefaultVelocityFormula()
self.init.setVelocityFormula(zone, velocity_formula)
setGreenColor(self.pushButtonVelocity, True)
# Initialisation of Model Variables if thermal model is selectionned
for item in self.thermal_group:
item.hide()
model = self.therm.getThermalScalarModel()
if model != "off" and self.comp.getCompressibleModel() == 'off':
for item in self.thermal_group:
item.show()
th_formula = self.init.getThermalFormula(zone)
if not th_formula:
th_formula = self.init.getDefaultThermalFormula()
self.init.setThermalFormula(zone, th_formula)
setGreenColor(self.pushButtonThermal, True)
# Initialisation of the termodynamics values for the compressible model
if self.comp.getCompressibleModel() != 'off':
nb_box = 0
box_list = self.init.getCheckedBoxList(self.zone)
if box_list == []:
for name in self.thermodynamic_list:
__checkBox = getattr(self, "checkBox" + name)
__Button = getattr(self, "pushButton" + name)
__checkBox.setChecked(False)
__Button.setEnabled(False)
setGreenColor(__Button, False)
elif len(box_list) == 1:
box = box_list[0]
for name in self.thermodynamic_list:
if name != box:
__checkBox = getattr(self, "checkBox" + name)
__Button = getattr(self, "pushButton" + name)
__checkBox.setChecked(False)
__Button.setEnabled(False)
setGreenColor(__Button,False)
if box == 'Temperature':
self.checkBoxEnergy.setEnabled(False)
elif box == 'Energy':
self.checkBoxTemperature.setEnabled(False)
__checkBox = getattr(self, "checkBox" + box)
__checkBox.setChecked(True)
__Button = getattr(self, "pushButton" + box)
__Button.setEnabled(True)
setGreenColor(__Button, True)
elif len(box_list) == 2:
box1 = box_list[0]
box2 = box_list[1]
for name in self.thermodynamic_list:
if name not in box_list:
__checkBox = getattr(self, "checkBox" + name)
__Button = getattr(self, "pushButton" + name)
__checkBox.setChecked(False)
__checkBox.setEnabled(False)
__Button.setEnabled(False)
for name in box_list:
__checkBox = getattr(self, "checkBox" + name)
__Button = getattr(self, "pushButton" + name)
__checkBox.setChecked(True)
__Button.setEnabled(True)
setGreenColor(__Button, True)
def tr(self, text):
"""
Translation
"""
return text
class BoundaryConditionsVelocityInletView(QWidget, Ui_BoundaryConditionsVelocityInletForm):
"""
Boundary condition for velocity in inlet, without particular physics.
"""
def __init__(self, parent):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_BoundaryConditionsVelocityInletForm.__init__(self)
self.setupUi(self)
self.thermodynamic_list = ['Pressure', 'Density', 'Temperature', 'Energy']
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)
# Connections
self.connect(self.comboBoxVelocity, SIGNAL("activated(const QString&)"), self.__slotChoiceVelocity)
self.connect(self.lineEditVelocity, SIGNAL("textChanged(const QString &)"), self.__slotVelocityValue)
self.connect(self.comboBoxDirection, SIGNAL("activated(const QString&)"), self.__slotChoiceDirection)
self.connect(self.lineEditDirectionX, SIGNAL("textChanged(const QString &)"), self.__slotDirX)
self.connect(self.lineEditDirectionY, SIGNAL("textChanged(const QString &)"), self.__slotDirY)
self.connect(self.lineEditDirectionZ, SIGNAL("textChanged(const QString &)"), self.__slotDirZ)
self.connect(self.comboBoxTypeInlet, SIGNAL("activated(const QString&)"), self.__slotInletType)
self.connect(self.checkBoxPressure, SIGNAL("clicked()"), self.__slotPressure)
self.connect(self.checkBoxDensity, SIGNAL("clicked()"), self.__slotDensity)
self.connect(self.checkBoxTemperature, SIGNAL("clicked()"), self.__slotTemperature)
self.connect(self.checkBoxEnergy, SIGNAL("clicked()"), self.__slotEnergy)
self.connect(self.lineEditPressure, SIGNAL("textChanged(const QString &)"), self.__slotPressureValue)
self.connect(self.lineEditDensity, SIGNAL("textChanged(const QString &)"), self.__slotDensityValue)
self.connect(self.lineEditTotalPressure, SIGNAL("textChanged(const QString &)"), self.__slotTotalPressure)
self.connect(self.lineEditTotalEnthalpy, SIGNAL("textChanged(const QString &)"), self.__slotTotalEnthalpy)
self.connect(self.lineEditTemperature, SIGNAL("textChanged(const QString &)"), self.__slotTemperatureValue)
self.connect(self.lineEditEnergy, SIGNAL("textChanged(const QString &)"), self.__slotEnergyValue)
self.connect(self.comboBoxTypeInletGasComb, SIGNAL("activated(const QString&)"), self.__slotInletTypeGasComb)
self.connect(self.lineEditTemperatureGasComb, SIGNAL("textChanged(const QString &)"), self.__slotTemperatureGasComb)
self.connect(self.lineEditFraction, SIGNAL("textChanged(const QString &)"), 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.connect(self.pushButtonVelocityFormula, SIGNAL("clicked()"), self.__slotVelocityFormula)
self.connect(self.pushButtonDirectionFormula, SIGNAL("clicked()"), self.__slotDirectionFormula)
self.__case.undoStartGlobal()
def showWidget(self, boundary):
"""
Show the widget
"""
self.__boundary = boundary
# Initialize velocity
choice = self.__boundary.getVelocityChoice()
self.modelVelocity.setItem(str_model=choice)
self.__updateLabel()
if choice[-7:] == "formula":
self.pushButtonVelocityFormula.setEnabled(True)
self.lineEditVelocity.setEnabled(False)
else:
self.pushButtonVelocityFormula.setEnabled(False)
self.lineEditVelocity.setEnabled(True)
v = self.__boundary.getVelocity()
self.lineEditVelocity.setText(str(v))
# Initialize direction
choice = self.__boundary.getDirectionChoice()
self.modelDirection.setItem(str_model=choice)
text = self.modelDirection.dicoM2V[choice]
if choice == "formula":
self.pushButtonDirectionFormula.setEnabled(True)
self.frameDirectionCoordinates.hide()
elif choice == "coordinates":
self.pushButtonDirectionFormula.setEnabled(False)
self.frameDirectionCoordinates.show()
v = self.__boundary.getDirection('direction_x')
self.lineEditDirectionX.setText(str(v))
v = self.__boundary.getDirection('direction_y')
self.lineEditDirectionY.setText(str(v))
v = self.__boundary.getDirection('direction_z')
self.lineEditDirectionZ.setText(str(v))
elif choice == "normal":
self.pushButtonDirectionFormula.setEnabled(False)
self.frameDirectionCoordinates.hide()
self.initialize()
def initialize(self):
"""
Initialize widget for compressible
"""
self.comboBoxVelocity.show()
self.lineEditVelocity.show()
self.labelUnitVelocity.show()
self.pushButtonVelocityFormula.show()
# Initialize thermodynamic value
if self.mdl.getCompressibleModel() != 'off':
inlet_type = self.__boundary.getInletType()
self.modelTypeInlet.setItem(str_model = inlet_type)
self.__boundary.setInletType(inlet_type)
if inlet_type == 'imposed_inlet':
self.groupBoxThermodynamic.show()
self.frameDensity.hide()
for name in self.thermodynamic_list:
__checkBox = getattr(self, "checkBox" + name)
__lineEdit = getattr(self, "lineEdit" + name)
__checkBox.setChecked(False)
__checkBox.setEnabled(False)
__lineEdit.setEnabled(False)
__lineEdit.clear()
box_list = self.__boundary.getCheckedBoxList()
if len(box_list) == 0:
for name in self.thermodynamic_list:
__checkBox = getattr(self, "checkBox" + name)
__lineEdit = getattr(self, "lineEdit" + name)
__checkBox.setEnabled(True)
elif len(box_list) == 1:
for name in self.thermodynamic_list:
__checkBox = getattr(self, "checkBox" + name)
__lineEdit = getattr(self, "lineEdit" + name)
__checkBox.setEnabled(True)
box = box_list[0]
if box == 'Temperature':
self.checkBoxEnergy.setEnabled(False)
elif box == 'Energy':
self.checkBoxTemperature.setEnabled(False)
__checkBox = getattr(self, "checkBox" + box)
__checkBox.setChecked(True)
__lineEdit = getattr(self, "lineEdit" + box)
__lineEdit.setEnabled(True)
v1 = self.__boundary.getListValue()[0]
__lineEdit.setText(str(v1))
elif len(box_list) == 2:
v1,v2 = self.__boundary.getListValue()
for name in box_list:
__checkBox = getattr(self, "checkBox" + name)
__lineEdit = getattr(self, "lineEdit" + name)
__checkBox.setEnabled(True)
__checkBox.setChecked(True)
__lineEdit.setEnabled(True)
if v1 >= 0.:
__lineEdit.setText(str(v1))
else:
__lineEdit.setText(str(v2))
v1 = -1.
elif inlet_type == 'subsonic_inlet_PH':
self.comboBoxVelocity.hide()
self.lineEditVelocity.hide()
self.labelUnitVelocity.hide()
self.pushButtonVelocityFormula.hide()
self.groupBoxThermodynamic.hide()
self.frameDensity.show()
pressure = self.__boundary.getThermoValue('total_pressure')
self.lineEditTotalPressure.setText(str(pressure))
enthalpy = self.__boundary.getThermoValue('enthalpy')
self.lineEditTotalEnthalpy.setText(str(enthalpy))
else:
self.groupBoxCompressible.hide()
# Initialize temperature and mean mixture fraction
model = self.gas.getGasCombustionModel()
if model != 'off':
self.groupBoxGasCombustion.show()
inlet_type = self.__boundary.getInletGasCombustionType()
self.modelTypeInletGasComb.setItem(str_model = inlet_type)
if model == 'd3p':
self.lineEditTemperatureGasComb.hide()
self.labelTemperature_2.hide()
self.labelUnitTemp.hide()
self.lineEditFraction.setEnabled(False)
f = self.__boundary.setMeanMixtureFraction(1)
self.lineEditFraction.setText(str(1) if inlet_type == 'oxydant' else str(0))
else :
self.lineEditTemperatureGasComb.show()
self.labelTemperature_2.show()
self.labelUnitTemp.show()
t = self.__boundary.getGasCombustionTemperature()
self.lineEditTemperatureGasComb.setText(str(t))
self.lineEditFraction.setEnabled(True)
f = self.__boundary.getMeanMixtureFraction()
self.lineEditFraction.setText(str(f))
else:
self.groupBoxGasCombustion.hide()
self.show()
def hideWidget(self):
"""
Hide all
"""
self.hide()
@pyqtSignature("const QString&")
def __slotChoiceVelocity(self, text):
"""
Private slot.
Input the velocity boundary type choice (norm, ).
@type text: C{QString}
@param text: velocity boundary type choice.
"""
c = self.modelVelocity.dicoV2M[str(text)]
log.debug("slotChoiceVelocity: %s " % c)
self.__boundary.setVelocityChoice(c)
if c[-7:] == "formula":
self.pushButtonVelocityFormula.setEnabled(True)
setGreenColor(self.pushButtonVelocityFormula, True)
self.lineEditVelocity.setEnabled(False)
self.lineEditVelocity.setText("")
else:
self.pushButtonVelocityFormula.setEnabled(False)
setGreenColor(self.pushButtonVelocityFormula, False)
self.lineEditVelocity.setEnabled(True)
v = self.__boundary.getVelocity()
self.lineEditVelocity.setText(str(v))
self.__updateLabel()
def __updateLabel(self):
"""
Update the unit for the velocity specification.
"""
c = self.__boundary.getVelocityChoice()
if c in ('norm', 'norm_formula'):
self.labelUnitVelocity.setText(str('m/s'))
elif c in ('flow1', 'flow1_formula'):
self.labelUnitVelocity.setText(str('kg/s'))
elif c in ('flow2', 'flow2_formula'):
self.labelUnitVelocity.setText(str('m<sup>3</sup>/s'))
@pyqtSignature("const QString&")
def __slotVelocityValue(self, text):
"""
Private slot.
New value associated to the velocity boundary type.
@type text: C{QString}
@param text: value
"""
if self.sender().validator().state == QValidator.Acceptable:
v = from_qvariant(text, float)
self.__boundary.setVelocity(v)
@pyqtSignature("")
def __slotVelocityFormula(self):
"""
"""
exp = self.__boundary.getVelocity()
c = self.__boundary.getVelocityChoice()
if c == 'norm_formula':
exa = "u_norm = 1.0;"
req = [('u_norm', 'Norm of the velocity')]
elif c == 'flow1_formula':
exa = "q_m = 1.0;"
req = [('q_m', 'mass flow rate')]
elif c == 'flow2_formula':
exa = "q_v = 1.0;"
req = [('q_v', 'volumic flow rate')]
sym = [('x', "X face's gravity center"),
('y', "Y face's gravity center"),
('z', "Z face's gravity center"),
('dt', 'time step'),
('t', 'current time'),
('iter', 'number of iteration')]
dialog = QMeiEditorView(self,
check_syntax = self.__case['package'].get_check_syntax(),
expression = exp,
required = req,
symbols = sym,
examples = exa)
if dialog.exec_():
result = dialog.get_result()
log.debug("slotFormulaVelocity -> %s" % str(result))
self.__boundary.setVelocity(result)
setGreenColor(self.pushButtonVelocityFormula, False)
@pyqtSignature("const QString&")
def __slotChoiceDirection(self, text):
"""
Input the direction type choice.
"""
c = self.modelDirection.dicoV2M[str(text)]
log.debug("slotChoiceVelocity: %s " % c)
self.__boundary.setDirectionChoice(c)
if c == "formula":
self.pushButtonDirectionFormula.setEnabled(True)
setGreenColor(self.pushButtonDirectionFormula, True)
self.frameDirectionCoordinates.hide()
elif c == "coordinates":
self.pushButtonDirectionFormula.setEnabled(False)
setGreenColor(self.pushButtonDirectionFormula, False)
self.frameDirectionCoordinates.show()
v = self.__boundary.getDirection('direction_x')
self.lineEditDirectionX.setText(str(v))
v = self.__boundary.getDirection('direction_y')
self.lineEditDirectionY.setText(str(v))
v = self.__boundary.getDirection('direction_z')
self.lineEditDirectionZ.setText(str(v))
elif c == "normal":
self.pushButtonDirectionFormula.setEnabled(False)
setGreenColor(self.pushButtonDirectionFormula, False)
self.frameDirectionCoordinates.hide()
@pyqtSignature("const QString&")
def __slotDirX(self, text):
"""
INPUT value into direction of inlet flow
"""
if self.sender().validator().state == QValidator.Acceptable:
value = from_qvariant(text, float)
self.__boundary.setDirection('direction_x', value)
@pyqtSignature("const QString&")
def __slotDirY(self, text):
"""
INPUT value into direction of inlet flow
"""
if self.sender().validator().state == QValidator.Acceptable:
value = from_qvariant(text, float)
self.__boundary.setDirection('direction_y', value)
@pyqtSignature("const QString&")
def __slotDirZ(self, text):
"""
INPUT value into direction of inlet flow
"""
if self.sender().validator().state == QValidator.Acceptable:
value = from_qvariant(text, float)
self.__boundary.setDirection('direction_z', value)
@pyqtSignature("")
def __slotDirectionFormula(self):
"""
"""
exp = self.__boundary.getDirection('direction_formula')
req = [('dir_x', 'Direction of the flow along X'),
('dir_y', 'Direction of the flow along Y'),
('dir_z', 'Direction of the flow along Z')]
exa = "dir_x = 3.0;\ndir_y = 1.0;\ndir_z = 0.0;\n"
sym = [('x', "X face's gravity center"),
('y', "Y face's gravity center"),
('z', "Z face's gravity center"),
('dt', 'time step'),
('t', 'current time'),
('iter', 'number of iteration')]
dialog = QMeiEditorView(self,
check_syntax = self.__case['package'].get_check_syntax(),
expression = exp,
required = req,
symbols = sym,
examples = exa)
if dialog.exec_():
result = dialog.get_result()
log.debug("slotFormulaDirection -> %s" % str(result))
self.__boundary.setDirection('direction_formula', result)
setGreenColor(self.pushButtonDirectionFormula, False)
@pyqtSignature("const QString&")
def __slotInletType(self, text):
"""
INPUT inlet type : 'oxydant'/'fuel' or 'burned'/'unburned'
"""
value = self.modelTypeInlet.dicoV2M[str(text)]
log.debug("__slotInletType value = %s " % value)
self.__boundary.setInletType(value)
self.initialize()
@pyqtSignature("")
def __slotPressure(self):
"""
Pressure selected or not for the initialisation.
"""
if self.checkBoxPressure.isChecked():
self.__boundary.setThermoStatus('pressure', "on")
else:
self.__boundary.setThermoStatus('pressure', "off")
self.initialize()
@pyqtSignature("")
def __slotDensity(self):
"""
Density selected or not for the initialisation.
"""
if self.checkBoxDensity.isChecked():
self.__boundary.setThermoStatus('density', "on")
else:
self.__boundary.setThermoStatus('density', "off")
self.initialize()
@pyqtSignature("")
def __slotTemperature(self):
"""
Temperature selected or not for the initialisation.
"""
if self.checkBoxTemperature.isChecked():
self.__boundary.setThermoStatus('temperature', "on")
else:
self.__boundary.setThermoStatus('temperature', "off")
self.initialize()
@pyqtSignature("")
def __slotEnergy(self):
"""
Energy selected or not for the initialisation.
"""
if self.checkBoxEnergy.isChecked():
self.__boundary.setThermoStatus('energy', "on")
else:
self.__boundary.setThermoStatus('energy', "off")
self.initialize()
@pyqtSignature("const QString&")
def __slotPressureValue(self, text):
"""
INPUT inlet Pressure
"""
if self.sender().validator().state == QValidator.Acceptable:
t = from_qvariant(text, float)
self.__boundary.setThermoValue('pressure', t)
@pyqtSignature("const QString&")
def __slotDensityValue(self, text):
"""
INPUT inlet Density
"""
if self.sender().validator().state == QValidator.Acceptable:
t = from_qvariant(text, float)
self.__boundary.setThermoValue('density', t)
@pyqtSignature("const QString&")
def __slotTemperatureValue(self, text):
"""
INPUT inlet Temperature
"""
if self.sender().validator().state == QValidator.Acceptable:
t = from_qvariant(text, float)
self.__boundary.setThermoValue('temperature', t)
@pyqtSignature("const QString&")
def __slotEnergyValue(self, text):
"""
INPUT inlet Energy
"""
if self.sender().validator().state == QValidator.Acceptable:
t = from_qvariant(text, float)
self.__boundary.setThermoValue('energy', t)
@pyqtSignature("const QString&")
def __slotTotalPressure(self, text):
"""
INPUT inlet total pressure
"""
if self.sender().validator().state == QValidator.Acceptable:
t = from_qvariant(text, float)
self.__boundary.setThermoValue('total_pressure', t)
@pyqtSignature("const QString&")
def __slotTotalEnthalpy(self, text):
"""
INPUT inlet total enthalpy
"""
if self.sender().validator().state == QValidator.Acceptable:
t = from_qvariant(text, float)
self.__boundary.setThermoValue('enthalpy', t)
@pyqtSignature("const QString&")
def __slotTemperatureGasComb(self, text):
"""
INPUT inlet temperature
"""
if self.sender().validator().state == QValidator.Acceptable:
t = from_qvariant(text, float)
self.__boundary.setGasCombustionTemperature(t)
@pyqtSignature("const QString&")
def __slotMeanMixtureFraction(self, text):
"""
INPUT inlet mean mixutre fraction
"""
if self.sender().validator().state == QValidator.Acceptable:
t = from_qvariant(text, float)
self.__boundary.setMeanMixtureFraction(f)
@pyqtSignature("const QString&")
def __slotInletTypeGasComb(self, text):
"""
INPUT inlet type : 'oxydant'/'fuel' or 'burned'/'unburned'
"""
value = self.modelTypeInletGasComb.dicoV2M[str(text)]
log.debug("__slotInletTypeGasComb value = %s " % value)
self.__boundary.setInletGasCombustionType(value)
self.initialize()
def tr(self, text):
"""
Translation
"""
return text
class BoundaryConditionsScalarsView(QWidget, Ui_BoundaryConditionsScalarsForm):
"""
"""
def __init__(self, parent):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_BoundaryConditionsScalarsForm.__init__(self)
self.setupUi(self)
def setup(self, case):
"""
Setup the widget
"""
self.__case = case
self.__boundary = None
self.__case.undoStopGlobal()
self.connect(self.lineEditValueThermal, SIGNAL("textChanged(const QString &)"), self.slotValueThermal)
self.connect(self.lineEditValueSpecies, SIGNAL("textChanged(const QString &)"), self.slotValueSpecies)
self.connect(self.lineEditValueMeteo, SIGNAL("textChanged(const QString &)"), self.slotValueMeteo)
self.connect(self.lineEditExThermal, SIGNAL("textChanged(const QString &)"), self.slotExThermal)
self.connect(self.lineEditExSpecies, SIGNAL("textChanged(const QString &)"), self.slotExSpecies)
self.connect(self.lineEditExMeteo, SIGNAL("textChanged(const QString &)"), self.slotExMeteo)
self.connect(self.pushButtonThermal, SIGNAL("clicked()"), self.slotThermalFormula)
self.connect(self.pushButtonSpecies, SIGNAL("clicked()"), self.slotSpeciesFormula)
self.connect(self.pushButtonMeteo, SIGNAL("clicked()"), self.slotMeteoFormula)
self.connect(self.comboBoxThermal, SIGNAL("activated(const QString&)"), self.slotThermalChoice)
self.connect(self.comboBoxTypeThermal, SIGNAL("activated(const QString&)"), self.slotThermalTypeChoice)
self.connect(self.comboBoxSpecies, SIGNAL("activated(const QString&)"), self.slotSpeciesChoice)
self.connect(self.comboBoxTypeSpecies, SIGNAL("activated(const QString&)"), self.slotSpeciesTypeChoice)
self.connect(self.comboBoxMeteo, SIGNAL("activated(const QString&)"), self.slotMeteoChoice)
self.connect(self.comboBoxTypeMeteo, SIGNAL("activated(const QString&)"), self.slotMeteoTypeChoice)
## Validators
validatorValueThermal = DoubleValidator(self.lineEditValueThermal)
validatorValueSpecies = DoubleValidator(self.lineEditValueSpecies)
validatorValueMeteo = DoubleValidator(self.lineEditValueMeteo)
validatorExThermal = DoubleValidator(self.lineEditExThermal)
validatorExSpecies = DoubleValidator(self.lineEditExSpecies)
validatorExMeteo = DoubleValidator(self.lineEditExMeteo)
self.lineEditValueThermal.setValidator(validatorValueThermal)
self.lineEditValueSpecies.setValidator(validatorValueSpecies)
self.lineEditValueMeteo.setValidator(validatorValueMeteo)
self.lineEditExThermal.setValidator(validatorExThermal)
self.lineEditExSpecies.setValidator(validatorExSpecies)
self.lineEditExMeteo.setValidator(validatorExMeteo)
self.__case.undoStartGlobal()
def __setBoundary(self, boundary):
"""
Set the current boundary
"""
self.__boundary = boundary
self.nature = boundary.getNature()
self.therm = ThermalScalarModel(self.__case)
self.sca_mo = DefineUserScalarsModel(self.__case)
self.comp = CompressibleModel(self.__case)
self.atm = AtmosphericFlowsModel(self.__case)
self.modelTypeThermal = ComboModel(self.comboBoxTypeThermal, 1, 1)
self.modelTypeSpecies = ComboModel(self.comboBoxTypeSpecies, 1, 1)
self.modelTypeMeteo = ComboModel(self.comboBoxTypeMeteo, 1, 1)
self.modelTypeThermal.addItem(self.tr("Prescribed value"), 'dirichlet')
self.modelTypeSpecies.addItem(self.tr("Prescribed value"), 'dirichlet')
self.modelTypeMeteo.addItem( self.tr("Prescribed value"), 'dirichlet')
self.modelTypeThermal.addItem(self.tr("Prescribed value (user law)"), 'dirichlet_formula')
self.modelTypeSpecies.addItem(self.tr("Prescribed value (user law)"), 'dirichlet_formula')
self.modelTypeMeteo.addItem( self.tr("Prescribed value (user law)"), 'dirichlet_formula')
if self.nature == 'outlet':
self.modelTypeThermal.addItem(self.tr("Prescribed flux"), 'neumann')
self.modelTypeSpecies.addItem(self.tr("Prescribed flux"), 'neumann')
self.modelTypeMeteo.addItem( self.tr("Prescribed flux"), 'neumann')
elif self.nature == 'wall':
self.modelTypeThermal.addItem(self.tr("Prescribed flux"), 'neumann')
self.modelTypeSpecies.addItem(self.tr("Prescribed flux"), 'neumann')
self.modelTypeMeteo.addItem( self.tr("Prescribed flux"), 'neumann')
self.modelTypeThermal.addItem(self.tr("Prescribed flux (user law)"), 'neumann_formula')
self.modelTypeSpecies.addItem(self.tr("Prescribed flux (user law)"), 'neumann_formula')
self.modelTypeMeteo.addItem( self.tr("Prescribed flux (user law)"), 'neumann_formula')
self.modelTypeThermal.addItem(self.tr("Exchange coefficient"), 'exchange_coefficient')
self.modelTypeSpecies.addItem(self.tr("Exchange coefficient"), 'exchange_coefficient')
self.modelTypeMeteo.addItem( self.tr("Exchange coefficient"), 'exchange_coefficient')
self.modelTypeThermal.addItem(self.tr("Exchange coefficient (user law)"), 'exchange_coefficient_formula')
self.modelTypeSpecies.addItem(self.tr("Exchange coefficient (user law)"), 'exchange_coefficient_formula')
self.modelTypeMeteo.addItem( self.tr("Exchange coefficient (user law)"), 'exchange_coefficient_formula')
self.species = ""
self.species_list = self.sca_mo.getUserScalarNameList()
for s in self.sca_mo.getScalarsVarianceList():
if s in self.species_list:
self.species_list.remove(s)
self.species = ""
if self.species_list != []:
self.groupBoxSpecies.show()
self.modelSpecies = ComboModel(self.comboBoxSpecies, 1, 1)
for species in self.species_list:
self.modelSpecies.addItem(self.tr(species), species)
self.species = self.species_list[0]
self.modelSpecies.setItem(str_model = self.species)
else:
self.groupBoxSpecies.hide()
self.model_th = self.therm.getThermalScalarModel()
if self.model_th != 'off' and self.comp.getCompressibleModel() == 'off':
self.groupBoxThermal.show()
self.modelThermal = ComboModel(self.comboBoxThermal,1,1)
self.thermal = self.therm.getThermalScalarName()
self.modelThermal.addItem(self.tr(self.thermal),self.thermal)
self.modelThermal.setItem(str_model = self.thermal)
else:
self.groupBoxThermal.hide()
self.meteo_list = ""
self.meteo_list = self.sca_mo.getMeteoScalarsNameList()
self.groupBoxMeteo.hide()
if (self.atm.getAtmosphericFlowsModel() != "off" and self.nature == 'wall'):
self.groupBoxThermal.hide()
if (self.atm.getAtmosphericFlowsModel() != "off" and \
(self.nature == 'inlet' or self.nature == 'outlet')):
label = self.__boundary.getLabel()
nature = "meteo_" + self.nature
bb = Boundary(nature, label, self.__case)
if bb.getMeteoDataStatus() == 'off':
self.groupBoxMeteo.hide()
self.groupBoxThermal.show()
self.modelMeteo = ComboModel(self.comboBoxMeteo, 1, 1)
if len(self.meteo_list) > 0:
self.groupBoxMeteo.show()
for m in self.meteo_list:
self.modelMeteo.addItem(self.tr(m), m)
self.meteo = self.meteo_list[0]
self.modelMeteo.setItem(str_model = self.meteo)
else:
self.groupBoxMeteo.hide()
self.groupBoxThermal.hide()
self.initializeVariables()
def initializeVariables(self):
"""
Initialize widget
"""
# Initalize exchange coef
self.lineEditExThermal.hide()
self.labelExThermal.hide()
self.lineEditExSpecies.hide()
self.labelExSpecies.hide()
self.lineEditExMeteo.hide()
self.labelExMeteo.hide()
# Initalize thermal
self.lineEditValueThermal.hide()
self.labelValueThermal.hide()
self.pushButtonThermal.setEnabled(False)
setGreenColor(self.pushButtonThermal, False)
if self.model_th != 'off' and self.comp.getCompressibleModel() == 'off':
self.thermal_type = self.__boundary.getScalarChoice(self.thermal)
self.modelTypeThermal.setItem(str_model = self.thermal_type)
self.labelValueThermal.setText('Value')
self.groupBoxThermal.setTitle('Thermal')
if self.thermal_type in ('dirichlet', 'exchange_coefficient', 'neumann'):
self.labelValueThermal.show()
self.lineEditValueThermal.show()
if self.thermal_type == 'exchange_coefficient':
self.lineEditExThermal.show()
self.labelExThermal.show()
v = self.__boundary.getScalarValue(self.thermal, 'dirichlet')
w = self.__boundary.getScalarValue(self.thermal, 'exchange_coefficient')
self.lineEditValueThermal.setText(str(v))
self.lineEditExThermal.setText(str(w))
else:
v = self.__boundary.getScalarValue(self.thermal, self.thermal_type)
self.lineEditValueThermal.setText(str(v))
if self.thermal_type == 'neumann':
self.labelValueThermal.setText('Flux')
if self.nature == 'outlet':
self.groupBoxThermal.setTitle('Thermal for backflow')
elif self.thermal_type in ('exchange_coefficient_formula', 'dirichlet_formula', 'neumann_formula'):
self.pushButtonThermal.setEnabled(True)
setGreenColor(self.pushButtonThermal, True)
# Initalize species
self.labelValueSpecies.hide()
self.lineEditValueSpecies.hide()
self.pushButtonSpecies.setEnabled(False)
setGreenColor(self.pushButtonSpecies, False)
if self.species_list != None and self.species_list != []:
self.species_type = self.__boundary.getScalarChoice(self.species)
self.modelTypeSpecies.setItem(str_model = self.species_type)
self.labelValueSpecies.setText('Value')
self.groupBoxSpecies.setTitle('Species')
if self.species_type in ('dirichlet', 'exchange_coefficient', 'neumann'):
self.labelValueSpecies.show()
self.lineEditValueSpecies.show()
if self.species_type == 'exchange_coefficient':
self.lineEditExSpecies.show()
self.labelExSpecies.show()
v = self.__boundary.getScalarValue(self.species, 'dirichlet')
w = self.__boundary.getScalarValue(self.species, 'exchange_coefficient')
self.lineEditValueSpecies.setText(str(v))
self.lineEditExSpecies.setText(str(w))
else:
v = self.__boundary.getScalarValue(self.species, self.species_type)
self.lineEditValueSpecies.setText(str(v))
if self.species_type == 'neumann':
self.labelValueSpecies.setText('Flux')
if self.nature == 'outlet':
self.groupBoxSpecies.setTitle('Species for backflow')
elif self.species_type in ('exchange_coefficient_formula', 'dirichlet_formula', 'neumann_formula'):
self.pushButtonSpecies.setEnabled(True)
setGreenColor(self.pushButtonSpecies, True)
# Initalize meteo
self.labelValueMeteo.hide()
self.lineEditValueMeteo.hide()
self.pushButtonMeteo.setEnabled(False)
setGreenColor(self.pushButtonMeteo, False)
if (self.meteo_list and (self.nature == 'inlet' or self.nature == 'outlet')):
label = self.__boundary.getLabel()
nature = "meteo_" + self.nature
bb = Boundary(nature, label, self.__case)
if bb.getMeteoDataStatus() == 'off':
self.meteo_type = self.__boundary.getScalarChoice(self.meteo)
self.modelTypeMeteo.setItem(str_model = self.meteo_type)
self.labelValueMeteo.setText('Value')
self.groupBoxMeteo.setTitle('Meteo')
if self.meteo_type in ('dirichlet', 'exchange_coefficient', 'neumann'):
self.labelValueMeteo.show()
self.lineEditValueMeteo.show()
if self.meteo_type == 'exchange_coefficient':
self.lineEditExMeteo.show()
self.labelExMeteo.show()
v = self.__boundary.getScalarValue(self.meteo, 'dirichlet')
w = self.__boundary.getScalarValue(self.meteo, 'exchange_coefficient')
self.lineEditValueMeteo.setText(str(v))
self.lineEditExMeteo.setText(str(w))
else:
v = self.__boundary.getScalarValue(self.meteo, self.meteo_type)
self.lineEditValueMeteo.setText(str(v))
if self.meteo_type == 'neumann':
self.labelValueMeteo.setText('Flux')
if self.nature == 'outlet':
self.groupBoxMeteo.setTitle('Meteo for backflow')
if self.meteo_type in ('exchange_coefficient_formula', 'dirichlet_formula', 'neumann_formula'):
self.pushButtonMeteo.setEnabled(True)
setGreenColor(self.pushButtonMeteo, True)
def showWidget(self, boundary):
"""
Show the widget
"""
if DefineUserScalarsModel(self.__case).getScalarNameList() or\
DefineUserScalarsModel(self.__case).getMeteoScalarsNameList() or\
DefineUserScalarsModel(self.__case).getThermalScalarName():
self.__setBoundary(boundary)
self.show()
else:
self.hideWidget()
def hideWidget(self):
"""
Hide all
"""
self.hide()
@pyqtSignature("const QString&")
def slotThermalChoice(self, text):
"""
INPUT label for choice of zone
"""
self.thermal = self.modelThermal.dicoV2M[str(text)]
self.initializeVariables()
@pyqtSignature("const QString&")
def slotThermalTypeChoice(self, text):
"""
INPUT label for choice of zone
"""
self.thermal_type = self.modelTypeThermal.dicoV2M[str(text)]
self.__boundary.setScalarChoice(self.thermal, self.thermal_type)
self.initializeVariables()
@pyqtSignature("const QString&")
def slotSpeciesChoice(self, text):
"""
INPUT label for choice of zone
"""
self.species = self.modelSpecies.dicoV2M[str(text)]
self.initializeVariables()
@pyqtSignature("const QString&")
def slotSpeciesTypeChoice(self, text):
"""
INPUT label for choice of zone
"""
self.species_type = self.modelTypeSpecies.dicoV2M[str(text)]
self.__boundary.setScalarChoice(self.species, self.species_type)
self.initializeVariables()
@pyqtSignature("const QString&")
def slotMeteoChoice(self, text):
"""
INPUT label for choice of zone
"""
self.meteo = self.modelMeteo.dicoV2M[str(text)]
self.initializeVariables()
@pyqtSignature("const QString&")
def slotMeteoTypeChoice(self, text):
"""
INPUT label for choice of zone
"""
self.meteo_type= self.modelTypeMeteo.dicoV2M[str(text)]
self.__boundary.setScalarChoice(self.meteo, self.meteo_type)
self.initializeVariables()
@pyqtSignature("")
def slotThermalFormula(self):
"""
"""
name = self.thermal
exp = self.__boundary.getScalarFormula(self.thermal, self.thermal_type)
exa = """#example: """
if self.thermal_type == 'dirichlet_formula':
req = [(name, str(name))]
elif self.thermal_type == 'neumann_formula':
req = [("flux", "flux")]
elif self.thermal_type == 'exchange_coefficient_formula':
req = [(name, str(nameal)),("hc", "heat coefficient")]
sym = [('x', "X face's gravity center"),
('y', "Y face's gravity center"),
('z', "Z face's gravity center"),
('dt', 'time step'),
('t', 'current time'),
('iter', 'number of iteration')]
dialog = QMeiEditorView(self,
check_syntax = self.__case['package'].get_check_syntax(),
expression = exp,
required = req,
symbols = sym,
examples = exa)
if dialog.exec_():
result = dialog.get_result()
log.debug("slotThermalFormula -> %s" % str(result))
self.__boundary.setScalarFormula(self.thermal, self.thermal_type, result)
setGreenColor(self.pushButtonThermal, False)
@pyqtSignature("")
def slotSpeciesFormula(self):
"""
"""
exp = self.__boundary.getScalarFormula(self.species, self.species_type)
exa = """#example: """
if self.species_type == 'dirichlet_formula':
req = [(self.species, str(self.species))]
elif self.species_type == 'neumann_formula':
req = [("flux", "flux")]
elif self.species_type == 'exchange_coefficient_formula':
req = [(self.species, str(self.species)),("hc", "heat coefficient")]
sym = [('x', "X face's gravity center"),
('y', "Y face's gravity center"),
('z', "Z face's gravity center"),
('dt', 'time step'),
('t', 'current time'),
('iter', 'number of iteration')]
dialog = QMeiEditorView(self,
check_syntax = self.__case['package'].get_check_syntax(),
expression = exp,
required = req,
symbols = sym,
examples = exa)
if dialog.exec_():
result = dialog.get_result()
log.debug("slotSpeciesFormula -> %s" % str(result))
self.__boundary.setScalarFormula(self.species, self.species_type, result)
setGreenColor(self.pushButtonSpecies, False)
@pyqtSignature("")
def slotMeteoFormula(self):
"""
"""
exp = self.__boundary.getScalarFormula(self.meteo, self.meteo_type)
exa = """#example: """
if self.meteo_type == 'dirichlet_formula':
req = [(self.meteo, str(self.meteo))]
elif self.meteo_type == 'neumann_formula':
req = [("flux", "flux")]
elif self.meteo_type == 'exchange_coefficient_formula':
req = [(self.meteo, str(self.meteo)),
("hc", "heat coefficient")]
sym = [('x', "X face's gravity center"),
('y', "Y face's gravity center"),
('z', "Z face's gravity center"),
('dt', 'time step'),
('t', 'current time'),
('iter', 'number of iteration')]
dialog = QMeiEditorView(self,
check_syntax = self.__case['package'].get_check_syntax(),
expression = exp,
required = req,
symbols = sym,
examples = exa)
if dialog.exec_():
result = dialog.get_result()
log.debug("slotMeteoFormula -> %s" % str(result))
self.__boundary.setScalarFormula(self.meteo, self.meteo_type, result)
setGreenColor(self.pushButtonMeteo, False)
@pyqtSignature("const QString&")
def slotValueThermal(self, var):
"""
"""
if self.sender().validator().state == QValidator.Acceptable:
value = from_qvariant(var, float)
if self.thermal_type in ('dirichlet', 'neumann'):
self.__boundary.setScalarValue(self.thermal, self.thermal_type, value)
elif self.thermal_type == 'exchange_coefficient':
self.__boundary.setScalarValue(self.thermal, 'dirichlet', value)
@pyqtSignature("const QString&")
def slotValueSpecies(self, var):
"""
"""
if self.sender().validator().state == QValidator.Acceptable:
value = from_qvariant(var, float)
if self.species_type in ('dirichlet', 'neumann'):
self.__boundary.setScalarValue(self.species, self.species_type, value)
elif self.species_type == 'exchange_coefficient' :
self.__boundary.setScalarValue(self.species, 'dirichlet', value)
@pyqtSignature("const QString&")
def slotValueMeteo(self, var):
"""
"""
if self.sender().validator().state == QValidator.Acceptable:
value = from_qvariant(var, float)
if self.meteo_type in ('dirichlet', 'neumann'):
self.__boundary.setScalarValue(self.meteo, self.meteo_type, value)
elif self.meteo_type == 'exchange_coefficient':
self.__boundary.setScalarValue(self.meteo, 'dirichlet', value)
@pyqtSignature("const QString&")
def slotExThermal(self, var):
"""
"""
if self.sender().validator().state == QValidator.Acceptable:
value = from_qvariant(var, float)
self.__boundary.setScalarValue(self.thermal, 'exchange_coefficient', value)
@pyqtSignature("const QString&")
def slotExSpecies(self, var):
"""
"""
if self.sender().validator().state == QValidator.Acceptable:
value = from_qvariant(var, float)
self.__boundary.setScalarValue(self.species, 'exchange_coefficient', value)
@pyqtSignature("const QString&")
def slotExMeteo(self, var):
"""
"""
if self.sender().validator().state == QValidator.Acceptable:
value = from_qvariant(var, float)
self.__boundary.setScalarValue(self.meteo, 'exchange_coefficient', value)
def tr(self, text):
"""
Translation
"""
return text
def __setBoundary(self, boundary):
"""
Set the current boundary
"""
self.__boundary = boundary
self.nature = boundary.getNature()
self.therm = ThermalScalarModel(self.__case)
self.sca_mo = DefineUserScalarsModel(self.__case)
self.comp = CompressibleModel(self.__case)
self.atm = AtmosphericFlowsModel(self.__case)
self.modelTypeThermal = ComboModel(self.comboBoxTypeThermal, 1, 1)
self.modelTypeSpecies = ComboModel(self.comboBoxTypeSpecies, 1, 1)
self.modelTypeMeteo = ComboModel(self.comboBoxTypeMeteo, 1, 1)
self.modelTypeThermal.addItem(self.tr("Prescribed value"), 'dirichlet')
self.modelTypeSpecies.addItem(self.tr("Prescribed value"), 'dirichlet')
self.modelTypeMeteo.addItem( self.tr("Prescribed value"), 'dirichlet')
self.modelTypeThermal.addItem(self.tr("Prescribed value (user law)"), 'dirichlet_formula')
self.modelTypeSpecies.addItem(self.tr("Prescribed value (user law)"), 'dirichlet_formula')
self.modelTypeMeteo.addItem( self.tr("Prescribed value (user law)"), 'dirichlet_formula')
if self.nature == 'outlet':
self.modelTypeThermal.addItem(self.tr("Prescribed flux"), 'neumann')
self.modelTypeSpecies.addItem(self.tr("Prescribed flux"), 'neumann')
self.modelTypeMeteo.addItem( self.tr("Prescribed flux"), 'neumann')
elif self.nature == 'wall':
self.modelTypeThermal.addItem(self.tr("Prescribed flux"), 'neumann')
self.modelTypeSpecies.addItem(self.tr("Prescribed flux"), 'neumann')
self.modelTypeMeteo.addItem( self.tr("Prescribed flux"), 'neumann')
self.modelTypeThermal.addItem(self.tr("Prescribed flux (user law)"), 'neumann_formula')
self.modelTypeSpecies.addItem(self.tr("Prescribed flux (user law)"), 'neumann_formula')
self.modelTypeMeteo.addItem( self.tr("Prescribed flux (user law)"), 'neumann_formula')
self.modelTypeThermal.addItem(self.tr("Exchange coefficient"), 'exchange_coefficient')
self.modelTypeSpecies.addItem(self.tr("Exchange coefficient"), 'exchange_coefficient')
self.modelTypeMeteo.addItem( self.tr("Exchange coefficient"), 'exchange_coefficient')
self.modelTypeThermal.addItem(self.tr("Exchange coefficient (user law)"), 'exchange_coefficient_formula')
self.modelTypeSpecies.addItem(self.tr("Exchange coefficient (user law)"), 'exchange_coefficient_formula')
self.modelTypeMeteo.addItem( self.tr("Exchange coefficient (user law)"), 'exchange_coefficient_formula')
self.species = ""
self.species_list = self.sca_mo.getUserScalarNameList()
for s in self.sca_mo.getScalarsVarianceList():
if s in self.species_list:
self.species_list.remove(s)
self.species = ""
if self.species_list != []:
self.groupBoxSpecies.show()
self.modelSpecies = ComboModel(self.comboBoxSpecies, 1, 1)
for species in self.species_list:
self.modelSpecies.addItem(self.tr(species), species)
self.species = self.species_list[0]
self.modelSpecies.setItem(str_model = self.species)
else:
self.groupBoxSpecies.hide()
self.model_th = self.therm.getThermalScalarModel()
if self.model_th != 'off' and self.comp.getCompressibleModel() == 'off':
self.groupBoxThermal.show()
self.modelThermal = ComboModel(self.comboBoxThermal,1,1)
self.thermal = self.therm.getThermalScalarName()
self.modelThermal.addItem(self.tr(self.thermal),self.thermal)
self.modelThermal.setItem(str_model = self.thermal)
else:
self.groupBoxThermal.hide()
self.meteo_list = ""
self.meteo_list = self.sca_mo.getMeteoScalarsNameList()
self.groupBoxMeteo.hide()
if (self.atm.getAtmosphericFlowsModel() != "off" and self.nature == 'wall'):
self.groupBoxThermal.hide()
if (self.atm.getAtmosphericFlowsModel() != "off" and \
(self.nature == 'inlet' or self.nature == 'outlet')):
label = self.__boundary.getLabel()
nature = "meteo_" + self.nature
bb = Boundary(nature, label, self.__case)
if bb.getMeteoDataStatus() == 'off':
self.groupBoxMeteo.hide()
self.groupBoxThermal.show()
self.modelMeteo = ComboModel(self.comboBoxMeteo, 1, 1)
if len(self.meteo_list) > 0:
self.groupBoxMeteo.show()
for m in self.meteo_list:
self.modelMeteo.addItem(self.tr(m), m)
self.meteo = self.meteo_list[0]
self.modelMeteo.setItem(str_model = self.meteo)
else:
self.groupBoxMeteo.hide()
self.groupBoxThermal.hide()
self.initializeVariables()
def __setBoundary(self, boundary):
"""
Set the current boundary
"""
self.__boundary = boundary
self.nature = boundary.getNature()
self.therm = ThermalScalarModel(self.__case)
self.sca_mo = DefineUserScalarsModel(self.__case)
self.comp = CompressibleModel(self.__case)
self.atm = AtmosphericFlowsModel(self.__case)
self.modelTypeThermal = ComboModel(self.comboBoxTypeThermal, 1, 1)
self.modelTypeSpecies = ComboModel(self.comboBoxTypeSpecies, 1, 1)
self.modelTypeMeteo = ComboModel(self.comboBoxTypeMeteo, 1, 1)
self.modelTypeThermal.addItem(self.tr("Prescribed value"), 'dirichlet')
self.modelTypeSpecies.addItem(self.tr("Prescribed value"), 'dirichlet')
self.modelTypeMeteo.addItem( self.tr("Prescribed value"), 'dirichlet')
self.modelTypeThermal.addItem(self.tr("Prescribed value (user law)"), 'dirichlet_formula')
self.modelTypeSpecies.addItem(self.tr("Prescribed value (user law)"), 'dirichlet_formula')
self.modelTypeMeteo.addItem( self.tr("Prescribed value (user law)"), 'dirichlet_formula')
if self.nature == 'outlet':
self.modelTypeThermal.addItem(self.tr("Prescribed (outgoing) flux"), 'neumann')
self.modelTypeSpecies.addItem(self.tr("Prescribed (outgoing) flux"), 'neumann')
self.modelTypeMeteo.addItem( self.tr("Prescribed (outgoing) flux"), 'neumann')
elif self.nature == 'wall':
self.modelTypeThermal.addItem(self.tr("Prescribed (outgoing) flux"), 'neumann')
self.modelTypeSpecies.addItem(self.tr("Prescribed (outgoing) flux"), 'neumann')
self.modelTypeMeteo.addItem( self.tr("Prescribed (outgoing) flux"), 'neumann')
self.modelTypeThermal.addItem(self.tr("Prescribed (outgoing) flux (user law)"), 'neumann_formula')
self.modelTypeSpecies.addItem(self.tr("Prescribed (outgoing) flux (user law)"), 'neumann_formula')
self.modelTypeMeteo.addItem( self.tr("Prescribed (outgoing) flux (user law)"), 'neumann_formula')
self.modelTypeThermal.addItem(self.tr("Exchange coefficient"), 'exchange_coefficient')
self.modelTypeSpecies.addItem(self.tr("Exchange coefficient"), 'exchange_coefficient')
self.modelTypeMeteo.addItem( self.tr("Exchange coefficient"), 'exchange_coefficient')
self.modelTypeThermal.addItem(self.tr("Exchange coefficient (user law)"), 'exchange_coefficient_formula')
self.modelTypeSpecies.addItem(self.tr("Exchange coefficient (user law)"), 'exchange_coefficient_formula')
self.modelTypeMeteo.addItem( self.tr("Exchange coefficient (user law)"), 'exchange_coefficient_formula')
elif self.nature == 'groundwater':
self.modelTypeSpecies.addItem(self.tr("Prescribed (outgoing) flux"), 'neumann')
self.species = ""
self.species_list = self.sca_mo.getUserScalarNameList()
for s in self.sca_mo.getScalarsVarianceList():
if s in self.species_list:
self.species_list.remove(s)
self.species = ""
if self.species_list != []:
self.groupBoxSpecies.show()
self.modelSpecies = ComboModel(self.comboBoxSpecies, 1, 1)
for species in self.species_list:
self.modelSpecies.addItem(self.tr(species), species)
self.species = self.species_list[0]
self.modelSpecies.setItem(str_model = self.species)
else:
self.groupBoxSpecies.hide()
self.model_th = self.therm.getThermalScalarModel()
if self.model_th != 'off' and self.comp.getCompressibleModel() == 'off':
self.groupBoxThermal.show()
self.modelThermal = ComboModel(self.comboBoxThermal,1,1)
self.thermal = self.therm.getThermalScalarName()
self.modelThermal.addItem(self.tr(self.thermal),self.thermal)
self.modelThermal.setItem(str_model = self.thermal)
else:
self.groupBoxThermal.hide()
self.meteo_list = ""
self.meteo_list = self.sca_mo.getMeteoScalarsNameList()
self.groupBoxMeteo.hide()
if (self.atm.getAtmosphericFlowsModel() != "off" and self.nature == 'wall'):
self.modelMeteo = ComboModel(self.comboBoxMeteo, 1, 1)
if len(self.meteo_list) > 0:
self.groupBoxMeteo.show()
for m in self.meteo_list:
self.modelMeteo.addItem(self.tr(m), m)
self.meteo = self.meteo_list[0]
self.modelMeteo.setItem(str_model = self.meteo)
if (self.atm.getAtmosphericFlowsModel() != "off" and \
(self.nature == 'inlet' or self.nature == 'outlet')):
label = self.__boundary.getLabel()
nature = "meteo_" + self.nature
bb = Boundary(nature, label, self.__case)
if bb.getMeteoDataStatus() == 'off':
self.groupBoxMeteo.hide()
self.groupBoxThermal.show()
self.modelMeteo = ComboModel(self.comboBoxMeteo, 1, 1)
if len(self.meteo_list) > 0:
self.groupBoxMeteo.show()
for m in self.meteo_list:
self.modelMeteo.addItem(self.tr(m), m)
self.meteo = self.meteo_list[0]
self.modelMeteo.setItem(str_model = self.meteo)
else:
self.groupBoxMeteo.hide()
self.groupBoxThermal.hide()
self.initializeVariables()
class BoundaryConditionsCompressibleOutletView(
QWidget, Ui_BoundaryConditionsCompressibleOutletForm):
def __init__(self, parent):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_BoundaryConditionsCompressibleOutletForm.__init__(self)
self.setupUi(self)
def setup(self, case):
"""
Setup the widget
"""
self.__case = case
self.__boundary = None
self.__case.undoStopGlobal()
self.mdl = CompressibleModel(self.__case)
# Connections
self.comboBoxTypeOutlet.activated[str].connect(self.slotOutletType)
self.lineEditPressure.textChanged[str].connect(self.slotPressureValue)
# Combo models
self.modelTypeOutlet = ComboModel(self.comboBoxTypeOutlet, 2, 1)
self.modelTypeOutlet.addItem(self.tr("supersonic outlet"),
'supersonic_outlet')
self.modelTypeOutlet.addItem(self.tr("subsonic outlet"),
'subsonic_outlet')
# Validators
validatorP = DoubleValidator(self.lineEditPressure, min=0.0)
# Apply validators
self.lineEditPressure.setValidator(validatorP)
self.__case.undoStartGlobal()
def showWidget(self, boundary):
"""
Show the widget
"""
label = boundary.getLabel()
self.__boundary = Boundary('compressible_outlet', label, self.__case)
self.initialize()
def initialize(self):
# Initialize thermodynamic value
outlet_type = self.__boundary.getOutletType()
self.modelTypeOutlet.setItem(str_model=outlet_type)
self.__boundary.setOutletType(outlet_type)
if outlet_type == 'supersonic_outlet':
self.frameDensity.hide()
else:
self.frameDensity.show()
pressure = self.__boundary.getPressureValue()
self.lineEditPressure.setText(str(pressure))
self.show()
def hideWidget(self):
"""
Hide all
"""
self.hide()
@pyqtSlot(str)
def slotOutletType(self, text):
"""
INPUT outlet type
"""
value = self.modelTypeOutlet.dicoV2M[str(text)]
log.debug("__slotOutletType value = %s " % value)
self.__boundary.setOutletType(value)
self.initialize()
@pyqtSlot(str)
def slotPressureValue(self, text):
"""
INPUT outlet pressure
"""
if self.sender().validator().state == QValidator.Acceptable:
t = from_qvariant(text, float)
self.__boundary.setPressureValue(t)
def getCompressibleModel(self):
"""
Return the compressible model
"""
model = self.mdl.getCompressibleModel()
return model
def tr(self, text):
"""
Translation
"""
return text
class BoundaryConditionsScalarsView(QWidget, Ui_BoundaryConditionsScalarsForm):
"""
"""
def __init__(self, parent):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_BoundaryConditionsScalarsForm.__init__(self)
self.setupUi(self)
def setup(self, case):
"""
Setup the widget
"""
self.__case = case
self.__boundary = None
self.__case.undoStopGlobal()
self.notebook = NotebookModel(self.__case)
self.lineEditValueThermal.textChanged[str].connect(self.slotValueThermal)
self.lineEditValueSpecies.textChanged[str].connect(self.slotValueSpecies)
self.lineEditValueMeteo.textChanged[str].connect(self.slotValueMeteo)
self.lineEditExThermal.textChanged[str].connect(self.slotExThermal)
self.lineEditExSpecies.textChanged[str].connect(self.slotExSpecies)
self.lineEditExMeteo.textChanged[str].connect(self.slotExMeteo)
self.pushButtonThermal.clicked.connect(self.slotThermalFormula)
self.pushButtonSpecies.clicked.connect(self.slotSpeciesFormula)
self.pushButtonMeteo.clicked.connect(self.slotMeteoFormula)
self.comboBoxThermal.activated[str].connect(self.slotThermalChoice)
self.comboBoxTypeThermal.activated[str].connect(self.slotThermalTypeChoice)
self.comboBoxSpecies.activated[str].connect(self.slotSpeciesChoice)
self.comboBoxTypeSpecies.activated[str].connect(self.slotSpeciesTypeChoice)
self.comboBoxMeteo.activated[str].connect(self.slotMeteoChoice)
self.comboBoxTypeMeteo.activated[str].connect(self.slotMeteoTypeChoice)
## Validators
validatorValueThermal = DoubleValidator(self.lineEditValueThermal)
validatorValueSpecies = DoubleValidator(self.lineEditValueSpecies)
validatorValueMeteo = DoubleValidator(self.lineEditValueMeteo)
validatorExThermal = DoubleValidator(self.lineEditExThermal)
validatorExSpecies = DoubleValidator(self.lineEditExSpecies)
validatorExMeteo = DoubleValidator(self.lineEditExMeteo)
self.lineEditValueThermal.setValidator(validatorValueThermal)
self.lineEditValueSpecies.setValidator(validatorValueSpecies)
self.lineEditValueMeteo.setValidator(validatorValueMeteo)
self.lineEditExThermal.setValidator(validatorExThermal)
self.lineEditExSpecies.setValidator(validatorExSpecies)
self.lineEditExMeteo.setValidator(validatorExMeteo)
self.__case.undoStartGlobal()
def __setBoundary(self, boundary):
"""
Set the current boundary
"""
self.__boundary = boundary
self.nature = boundary.getNature()
self.therm = ThermalScalarModel(self.__case)
self.sca_mo = DefineUserScalarsModel(self.__case)
self.comp = CompressibleModel(self.__case)
self.atm = AtmosphericFlowsModel(self.__case)
self.modelTypeThermal = ComboModel(self.comboBoxTypeThermal, 1, 1)
self.modelTypeSpecies = ComboModel(self.comboBoxTypeSpecies, 1, 1)
self.modelTypeMeteo = ComboModel(self.comboBoxTypeMeteo, 1, 1)
self.modelTypeThermal.addItem(self.tr("Prescribed value"), 'dirichlet')
self.modelTypeSpecies.addItem(self.tr("Prescribed value"), 'dirichlet')
self.modelTypeMeteo.addItem( self.tr("Prescribed value"), 'dirichlet')
self.modelTypeThermal.addItem(self.tr("Prescribed value (user law)"), 'dirichlet_formula')
self.modelTypeSpecies.addItem(self.tr("Prescribed value (user law)"), 'dirichlet_formula')
self.modelTypeMeteo.addItem( self.tr("Prescribed value (user law)"), 'dirichlet_formula')
if self.nature == 'outlet':
self.modelTypeThermal.addItem(self.tr("Prescribed (outgoing) flux"), 'neumann')
self.modelTypeSpecies.addItem(self.tr("Prescribed (outgoing) flux"), 'neumann')
self.modelTypeMeteo.addItem( self.tr("Prescribed (outgoing) flux"), 'neumann')
elif self.nature == 'wall':
self.modelTypeThermal.addItem(self.tr("Prescribed (outgoing) flux"), 'neumann')
self.modelTypeSpecies.addItem(self.tr("Prescribed (outgoing) flux"), 'neumann')
self.modelTypeMeteo.addItem( self.tr("Prescribed (outgoing) flux"), 'neumann')
self.modelTypeThermal.addItem(self.tr("Prescribed (outgoing) flux (user law)"), 'neumann_formula')
self.modelTypeSpecies.addItem(self.tr("Prescribed (outgoing) flux (user law)"), 'neumann_formula')
self.modelTypeMeteo.addItem( self.tr("Prescribed (outgoing) flux (user law)"), 'neumann_formula')
self.modelTypeThermal.addItem(self.tr("Exchange coefficient"), 'exchange_coefficient')
self.modelTypeSpecies.addItem(self.tr("Exchange coefficient"), 'exchange_coefficient')
self.modelTypeMeteo.addItem( self.tr("Exchange coefficient"), 'exchange_coefficient')
self.modelTypeThermal.addItem(self.tr("Exchange coefficient (user law)"), 'exchange_coefficient_formula')
self.modelTypeSpecies.addItem(self.tr("Exchange coefficient (user law)"), 'exchange_coefficient_formula')
self.modelTypeMeteo.addItem( self.tr("Exchange coefficient (user law)"), 'exchange_coefficient_formula')
elif self.nature == 'groundwater':
self.modelTypeSpecies.addItem(self.tr("Prescribed (outgoing) flux"), 'neumann')
self.species = ""
self.species_list = self.sca_mo.getUserScalarNameList()
for s in self.sca_mo.getScalarsVarianceList():
if s in self.species_list:
self.species_list.remove(s)
self.species = ""
if self.species_list != []:
self.groupBoxSpecies.show()
self.modelSpecies = ComboModel(self.comboBoxSpecies, 1, 1)
for species in self.species_list:
self.modelSpecies.addItem(self.tr(species), species)
self.species = self.species_list[0]
self.modelSpecies.setItem(str_model = self.species)
else:
self.groupBoxSpecies.hide()
self.model_th = self.therm.getThermalScalarModel()
if self.model_th != 'off' and self.comp.getCompressibleModel() == 'off':
self.groupBoxThermal.show()
self.modelThermal = ComboModel(self.comboBoxThermal,1,1)
self.thermal = self.therm.getThermalScalarName()
self.modelThermal.addItem(self.tr(self.thermal),self.thermal)
self.modelThermal.setItem(str_model = self.thermal)
else:
self.groupBoxThermal.hide()
self.meteo_list = ""
self.meteo_list = self.sca_mo.getMeteoScalarsNameList()
self.groupBoxMeteo.hide()
if (self.atm.getAtmosphericFlowsModel() != "off" and self.nature == 'wall'):
self.modelMeteo = ComboModel(self.comboBoxMeteo, 1, 1)
if len(self.meteo_list) > 0:
self.groupBoxMeteo.show()
for m in self.meteo_list:
self.modelMeteo.addItem(self.tr(m), m)
self.meteo = self.meteo_list[0]
self.modelMeteo.setItem(str_model = self.meteo)
if (self.atm.getAtmosphericFlowsModel() != "off" and \
(self.nature == 'inlet' or self.nature == 'outlet')):
label = self.__boundary.getLabel()
nature = "meteo_" + self.nature
bb = Boundary(nature, label, self.__case)
if bb.getMeteoDataStatus() == 'off':
self.groupBoxMeteo.hide()
self.groupBoxThermal.show()
self.modelMeteo = ComboModel(self.comboBoxMeteo, 1, 1)
if len(self.meteo_list) > 0:
self.groupBoxMeteo.show()
for m in self.meteo_list:
self.modelMeteo.addItem(self.tr(m), m)
self.meteo = self.meteo_list[0]
self.modelMeteo.setItem(str_model = self.meteo)
else:
self.groupBoxMeteo.hide()
self.groupBoxThermal.hide()
self.initializeVariables()
def initializeVariables(self):
"""
Initialize widget
"""
# Initalize exchange coef
self.lineEditExThermal.hide()
self.labelExThermal.hide()
self.lineEditExSpecies.hide()
self.labelExSpecies.hide()
self.lineEditExMeteo.hide()
self.labelExMeteo.hide()
# Initalize thermal
self.lineEditValueThermal.hide()
self.labelValueThermal.hide()
self.pushButtonThermal.setEnabled(False)
self.pushButtonThermal.setStyleSheet("background-color: None")
if self.model_th != 'off' and self.comp.getCompressibleModel() == 'off':
self.thermal_type = self.__boundary.getScalarChoice(self.thermal)
self.modelTypeThermal.setItem(str_model = self.thermal_type)
self.labelValueThermal.setText('Value')
self.groupBoxThermal.setTitle('Thermal')
if self.thermal_type in ('dirichlet', 'exchange_coefficient', 'neumann'):
self.labelValueThermal.show()
self.lineEditValueThermal.show()
if self.thermal_type == 'exchange_coefficient':
self.lineEditExThermal.show()
self.labelExThermal.show()
v = self.__boundary.getScalarValue(self.thermal, 'dirichlet')
w = self.__boundary.getScalarValue(self.thermal, 'exchange_coefficient')
self.lineEditValueThermal.setText(str(v))
self.lineEditExThermal.setText(str(w))
else:
v = self.__boundary.getScalarValue(self.thermal, self.thermal_type)
self.lineEditValueThermal.setText(str(v))
if self.thermal_type == 'neumann':
self.labelValueThermal.setText('Flux')
if self.nature == 'outlet':
self.groupBoxThermal.setTitle('Thermal for backflow')
elif self.thermal_type in ('exchange_coefficient_formula', 'dirichlet_formula', 'neumann_formula'):
self.pushButtonThermal.setEnabled(True)
exp = self.__boundary.getScalarFormula(self.thermal, self.thermal_type)
if exp:
self.pushButtonThermal.setStyleSheet("background-color: green")
self.pushButtonThermal.setToolTip(exp)
else:
self.pushButtonThermal.setStyleSheet("background-color: red")
# Initalize species
self.labelValueSpecies.hide()
self.lineEditValueSpecies.hide()
self.pushButtonSpecies.setEnabled(False)
self.pushButtonSpecies.setStyleSheet("background-color: None")
if self.species_list != None and self.species_list != []:
self.species_type = self.__boundary.getScalarChoice(self.species)
self.modelTypeSpecies.setItem(str_model = self.species_type)
self.labelValueSpecies.setText('Value')
self.groupBoxSpecies.setTitle('Species')
if self.species_type in ('dirichlet', 'exchange_coefficient', 'neumann'):
self.labelValueSpecies.show()
self.lineEditValueSpecies.show()
if self.species_type == 'exchange_coefficient':
self.lineEditExSpecies.show()
self.labelExSpecies.show()
v = self.__boundary.getScalarValue(self.species, 'dirichlet')
w = self.__boundary.getScalarValue(self.species, 'exchange_coefficient')
if self.nature == 'groundwater':
self.labelValueSpecies.setText('Velocity')
self.labelExSpecies.setText('Concentration')
self.lineEditValueSpecies.setText(str(v))
self.lineEditExSpecies.setText(str(w))
else:
v = self.__boundary.getScalarValue(self.species, self.species_type)
self.lineEditValueSpecies.setText(str(v))
if self.species_type == 'neumann':
self.labelValueSpecies.setText('Flux')
if self.nature == 'outlet':
self.groupBoxSpecies.setTitle('Species for backflow')
elif self.species_type in ('exchange_coefficient_formula', 'dirichlet_formula', 'neumann_formula'):
self.pushButtonSpecies.setEnabled(True)
exp = self.__boundary.getScalarFormula(self.species, self.species_type)
if exp:
self.pushButtonSpecies.setStyleSheet("background-color: green")
self.pushButtonSpecies.setToolTip(exp)
else:
self.pushButtonSpecies.setStyleSheet("background-color: red")
if self.nature == 'groundwater':
self.groupBoxSpecies.setTitle('Transport equation')
# Initalize meteo
self.labelValueMeteo.hide()
self.lineEditValueMeteo.hide()
self.pushButtonMeteo.setEnabled(False)
self.pushButtonMeteo.setStyleSheet("background-color: None")
if (self.meteo_list):
label = self.__boundary.getLabel()
if self.nature != 'wall':
nature = "meteo_" + self.nature
else:
nature = self.nature
bb = Boundary(nature, label, self.__case)
if self.nature == 'wall' or bb.getMeteoDataStatus() == 'off':
self.meteo_type = self.__boundary.getScalarChoice(self.meteo)
self.modelTypeMeteo.setItem(str_model = self.meteo_type)
self.labelValueMeteo.setText('Value')
self.groupBoxMeteo.setTitle('Meteo')
if self.meteo_type in ('dirichlet', 'exchange_coefficient', 'neumann'):
self.labelValueMeteo.show()
self.lineEditValueMeteo.show()
if self.meteo_type == 'exchange_coefficient':
self.lineEditExMeteo.show()
self.labelExMeteo.show()
v = self.__boundary.getScalarValue(self.meteo, 'dirichlet')
w = self.__boundary.getScalarValue(self.meteo, 'exchange_coefficient')
self.lineEditValueMeteo.setText(str(v))
self.lineEditExMeteo.setText(str(w))
else:
v = self.__boundary.getScalarValue(self.meteo, self.meteo_type)
self.lineEditValueMeteo.setText(str(v))
if self.meteo_type == 'neumann':
self.labelValueMeteo.setText('Flux')
if self.nature == 'outlet':
self.groupBoxMeteo.setTitle('Meteo for backflow')
if self.meteo_type in ('exchange_coefficient_formula', 'dirichlet_formula', 'neumann_formula'):
self.pushButtonMeteo.setEnabled(True)
exp = self.__boundary.getScalarFormula(self.meteo, self.meteo_type)
if exp:
self.pushButtonMeteo.setStyleSheet("background-color: green")
self.pushButtonMeteo.setToolTip(exp)
else:
self.pushButtonMeteo.setStyleSheet("background-color: red")
def showWidget(self, boundary):
"""
Show the widget
"""
if DefineUserScalarsModel(self.__case).getScalarNameList() or\
DefineUserScalarsModel(self.__case).getMeteoScalarsNameList() or\
DefineUserScalarsModel(self.__case).getThermalScalarName():
self.__setBoundary(boundary)
self.show()
else:
self.hideWidget()
def hideWidget(self):
"""
Hide all
"""
self.hide()
@pyqtSlot(str)
def slotThermalChoice(self, text):
"""
INPUT label for choice of zone
"""
self.thermal = self.modelThermal.dicoV2M[str(text)]
self.initializeVariables()
@pyqtSlot(str)
def slotThermalTypeChoice(self, text):
"""
INPUT label for choice of zone
"""
self.thermal_type = self.modelTypeThermal.dicoV2M[str(text)]
self.__boundary.setScalarChoice(self.thermal, self.thermal_type)
self.initializeVariables()
@pyqtSlot(str)
def slotSpeciesChoice(self, text):
"""
INPUT label for choice of zone
"""
self.species = self.modelSpecies.dicoV2M[str(text)]
self.initializeVariables()
@pyqtSlot(str)
def slotSpeciesTypeChoice(self, text):
"""
INPUT label for choice of zone
"""
self.species_type = self.modelTypeSpecies.dicoV2M[str(text)]
self.__boundary.setScalarChoice(self.species, self.species_type)
self.initializeVariables()
@pyqtSlot(str)
def slotMeteoChoice(self, text):
"""
INPUT label for choice of zone
"""
self.meteo = self.modelMeteo.dicoV2M[str(text)]
self.initializeVariables()
@pyqtSlot(str)
def slotMeteoTypeChoice(self, text):
"""
INPUT label for choice of zone
"""
self.meteo_type= self.modelTypeMeteo.dicoV2M[str(text)]
self.__boundary.setScalarChoice(self.meteo, self.meteo_type)
self.initializeVariables()
@pyqtSlot()
def slotThermalFormula(self):
"""
"""
name = self.thermal
exp = self.__boundary.getScalarFormula(self.thermal, self.thermal_type)
exa = """#example: """
if self.thermal_type == 'dirichlet_formula':
req = [(name, str(name))]
elif self.thermal_type == 'neumann_formula':
req = [("flux", "flux")]
elif self.thermal_type == 'exchange_coefficient_formula':
req = [(name, str(name)),("hc", "heat coefficient")]
sym = [('x', "X face's gravity center"),
('y', "Y face's gravity center"),
('z', "Z face's gravity center"),
('dt', 'time step'),
('t', 'current time'),
('iter', 'number of iteration')]
for (nme, val) in self.notebook.getNotebookList():
sym.append((nme, 'value (notebook) = ' + str(val)))
dialog = QMeiEditorView(self,
check_syntax = self.__case['package'].get_check_syntax(),
expression = exp,
required = req,
symbols = sym,
examples = exa)
if dialog.exec_():
result = dialog.get_result()
log.debug("slotThermalFormula -> %s" % str(result))
self.__boundary.setScalarFormula(self.thermal, self.thermal_type, str(result))
self.pushButtonThermal.setStyleSheet("background-color: green")
self.pushButtonThermal.setToolTip(exp)
@pyqtSlot()
def slotSpeciesFormula(self):
"""
"""
exp = self.__boundary.getScalarFormula(self.species, self.species_type)
exa = """#example: """
if self.species_type == 'dirichlet_formula':
req = [(self.species, str(self.species))]
elif self.species_type == 'neumann_formula':
req = [("flux", "flux")]
elif self.species_type == 'exchange_coefficient_formula':
req = [(self.species, str(self.species)),("hc", "heat coefficient")]
sym = [('x', "X face's gravity center"),
('y', "Y face's gravity center"),
('z', "Z face's gravity center"),
('dt', 'time step'),
('t', 'current time'),
('iter', 'number of iteration')]
for (nme, val) in self.notebook.getNotebookList():
sym.append((nme, 'value (notebook) = ' + str(val)))
dialog = QMeiEditorView(self,
check_syntax = self.__case['package'].get_check_syntax(),
expression = exp,
required = req,
symbols = sym,
examples = exa)
if dialog.exec_():
result = dialog.get_result()
log.debug("slotSpeciesFormula -> %s" % str(result))
self.__boundary.setScalarFormula(self.species, self.species_type, str(result))
self.pushButtonSpecies.setStyleSheet("background-color: green")
self.pushButtonSpecies.setToolTip(exp)
@pyqtSlot()
def slotMeteoFormula(self):
"""
"""
exp = self.__boundary.getScalarFormula(self.meteo, self.meteo_type)
exa = """#example: """
if self.meteo_type == 'dirichlet_formula':
req = [(self.meteo, str(self.meteo))]
elif self.meteo_type == 'neumann_formula':
req = [("flux", "flux")]
elif self.meteo_type == 'exchange_coefficient_formula':
req = [(self.meteo, str(self.meteo)),
("hc", "heat coefficient")]
sym = [('x', "X face's gravity center"),
('y', "Y face's gravity center"),
('z', "Z face's gravity center"),
('dt', 'time step'),
('t', 'current time'),
('iter', 'number of iteration')]
for (nme, val) in self.notebook.getNotebookList():
sym.append((nme, 'value (notebook) = ' + str(val)))
dialog = QMeiEditorView(self,
check_syntax = self.__case['package'].get_check_syntax(),
expression = exp,
required = req,
symbols = sym,
examples = exa)
if dialog.exec_():
result = dialog.get_result()
log.debug("slotMeteoFormula -> %s" % str(result))
self.__boundary.setScalarFormula(self.meteo, self.meteo_type, str(result))
self.pushButtonMeteo.setStyleSheet("background-color: green")
self.pushButtonMeteo.setToolTip(exp)
@pyqtSlot(str)
def slotValueThermal(self, var):
"""
"""
if self.lineEditValueThermal.validator().state == QValidator.Acceptable:
value = from_qvariant(var, float)
if self.thermal_type in ('dirichlet', 'neumann'):
self.__boundary.setScalarValue(self.thermal, self.thermal_type, value)
elif self.thermal_type == 'exchange_coefficient':
self.__boundary.setScalarValue(self.thermal, 'dirichlet', value)
@pyqtSlot(str)
def slotValueSpecies(self, var):
"""
"""
if self.lineEditValueSpecies.validator().state == QValidator.Acceptable:
value = from_qvariant(var, float)
if self.species_type in ('dirichlet', 'neumann'):
self.__boundary.setScalarValue(self.species, self.species_type, value)
elif self.species_type == 'exchange_coefficient' :
self.__boundary.setScalarValue(self.species, 'dirichlet', value)
@pyqtSlot(str)
def slotValueMeteo(self, var):
"""
"""
if self.lineEditValueMeteo.validator().state == QValidator.Acceptable:
value = from_qvariant(var, float)
if self.meteo_type in ('dirichlet', 'neumann'):
self.__boundary.setScalarValue(self.meteo, self.meteo_type, value)
elif self.meteo_type == 'exchange_coefficient':
self.__boundary.setScalarValue(self.meteo, 'dirichlet', value)
@pyqtSlot(str)
def slotExThermal(self, var):
"""
"""
if self.lineEditExThermal.validator().state == QValidator.Acceptable:
value = from_qvariant(var, float)
self.__boundary.setScalarValue(self.thermal, 'exchange_coefficient', value)
@pyqtSlot(str)
def slotExSpecies(self, var):
"""
"""
if self.lineEditExSpecies.validator().state == QValidator.Acceptable:
value = from_qvariant(var, float)
self.__boundary.setScalarValue(self.species, 'exchange_coefficient', value)
@pyqtSlot(str)
def slotExMeteo(self, var):
"""
"""
if self.lineEditExMeteo.validator().state == QValidator.Acceptable:
value = from_qvariant(var, float)
self.__boundary.setScalarValue(self.meteo, 'exchange_coefficient', value)
def tr(self, text):
"""
Translation
"""
return text
class BoundaryConditionsCompressibleOutletView(QWidget, Ui_BoundaryConditionsCompressibleOutletForm):
def __init__(self, parent):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_BoundaryConditionsCompressibleOutletForm.__init__(self)
self.setupUi(self)
def setup(self, case):
"""
Setup the widget
"""
self.__case = case
self.__boundary = None
self.__case.undoStopGlobal()
self.mdl = CompressibleModel(self.__case)
# Connections
self.connect(self.comboBoxTypeOutlet, SIGNAL("activated(const QString&)"), self.slotOutletType)
self.connect(self.lineEditPressure, SIGNAL("textChanged(const QString &)"), self.slotPressureValue)
# Combo models
self.modelTypeOutlet = ComboModel(self.comboBoxTypeOutlet, 2, 1)
self.modelTypeOutlet.addItem(self.tr("supersonic outlet"), 'supersonic_outlet')
self.modelTypeOutlet.addItem(self.tr("subsonic outlet"), 'subsonic_outlet')
# Validators
validatorP = DoubleValidator(self.lineEditPressure, min = 0.0)
# Apply validators
self.lineEditPressure.setValidator(validatorP)
self.__case.undoStartGlobal()
def showWidget(self, boundary):
"""
Show the widget
"""
label = boundary.getLabel()
self.__boundary = Boundary('compressible_outlet', label, self.__case)
self.initialize()
def initialize(self):
# Initialize thermodynamic value
outlet_type = self.__boundary.getOutletType()
self.modelTypeOutlet.setItem(str_model = outlet_type)
self.__boundary.setOutletType(outlet_type)
if outlet_type == 'supersonic_outlet':
self.frameDensity.hide()
else:
self.frameDensity.show()
pressure = self.__boundary.getPressureValue()
self.lineEditPressure.setText(str(pressure))
self.show()
def hideWidget(self):
"""
Hide all
"""
self.hide()
@pyqtSignature("const QString&")
def slotOutletType(self, text):
"""
INPUT outlet type
"""
value = self.modelTypeOutlet.dicoV2M[str(text)]
log.debug("__slotOutletType value = %s " % value)
self.__boundary.setOutletType(value)
self.initialize()
@pyqtSignature("const QString&")
def slotPressureValue(self, text):
"""
INPUT outlet pressure
"""
if self.sender().validator().state == QValidator.Acceptable:
t = from_qvariant(text, float)
self.__boundary.setPressureValue(t)
def getCompressibleModel(self):
"""
Return the compressible model
"""
model = self.mdl.getCompressibleModel()
return model
def tr(self, text):
"""
Translation
"""
return text