def getReference(self):
"""
return reference value for EOS
"""
reference = ""
material = self.getMaterials()
method = self.getMethod()
if method in ("user_properties", "freesteam", "CoolProp"):
return None
nodem = self.node_fluid.xmlGetChildNode('method')
reference = nodem.xmlGetString('reference')
if not reference and self.lib_properties[
material] & self.mask_EOS and EOS:
self.ava = eosAva.EosAvailable()
self.ava.setMethods(material)
self.ava.setReferences(material, self.getMethod())
ref = self.ava.whichReferences()
if ref:
reference = ref[0]
# update XML
self.setReference('reference')
return reference
def getReference(self):
"""
return reference value for EOS
"""
reference = ""
material = self.getMaterials()
method = self.getMethod()
if material == "user_material":
reference = material
else:
if self.freesteam == 1:
if self.getMethod() == "freesteam":
reference = "freesteam"
if self.coolprop == 1:
if self.getMethod() == "CoolProp":
reference = "CoolProp"
if EOS == 1:
if self.getMethod() != "freesteam" and self.getMethod(
) != "CoolProp":
phas = self.getFieldNature()
self.ava = eosAva.EosAvailable()
self.ava.setMethods(material)
self.ava.setReferences(material, self.getMethod())
ref = self.ava.whichReferences()
if phas == "liquid":
reference = ref[0]
elif phas == "gas":
reference = ref[1]
# update XML
childNode = self.node_fluid.xmlInitChildNode('reference')
childNode.xmlSetAttribute(choice=reference)
return reference
def getAvailReferences(self, material, method):
"""
return available reference value for EOS
"""
if method in ("user_properties", "freesteam", "CoolProp"):
return None
references = []
if EOS:
self.ava = eosAva.EosAvailable()
self.ava.setMethods(material)
self.ava.setReferences(material, self.getMethod())
references = self.ava.whichReferences()
return references
def __init__(self):
"""
Constructor
"""
self._has_eos = True
try:
import eosAva
except:
self._has_eos = False
else:
import eosAva
if self._has_eos:
self._ava = eosAva.EosAvailable()
def updateMethod(self, oldMaterial):
"""
update reference value for EOS
"""
material = self.getMaterials()
if oldMaterial != material:
if material == self.defaultFluidCharacteristicsValues()['material'] :
self.setMethod(self.defaultFluidCharacteristicsValues()['method'])
elif EOS == 1:
self.ava = eosAva.EosAvailable()
self.ava.setMethods(material)
self.setMethod(self.ava.whichMethods()[0])
elif self.coolprop == 1:
self.setMethod("CoolProp")
else:
self.setMethod("freesteam")
# suppress phas choice if not EOS
if self.getMethod() == self.defaultFluidCharacteristicsValues()['method'] or \
self.getMethod() == "freesteam" or self.getMethod() == "CoolProp":
nodem = self.node_fluid.xmlGetNode('phas')
if nodem:
nodem.xmlRemoveNode()
def __init__(self, parent, case):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_FluidCharacteristicsForm.__init__(self)
self.setupUi(self)
self.case = case
self.case.undoStopGlobal()
self.mdl = FluidCharacteristicsModel(self.case)
self.notebook = NotebookModel(self.case)
if EOS == 1:
self.ava = eosAva.EosAvailable()
import cs_config
cfg = cs_config.config()
self.freesteam = 0
if cfg.libs['freesteam'].have != "no":
self.freesteam = 1
self.m_th = ThermalScalarModel(self.case)
s = self.m_th.getThermalScalarName()
tsm = self.mdl.tsm
# Particular Widget initialization taking into account of "Calculation Features"
mdl_atmo, mdl_joule, mdl_thermal, mdl_gas, mdl_coal, mdl_comp = self.mdl.getThermoPhysicalModel(
)
# Combo models
self.modelRho = ComboModel(self.comboBoxRho, 3, 1)
self.modelMu = ComboModel(self.comboBoxMu, 3, 1)
self.modelCp = ComboModel(self.comboBoxCp, 3, 1)
self.modelAl = ComboModel(self.comboBoxAl, 3, 1)
self.modelDiff = ComboModel(self.comboBoxDiff, 2, 1)
self.modelNameDiff = ComboModel(self.comboBoxNameDiff, 1, 1)
self.modelViscv0 = ComboModel(self.comboBoxViscv0, 3, 1)
self.modelDiftl0 = ComboModel(self.comboBoxDiftl0, 3, 1)
self.modelMaterial = ComboModel(self.comboBoxMaterial, 1, 1)
self.modelMethod = ComboModel(self.comboBoxMethod, 1, 1)
self.modelPhas = ComboModel(self.comboBoxPhas, 2, 1)
self.modelRho.addItem(self.tr('constant'), 'constant')
self.modelRho.addItem(self.tr('user law'), 'user_law')
self.modelRho.addItem(self.tr('material law'), 'thermal_law')
if mdl_atmo != 'off':
self.modelRho.addItem(self.tr('defined in atphyv'),
'predefined_law')
elif mdl_joule == 'arc':
self.modelRho.addItem(self.tr('defined in elphyv'),
'predefined_law')
elif mdl_comp != 'off':
self.modelRho.addItem(self.tr('predefined law'), 'predefined_law')
elif mdl_gas != 'off' or mdl_coal != 'off':
self.modelRho.addItem(self.tr('predefined law'), 'predefined_law')
self.modelMu.addItem(self.tr('constant'), 'constant')
self.modelMu.addItem(self.tr('user law'), 'user_law')
self.modelMu.addItem(self.tr('material law'), 'thermal_law')
if mdl_joule == 'arc':
self.modelMu.addItem(self.tr('defined in elphyv'),
'predefined_law')
self.modelCp.addItem(self.tr('constant'), 'constant')
self.modelCp.addItem(self.tr('user law'), 'user_law')
self.modelCp.addItem(self.tr('material law'), 'thermal_law')
if mdl_joule == 'arc':
self.modelCp.addItem(self.tr('defined in elphyv'),
'predefined_law')
self.modelAl.addItem(self.tr('constant'), 'constant')
self.modelAl.addItem(self.tr('user law'), 'user_law')
self.modelAl.addItem(self.tr('material law'), 'thermal_law')
if mdl_joule == 'arc':
self.modelAl.addItem(self.tr('defined in elphyv'),
'predefined_law')
self.modelDiff.addItem(self.tr('constant'), 'constant')
self.modelDiff.addItem(self.tr('user law'), 'user_law')
self.modelViscv0.addItem(self.tr('constant'), 'constant')
self.modelViscv0.addItem(self.tr('user law'), 'user_law')
self.modelViscv0.addItem(self.tr('material law'), 'thermal_law')
self.modelDiftl0.addItem(self.tr('constant'), 'constant')
self.modelDiftl0.addItem(self.tr('user law'), 'user_law')
self.modelDiftl0.addItem(self.tr('material law'), 'thermal_law')
if mdl_gas != 'off' or mdl_coal != 'off':
self.modelDiftl0.addItem(self.tr('predefined law'),
'predefined_law')
self.modelPhas.addItem(self.tr('liquid'), 'liquid')
self.modelPhas.addItem(self.tr('gas'), 'gas')
self.scalar = ""
scalar_list = self.mdl.m_sca.getUserScalarNameList()
for s in self.mdl.m_sca.getScalarsVarianceList():
if s in scalar_list: scalar_list.remove(s)
if scalar_list != []:
self.scalar = scalar_list[0]
for scalar in scalar_list:
self.modelNameDiff.addItem(scalar)
# Validators
validatorP0 = DoubleValidator(self.lineEditP0, min=0.0)
self.lineEditP0.setValidator(validatorP0)
validatorT0 = DoubleValidator(self.lineEditT0, min=0.0)
validatorT0.setExclusiveMin(True)
self.lineEditT0.setValidator(validatorT0)
validatorOxydant = DoubleValidator(self.lineEditOxydant, min=0.0)
validatorOxydant.setExclusiveMin(True)
self.lineEditOxydant.setValidator(validatorOxydant)
validatorFuel = DoubleValidator(self.lineEditFuel, min=0.0)
validatorFuel.setExclusiveMin(True)
self.lineEditFuel.setValidator(validatorFuel)
validatorMM = DoubleValidator(self.lineEditMassMolar, min=0.0)
validatorMM.setExclusiveMin(True)
self.lineEditMassMolar.setValidator(validatorMM)
validatorRho = DoubleValidator(self.lineEditRho, min=0.0)
validatorMu = DoubleValidator(self.lineEditMu, min=0.0)
validatorCp = DoubleValidator(self.lineEditCp, min=0.0)
validatorAl = DoubleValidator(self.lineEditAl, min=0.0)
validatorDiff = DoubleValidator(self.lineEditDiff, min=0.0)
validatorViscv0 = DoubleValidator(self.lineEditViscv0, min=0.0)
validatorDiftl0 = DoubleValidator(self.lineEditDiftl0, min=0.0)
validatorRho.setExclusiveMin(True)
validatorMu.setExclusiveMin(True)
validatorCp.setExclusiveMin(True)
validatorAl.setExclusiveMin(True)
validatorDiff.setExclusiveMin(True)
validatorDiftl0.setExclusiveMin(True)
self.lineEditRho.setValidator(validatorRho)
self.lineEditMu.setValidator(validatorMu)
self.lineEditCp.setValidator(validatorCp)
self.lineEditAl.setValidator(validatorAl)
self.lineEditDiff.setValidator(validatorDiff)
self.lineEditViscv0.setValidator(validatorViscv0)
self.lineEditDiftl0.setValidator(validatorDiftl0)
# Connections
self.lineEditP0.textChanged[str].connect(self.slotPressure)
self.lineEditT0.textChanged[str].connect(self.slotTemperature)
self.lineEditOxydant.textChanged[str].connect(self.slotTempOxydant)
self.lineEditFuel.textChanged[str].connect(self.slotTempFuel)
self.lineEditMassMolar.textChanged[str].connect(self.slotMassemol)
self.comboBoxRho.currentIndexChanged[str].connect(self.slotStateRho)
self.comboBoxMu.currentIndexChanged[str].connect(self.slotStateMu)
self.comboBoxCp.currentIndexChanged[str].connect(self.slotStateCp)
self.comboBoxAl.currentIndexChanged[str].connect(self.slotStateAl)
self.comboBoxDiff.currentIndexChanged[str].connect(self.slotStateDiff)
self.comboBoxNameDiff.activated[str].connect(self.slotNameDiff)
self.comboBoxViscv0.currentIndexChanged[str].connect(
self.slotStateViscv0)
self.comboBoxMaterial.activated[str].connect(self.slotMaterial)
self.comboBoxMethod.activated[str].connect(self.slotMethod)
self.comboBoxPhas.activated[str].connect(self.slotPhas)
self.lineEditRho.textChanged[str].connect(self.slotRho)
self.lineEditMu.textChanged[str].connect(self.slotMu)
self.lineEditCp.textChanged[str].connect(self.slotCp)
self.lineEditAl.textChanged[str].connect(self.slotAl)
self.lineEditDiff.textChanged[str].connect(self.slotDiff)
self.lineEditDiftl0.textChanged[str].connect(self.slotDiftl0)
self.lineEditViscv0.textChanged[str].connect(self.slotViscv0)
self.pushButtonRho.clicked.connect(self.slotFormulaRho)
self.pushButtonMu.clicked.connect(self.slotFormulaMu)
self.pushButtonCp.clicked.connect(self.slotFormulaCp)
self.pushButtonAl.clicked.connect(self.slotFormulaAl)
self.pushButtonDiff.clicked.connect(self.slotFormulaDiff)
self.pushButtonViscv0.clicked.connect(self.slotFormulaViscv0)
self.initializeWidget()
self.case.undoStartGlobal()
def __init__(self, case):
"""FluidCharacteristicsModel Constuctor."""
self.case = case
self.node_models = self.case.xmlGetNode('thermophysical_models')
self.node_prop = self.case.xmlGetNode('physical_properties')
self.node_fluid = self.node_prop.xmlInitNode('fluid_properties')
self.node_comp = self.node_models.xmlInitNode('compressible_model',
'model')
self.node_gas = self.node_models.xmlInitNode('gas_combustion', 'model')
self.node_coal = self.node_models.xmlInitNode('solid_fuels', 'model')
# Info on available libraries
self.mask_builtin = 1 << 0
self.mask_CoolProp = 1 << 1
self.mask_EOS = 1 << 2
self.mask_freesteam = 1 << 3
self.tables = 0
from code_saturne import cs_config
cfg = cs_config.config()
self.lib_properties = {}
self.lib_properties['user_material'] = self.mask_builtin
if EOS == 1:
self.tables += self.mask_EOS
self.ava = eosAva.EosAvailable()
# suppress perfect gas
fls = self.ava.whichFluids()
for fli in fls:
if fli in eos_excl:
continue
if fli not in self.lib_properties.keys():
self.lib_properties[fli] = self.mask_EOS
else:
self.lib_properties[fli] += self.mask_EOS
if cfg.libs['freesteam'].have != "no":
self.tables += self.mask_freesteam
fli = 'Water'
if fli not in self.lib_properties.keys():
self.lib_properties[fli] = self.mask_freesteam
else:
self.lib_properties[fli] += self.mask_freesteam
if coolprop_fluids:
if cfg.libs['coolprop'].have != "no":
self.tables += self.mask_CoolProp
for fli in coolprop_fluids:
if fli not in self.lib_properties.keys():
self.lib_properties[fli] = self.mask_CoolProp
else:
self.lib_properties[fli] += self.mask_CoolProp
# Base model needs density and molecular viscosity
self.lst = [('density', 'Rho'), ('molecular_viscosity', 'Mu')]
self.node_density = self.setNewFluidProperty(self.node_fluid, \
'density')
self.node_viscosity = self.setNewFluidProperty(self.node_fluid, \
'molecular_viscosity')
self.node_lst = [self.node_density, self.node_viscosity]
self.node_heat = None
self.node_cond = None
self.node_vol_visc = None
self.node_dyn = None
# Get thermal scalar and model
thm = ThermalScalarModel(self.case)
tsn = thm.getThermalScalarName()
self.tsm = thm.getThermalScalarModel()
# If thermal model enabled, add thermal conductivity and specific heat
if self.tsm != "off":
self.lst.extend([('specific_heat', 'Cp'), \
('thermal_conductivity', 'Al')])
self.node_heat = self.setNewFluidProperty(self.node_fluid, \
'specific_heat')
self.node_cond = self.setNewFluidProperty(self.node_fluid, \
'thermal_conductivity')
self.node_lst.extend([self.node_heat, self.node_cond])
# Define volume viscosity for compressible model
if self.node_comp['model'] not in [None, "off"]:
self.lst.append(('volume_viscosity', 'Viscv0'))
self.node_vol_visc = self.setNewFluidProperty(self.node_fluid, \
'volume_viscosity')
self.node_lst.append(self.node_vol_visc)
# Define dynamic diffusion for reactive flow
elif self.node_coal['model'] not in [None, "off"] \
or self.node_gas['model'] not in [None, "off"]:
self.lst.append(('dynamic_diffusion', 'Diftl0'))
self.node_dyn = self.setNewFluidProperty(self.node_fluid, \
'dynamic_diffusion')
self.node_lst.append(self.node_dyn)
# Build scalars list
self.list_scalars = []
if self.tsm == "temperature_celsius":
self.list_scalars.append(
(tsn, self.tr("Thermal scalar: temperature (\xB0 C)")))
elif self.tsm == "temperature_kelvin":
self.list_scalars.append(
(tsn, self.tr("Thermal scalar: temperature (K)")))
elif self.tsm != "off":
self.list_scalars.append((tsn, self.tr("Thermal scalar")))
self.m_sca = DefineUserScalarsModel(self.case)
for s in self.m_sca.getUserScalarNameList():
self.list_scalars.append((s, self.tr("Additional scalar")))
# Notebook
self.notebook = NotebookModel(self.case)
