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.getConvectiveInletStatus() == "on":
checked = True
if checked:
self.groupBoxConvectiveInlet.setChecked(True)
else:
self.groupBoxConvectiveInlet.setChecked(False)
self.__slotConvectiveInlet(checked)
if hide:
self.hide()
else:
self.show()
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
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()
def getVelocityExpression(self, boundary):
"""
Get the mathematical expression for velocity
"""
exp = boundary.getVelocity()
c = boundary.getVelocityChoice()
if c == 'norm_formula':
n = 'u_norm'
elif c == 'flow1_formula':
n = 'q_m'
elif c == 'flow2_formula':
n = 'q_v'
return exp, n
@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
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
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()