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 BoundaryConditionsElectricalView(QWidget, Ui_BoundaryConditionsElectricalForm):
"""
Boundary condifition for the velocity part
"""
def __init__(self, parent):
"""
Constructor.
"""
QWidget.__init__(self, parent)
Ui_BoundaryConditionsElectricalForm.__init__(self)
self.setupUi(self)
def setup(self, case):
"""
Setup the widget.
"""
self.__case = case
self.__boundary = None
self.__model = ElectricalModel(self.__case)
self.species_list = []
self.notebook = NotebookModel(self.__case)
self.lineEditValuePotElec.textChanged[str].connect(self.slotPotElec)
self.lineEditValuePotElecIm.textChanged[str].connect(self.slotPotElecIm)
self.lineEditValueSpecies.textChanged[str].connect(self.slotSpecies)
self.pushButtonPotVectorFormula.clicked.connect(self.slotPotVectorFormula)
self.comboBoxTypePotElec.activated[str].connect(self.slotPotElecChoice)
self.comboBoxTypePotElecIm.activated[str].connect(self.slotPotElecImChoice)
self.comboBoxTypePotVector.activated[str].connect(self.slotPotVectorChoice)
self.comboBoxSpecies.activated[str].connect(self.slotSpeciesChoice)
self.comboBoxPotVector.activated[str].connect(self.slotPotVectorComponentChoice)
## Validators
validatorPotElec = DoubleValidator(self.lineEditValuePotElec)
validatorPotElecIm = DoubleValidator(self.lineEditValuePotElecIm)
validatorSpecies = DoubleValidator(self.lineEditValueSpecies, min=0.)
self.lineEditValuePotElec.setValidator(validatorPotElec)
self.lineEditValuePotElecIm.setValidator(validatorPotElecIm)
self.lineEditValueSpecies.setValidator(validatorSpecies)
def __setBoundary(self, boundary):
"""
Set the current boundary
"""
self.__boundary = boundary
self.nature = boundary.getNature()
self.groupBoxPotElecIm.hide()
self.groupBoxPotVector.hide()
self.groupBoxMixture.hide()
self.modelPotElec = ComboModel(self.comboBoxTypePotElec, 1, 1)
self.modelPotElecIm = ComboModel(self.comboBoxTypePotElecIm, 1, 1)
self.modelPotVector = ComboModel(self.comboBoxTypePotVector, 1, 1)
self.modelPotElec.addItem(self.tr("Prescribed value"), 'dirichlet')
self.modelPotElec.addItem(self.tr("Prescribed value (user law)"), 'dirichlet_formula')
self.modelPotElec.addItem(self.tr("Prescribed flux"), 'neumann')
self.modelPotElec.addItem(self.tr("Prescribed flux (user law)"), 'neumann_formula')
if self.__model.getScaling() == 'on':
self.modelPotElec.addItem(self.tr("Implicit value (dpot)"), 'dirichlet_implicit')
#TODO
self.modelPotElec.disableItem(1)
self.modelPotElec.disableItem(3)
self.potElec = "elec_pot_r"
self.modelPotElecLabel = ComboModel(self.comboBoxPotElec,1,1)
self.modelPotElecLabel.addItem(self.tr(self.potElec),self.potElec)
self.modelPotElecLabel.setItem(str_model = self.potElec)
self.modelPotElecIm.addItem(self.tr("Prescribed value"), 'dirichlet')
self.modelPotElecIm.addItem(self.tr("Prescribed value (user law)"), 'dirichlet_formula')
self.modelPotElecIm.addItem(self.tr("Prescribed flux"), 'neumann')
self.modelPotElecIm.addItem(self.tr("Prescribed flux (user law)"), 'neumann_formula')
#TODO
self.modelPotElecIm.disableItem(1)
self.modelPotElecIm.disableItem(3)
self.potElecIm = 'elec_pot_i'
self.modelPotElecImLabel = ComboModel(self.comboBoxPotElecIm,1,1)
self.modelPotElecImLabel.addItem(self.tr(self.potElecIm),self.potElecIm)
self.modelPotElecImLabel.setItem(str_model = self.potElecIm)
self.modelPotVector.addItem(self.tr("Prescribed value (user law)"), 'dirichlet_formula')
self.modelPotVector.addItem(self.tr("Null flux"), 'neumann')
self.modelPotVector.addItem(self.tr("Implicit flux"), 'neumann_implicit')
self.modelPotVector.disableItem(0)
self.potVect = 'vec_potential'
self.modelPotVectLabel = ComboModel(self.comboBoxPotVector, 1, 1)
self.modelPotVectLabel.addItem(self.tr('vec_potential'), 'vec_potential')
self.modelPotVectLabel.setItem(str_model = self.potVect)
if self.__model.getElectricalModel() == 'joule':
if self.__model.getJouleModel() == 'three-phase' or \
self.__model.getJouleModel() == 'three-phase+Transformer':
self.groupBoxPotElecIm.show()
elif self.__model.getElectricalModel() == 'arc':
self.groupBoxPotVector.show()
self.species = ""
if self.nature == 'inlet':
if self.__model.getGasNumber() > 1:
self.groupBoxMixture.show()
self.modelSpecies = ComboModel(self.comboBoxSpecies, 1, 1)
self.species_list = self.__model.getSpeciesLabelsList()
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)
self.initializeVariables()
def initializeVariables(self):
"""
Initialize widget
"""
self.lineEditValuePotElec.hide()
self.lineEditValuePotElecIm.hide()
self.lineEditValuePotVector.hide()
self.labelValuePotVector.hide()
self.labelValuePotElec.hide()
self.labelValuePotElecIm.hide()
self.pushButtonPotVectorFormula.setEnabled(False)
self.pushButtonPotVectorFormula.setStyleSheet("background-color: None")
self.pushButtonPotElecFormula.setEnabled(False)
self.pushButtonPotElecFormula.setStyleSheet("background-color: None")
self.pushButtonPotElecImFormula.setEnabled(False)
self.pushButtonPotElecImFormula.setStyleSheet("background-color: None")
# Initialize electric potential
self.potElec_type = self.__b.getElecScalarChoice(self.potElec)
self.modelPotElec.setItem(str_model = self.potElec_type)
if self.potElec_type == 'dirichlet' or self.potElec_type == 'neumann':
self.lineEditValuePotElec.show()
self.labelValuePotElec.show()
v = self.__b.getElecScalarValue(self.potElec, self.potElec_type)
self.lineEditValuePotElec.setText(str(v))
# Initialize imaginary electric potential
if self.__model.getElectricalModel() == 'joule':
if self.__model.getJouleModel() == 'three-phase' or \
self.__model.getJouleModel() == 'three-phase+Transformer':
self.potElecIm_type = self.__b.getElecScalarChoice(self.potElecIm)
self.modelPotElecIm.setItem(str_model = self.potElecIm_type)
if self.potElecIm_type == 'dirichlet' or self.potElecIm_type == 'neumann':
self.lineEditValuePotElecIm.show()
self.labelValuePotElecIm.show()
v = self.__b.getElecScalarValue(self.potElecIm, self.potElecIm_type)
self.lineEditValuePotElecIm.setText(str(v))
# Initialize potential vector
if self.__model.getElectricalModel() == 'arc':
self.potVec_type = self.__b.getPotentialVectorChoice(self.potVect)
self.modelPotVector.setItem(str_model = self.potVec_type)
if self.potVec_type == 'dirichlet_formula':
self.pushButtonPotVectorFormula.setEnabled(True)
exp = self.__b.getElecScalarFormula(self.potVect, self.potVec_type)
if exp:
self.pushButtonPotVectorFormula.setStyleSheet("background-color: green")
self.pushButtonPotVectorFormula.setToolTip(exp)
else:
self.pushButtonPotVectorFormula.setStyleSheet("background-color: red")
# Initialize species
if self.species :
v = self.__b.getElecScalarValue(self.species, 'dirichlet')
self.lineEditValueSpecies.setText(str(v))
@pyqtSlot(str)
def slotPotElecChoice(self, text):
"""
INPUT choice for electric potential type
"""
potElec_type = self.modelPotElec.dicoV2M[str(text)]
self.__b.setElecScalarChoice(self.potElec, potElec_type)
self.initializeVariables()
@pyqtSlot(str)
def slotPotElecImChoice(self, text):
"""
INPUT choice for imaginary electric potential type
"""
potElecIm_type = self.modelPotElecIm.dicoV2M[str(text)]
self.__b.setElecScalarChoice(self.potElecIm, potElecIm_type)
self.initializeVariables()
@pyqtSlot(str)
def slotPotVectorChoice(self, text):
"""
INPUT choice for potential vector type
"""
potVec_choice = self.modelPotVector.dicoV2M[str(text)]
self.__b.setPotentialVectorChoice(self.potVect, potVec_choice)
self.initializeVariables()
@pyqtSlot(str)
def slotSpeciesChoice(self, text):
"""
INPUT species choice
"""
self.species = self.modelSpecies.dicoV2M[str(text)]
self.initializeVariables()
@pyqtSlot(str)
def slotPotVectorComponentChoice(self, text):
"""
INPUT potential vector component choice
"""
self.potVect = self.modelPotVectLabel.dicoV2M[str(text)]
self.initializeVariables()
@pyqtSlot(str)
def slotPotElec(self, var):
"""
"""
if self.sender().validator().state == QValidator.Acceptable:
value = from_qvariant(var, float)
self.__b.setElecScalarValue(self.potElec, self.potElec_type, value)
@pyqtSlot(str)
def slotPotElecIm(self, var):
"""
"""
if self.sender().validator().state == QValidator.Acceptable:
value = from_qvariant(var, float)
self.__b.setElecScalarValue(self.potElecIm, self.potElecIm_type, value)
@pyqtSlot(str)
def slotSpecies(self, var):
"""
"""
if self.sender().validator().state == QValidator.Acceptable:
value = from_qvariant(var, float)
self.__b.setElecScalarValue(self.species, 'dirichlet', value)
@pyqtSlot()
def slotPotVectorFormula(self):
"""
"""
exp = self.__b.getElecScalarFormula(self.potVect, self.potVec_type)
exa = """#example: """
if not exp:
exp = self.potVect + "[0] = 0;\n" + \
self.potVect + "[1] = 0;\n" + \
self.potVect + "[2] = 0;\n"
req = [(self.potVect + "[0]", 'vector potential X'),
(self.potVect + "[1]", 'vector potential Y'),
(self.potVect + "[2]", 'vector potential Z')]
sym = [('x', "X cell's gravity center"),
('y', "Y cell's gravity center"),
('z', "Z cell'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,expression = exp,
required = req,
symbols = sym,
examples = exa)
if dialog.exec_():
result = dialog.get_result()
log.debug("slotPotVectorFormula -> %s" % str(result))
self.__b.setElecScalarFormula(self.potVect, self.potVec_type, str(result))
self.pushButtonPotVectorFormula.setToolTip(result)
self.pushButtonPotVectorFormula.setStyleSheet("background-color: green")
def showWidget(self, b):
"""
Show the widget.
"""
self.__b = b
if self.__model.getElectricalModel() != 'off':
label = b.getLabel()
nature = "joule_" + b.getNature()
self.__b = Boundary(nature, label, self.__case)
self.__setBoundary(b)
self.show()
else:
self.hideWidget()
def hideWidget(self):
"""
Hide all.
"""
self.hide()
def tr(self, text):
"""
Translation.
"""
return text
class BoundaryConditionsExternalHeadLossesView(
QWidget, Ui_BoundaryConditionsExternalHeadLossesForm):
def __init__(self, parent):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_BoundaryConditionsExternalHeadLossesForm.__init__(self)
self.setupUi(self)
def setup(self, case):
"""
Setup the widget
"""
self.__case = case
self.__boundary = None
self.notebook = NotebookModel(self.__case)
self.__case.undoStopGlobal()
self.pushButtonHeadLossesFormula.clicked.connect(
self.slotHeadLossesFormula)
self.__case.undoStartGlobal()
def showWidget(self, b):
"""
Show the widget
"""
label = b.getLabel()
self.__boundary = Boundary('free_inlet_outlet', label, self.__case)
exp = self.__boundary.getHeadLossesFormula()
if exp:
self.pushButtonHeadLossesFormula.setStyleSheet(
"background-color: green")
self.pushButtonHeadLossesFormula.setToolTip(exp)
else:
self.pushButtonHeadLossesFormula.setStyleSheet(
"background-color: red")
self.show()
def hideWidget(self):
"""
Hide all
"""
self.hide()
@pyqtSlot()
def slotHeadLossesFormula(self):
"""
"""
exp = self.__boundary.getHeadLossesFormula()
req = [('K', 'External head losses')]
exa = "K = 0.;"
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.setHeadLossesFormula(str(result))
self.pushButtonHeadLossesFormula.setStyleSheet(
"background-color: green")
self.pushButtonHeadLossesFormula.setToolTip(result)
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)
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
class BoundaryConditionsTurbulenceInletView(QWidget, Ui_BoundaryConditionsTurbulenceInletForm):
"""
Boundary condition for turbulence
"""
def __init__(self, parent):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_BoundaryConditionsTurbulenceInletForm.__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.comboBoxTurbulence.activated[str].connect(self.__slotChoiceTurbulence)
self.__modelTurbulence = ComboModel(self.comboBoxTurbulence, 2, 1)
self.__modelTurbulence.addItem(self.tr("Calculation by hydraulic diameter"), 'hydraulic_diameter')
self.__modelTurbulence.addItem(self.tr("Calculation by turbulent intensity"), 'turbulent_intensity')
self.__modelTurbulence.addItem(self.tr("Calculation by formula"), 'formula')
self.lineEditDiameter.textChanged[str].connect(self.__slotDiam)
self.lineEditIntensity.textChanged[str].connect(self.__slotIntensity)
self.lineEditDiameterIntens.textChanged[str].connect(self.__slotDiam)
self.pushButtonTurb.clicked.connect(self.__slotTurbulenceFormula)
validatorDiam = DoubleValidator(self.lineEditDiameter, min=0.)
validatorDiam.setExclusiveMin(True)
validatorIntensity = DoubleValidator(self.lineEditIntensity, min=0.)
self.lineEditDiameter.setValidator(validatorDiam)
self.lineEditDiameterIntens.setValidator(validatorDiam)
self.lineEditIntensity.setValidator(validatorIntensity)
self.__case.undoStartGlobal()
def showWidget(self, boundary):
"""
Show the widget
"""
self.__boundary = boundary
if TurbulenceModel(self.__case).getTurbulenceVariable():
turb_choice = boundary.getTurbulenceChoice()
self.__modelTurbulence.setItem(str_model=turb_choice)
self.pushButtonTurb.setEnabled(False)
self.pushButtonTurb.setStyleSheet("background-color: None")
if turb_choice == "hydraulic_diameter":
self.frameTurbDiameter.show()
self.frameTurbIntensity.hide()
d = boundary.getHydraulicDiameter()
self.lineEditDiameter.setText(str(d))
elif turb_choice == "turbulent_intensity":
self.frameTurbIntensity.show()
self.frameTurbDiameter.hide()
i = boundary.getTurbulentIntensity()
d = boundary.getHydraulicDiameter()
self.lineEditIntensity.setText(str(i))
self.lineEditDiameterIntens.setText(str(d))
elif turb_choice == "formula":
self.frameTurbIntensity.hide()
self.frameTurbDiameter.hide()
self.pushButtonTurb.setEnabled(True)
exp = self.__boundary.getTurbFormula()
if exp:
self.pushButtonTurb.setStyleSheet("background-color: green")
self.pushButtonTurb.setToolTip(exp)
else:
self.pushButtonTurb.setStyleSheet("background-color: red")
self.show()
else:
self.hideWidget()
def hideWidget(self):
"""
Hide the widget
"""
self.hide()
@pyqtSlot(str)
def __slotChoiceTurbulence(self, text):
"""
INPUT choice of method of calculation of the turbulence
"""
turb_choice = self.__modelTurbulence.dicoV2M[str(text)]
self.__boundary.setTurbulenceChoice(turb_choice)
self.frameTurbDiameter.hide()
self.frameTurbIntensity.hide()
self.pushButtonTurb.setEnabled(False)
self.pushButtonTurb.setStyleSheet("background-color: None")
if turb_choice == 'hydraulic_diameter':
self.frameTurbDiameter.show()
d = self.__boundary.getHydraulicDiameter()
self.lineEditDiameter.setText(str(d))
elif turb_choice == 'turbulent_intensity':
self.frameTurbIntensity.show()
i = self.__boundary.getTurbulentIntensity()
self.lineEditIntensity.setText(str(i))
d = self.__boundary.getHydraulicDiameter()
self.lineEditDiameterIntens.setText(str(d))
elif turb_choice == 'formula':
self.pushButtonTurb.setEnabled(True)
exp = self.__boundary.getTurbFormula()
if exp:
self.pushButtonTurb.setStyleSheet("background-color: green")
self.pushButtonTurb.setToolTip(exp)
else:
self.pushButtonTurb.setStyleSheet("background-color: red")
@pyqtSlot(str)
def __slotDiam(self, text):
"""
INPUT hydraulic diameter
"""
if self.lineEditDiameter.validator().state == QValidator.Acceptable:
diam = from_qvariant(text, float)
self.__boundary.setHydraulicDiameter(diam)
@pyqtSlot(str)
def __slotIntensity(self, text):
"""
INPUT turbulent intensity
"""
if self.lineEditIntensity.validator().state == QValidator.Acceptable:
intens = from_qvariant(text, float)
self.__boundary.setTurbulentIntensity(intens)
@pyqtSlot()
def __slotTurbulenceFormula(self):
"""
INPUT user formula
"""
turb_model = TurbulenceModel(self.__case).getTurbulenceModel()
if turb_model in ('k-epsilon', 'k-epsilon-PL'):
exp = self.__boundary.getTurbFormula()
if not exp:
exp = self.__boundary.getDefaultTurbFormula(turb_model)
exa = """#example :
uref2 = 10.;
dh = 0.2;
re = sqrt(uref2)*dh*rho0/mu0;
if (re < 2000){
# in this case u*^2 is directly calculated to not have a problem with
# xlmbda=64/Re when Re->0
ustar2 = 8.*mu0*sqrt(uref2)/rho0/dh;}
else if (re<4000){
xlmbda = 0.021377 + 5.3115e-6*re;
ustar2 = uref2*xlmbda/8.;}
else {
xlmbda = 1/( 1.8*log(re)/log(10.)-1.64)^2;
ustar2 = uref2*xlmbda/8.;}
cmu = 0.09;
kappa = 0.42;
k = ustar2/sqrt(cmu);
epsilon = ustar2^1.5/(kappa*dh*0.1);"""
req = [('k', "turbulent energy"),
('epsilon', "turbulent dissipation")]
sym = [('x','cell center coordinate'),
('y','cell center coordinate'),
('z','cell center coordinate'),
('t','time'),
('dt','time step'),
('iter','number of time step')]
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("slotFormulaTurb -> %s" % str(result))
self.__boundary.setTurbFormula(str(result))
self.pushButtonTurb.setStyleSheet("background-color: green")
self.pushButtonTurb.setToolTip(result)
elif turb_model in ('Rij-epsilon', 'Rij-SSG'):
exp = self.__boundary.getTurbFormula()
if not exp:
exp = self.__boundary.getDefaultTurbFormula(turb_model)
exa = """#exemple :
uref2 = 10.;
dh = 0.2;
re = sqrt(uref2)*dh*rho0/mu0;
if (re < 2000){
# in this case u*^2 is directly calculated to not have a problem with
# xlmbda=64/Re when Re->0
ustar2 = 8.*mu0*sqrt(uref2)/rho0/dh;}
else if (re<4000){
xlmbda = 0.021377 + 5.3115e-6*re;
ustar2 = uref2*xlmbda/8.;}
else {
xlmbda = 1/( 1.8*log(re)/log(10.)-1.64)^2;
ustar2 = uref2*xlmbda/8.;}
cmu = 0.09;
kappa = 0.42;
k = ustar2/sqrt(cmu);
epsilon = ustar2^1.5/(kappa*dh*0.1);
d2s3 = 2/3;
r11 = d2s3*k;
r22 = d2s3*k;
r33 = d2s3*k;
r12 = 0;
r13 = 0;
r23 = 0;
"""
req = [('r11', "Reynolds stress R11"),
('r22', "Reynolds stress R22"),
('r33', "Reynolds stress R33"),
('r12', "Reynolds stress R12"),
('r13', "Reynolds stress R13"),
('r23', "Reynolds stress R23"),
('epsilon', "turbulent dissipation")]
sym = [('x','cell center coordinate'),
('y','cell center coordinate'),
('z','cell center coordinate'),
('t','time'),
('dt','time step'),
('iter','number of time step')]
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("slotFormulaTurb -> %s" % str(result))
self.__boundary.setTurbFormula(str(result))
self.pushButtonTurb.setStyleSheet("background-color: green")
self.pushButtonTurb.setToolTip(result)
elif turb_model == 'Rij-EBRSM':
exp = self.__boundary.getTurbFormula()
if not exp:
exp = self.__boundary.getDefaultTurbFormula(turb_model)
exa = """#exemple :
uref2 = 10.;
dh = 0.2;
re = sqrt(uref2)*dh*rho0/mu0;
if (re < 2000){
# in this case u*^2 is directly calculated to not have a problem with
# xlmbda=64/Re when Re->0
ustar2 = 8.*mu0*sqrt(uref2)/rho0/dh;}
else if (re<4000){
xlmbda = 0.021377 + 5.3115e-6*re;
ustar2 = uref2*xlmbda/8.;}
else {
xlmbda = 1/( 1.8*log(re)/log(10.)-1.64)^2;
ustar2 = uref2*xlmbda/8.;}
cmu = 0.09;
kappa = 0.42;
k = ustar2/sqrt(cmu);
epsilon = ustar2^1.5/(kappa*dh*0.1);
d2s3 = 2/3;
r11 = d2s3*k;
r22 = d2s3*k;
r33 = d2s3*k;
r12 = 0;
r13 = 0;
r23 = 0;
alpha = 1.;
"""
req = [('r11', "Reynolds stress R11"),
('r22', "Reynolds stress R22"),
('r33', "Reynolds stress R33"),
('r12', "Reynolds stress R12"),
('r13', "Reynolds stress R13"),
('r23', "Reynolds stress R23"),
('epsilon', "turbulent dissipation"),
('alpha', "alpha")]
sym = [('x','cell center coordinate'),
('y','cell center coordinate'),
('z','cell center coordinate'),
('t','time'),
('dt','time step'),
('iter','number of time step')]
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("slotFormulaTurb -> %s" % str(result))
self.__boundary.setTurbFormula(str(result))
self.pushButtonTurb.setStyleSheet("background-color: green")
self.pushButtonTurb.setToolTip(result)
elif turb_model == 'v2f-BL-v2/k':
exp = self.__boundary.getTurbFormula()
if not exp:
exp = self.__boundary.getDefaultTurbFormula(turb_model)
exa = """#exemple :
uref2 = 10.;
dh = 0.2;
re = sqrt(uref2)*dh*rho0/mu0;
if (re < 2000){
# in this case u*^2 is directly calculated to not have a problem with
# xlmbda=64/Re when Re->0
ustar2 = 8.*mu0*sqrt(uref2)/rho0/dh;}
else if (re<4000){
xlmbda = 0.021377 + 5.3115e-6*re;
ustar2 = uref2*xlmbda/8.;}
else {
xlmbda = 1/( 1.8*log(re)/log(10.)-1.64)^2;
ustar2 = uref2*xlmbda/8.;}
cmu = 0.09;
kappa = 0.42;
d2s3 = 2/3;
k = ustar2/sqrt(cmu);
epsilon = ustar2^1.5/(kappa*dh*0.1);
phi = d2s3;
alpha = 0;"""
req = [('k', "turbulent energy"),
('epsilon', "turbulent dissipation"),
('phi', "variable phi in v2f model"),
('alpha', "variable alpha in v2f model")]
sym = [('x','cell center coordinate'),
('y','cell center coordinate'),
('z','cell center coordinate'),
('t','time'),
('dt','time step'),
('iter','number of time step')]
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("slotFormulaTurb -> %s" % str(result))
self.__boundary.setTurbFormula(str(result))
self.pushButtonTurb.setStyleSheet("background-color: green")
self.pushButtonTurb.setToolTip(result)
elif turb_model == 'k-omega-SST':
exp = self.__boundary.getTurbFormula()
if not exp:
exp = self.__boundary.getDefaultTurbFormula(turb_model)
exa = """#exemple :
uref2 = 10.;
dh = 0.2;
re = sqrt(uref2)*dh*rho0/mu0;
if (re < 2000){
# in this case u*^2 is directly calculated to not have a problem with
# xlmbda=64/Re when Re->0
ustar2 = 8.*mu0*sqrt(uref2)/rho0/dh;}
else if (re<4000){
xlmbda = 0.021377 + 5.3115e-6*re;
ustar2 = uref2*xlmbda/8.;}
else {
xlmbda = 1/( 1.8*log(re)/log(10.)-1.64)^2;
ustar2 = uref2*xlmbda/8.;}
cmu = 0.09;
kappa = 0.42;
k = ustar2/sqrt(cmu);
eps = ustar2^1.5/(kappa*dh*0.1);
omega = eps/(cmu * k);"""
req = [('k', "turbulent energy"),
('omega', "specific dissipation rate")]
sym = [('x','cell center coordinate'),
('y','cell center coordinate'),
('z','cell center coordinate'),
('t','time'),
('dt','time step'),
('iter','number of time step')]
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("slotFormulaTurb -> %s" % str(result))
self.__boundary.setTurbFormula(str(result))
self.pushButtonTurb.setStyleSheet("background-color: green")
self.pushButtonTurb.setToolTip(result)
elif turb_model == 'Spalart-Allmaras':
exp = self.__boundary.getTurbFormula()
if not exp:
exp = self.__boundary.getDefaultTurbFormula(turb_model)
exa = """#exemple :
uref2 = 10.;
dh = 0.2;
re = sqrt(uref2)*dh*rho0/mu0;
if (re < 2000){
# in this case u*^2 is directly calculated to not have a problem with
# xlmbda=64/Re when Re->0
ustar2 = 8.*mu0*sqrt(uref2)/rho0/dh;}
else if (re<4000){
xlmbda = 0.021377 + 5.3115e-6*re;
ustar2 = uref2*xlmbda/8.;}
else {
xlmbda = 1/( 1.8*log(re)/log(10.)-1.64)^2;
ustar2 = uref2*xlmbda/8.;}
cmu = 0.09;
kappa = 0.42;
k = ustar2/sqrt(cmu);
eps = ustar2^1.5/(kappa*dh*0.1);
nu_tilda = eps/(cmu * k);"""
req = [('nu_tilda', "nu_tilda")]
sym = [('x','cell center coordinate'),
('y','cell center coordinate'),
('z','cell center coordinate'),
('t','time'),
('dt','time step'),
('iter','number of time step')]
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("slotFormulaTurb -> %s" % str(result))
self.__boundary.setTurbFormula(str(result))
self.pushButtonTurb.setStyleSheet("background-color: green")
self.pushButtonTurb.setToolTip(result)
def tr(self, text):
"""
Translation
"""
return text
class BoundaryConditionsMobileMeshView(QWidget,
Ui_BoundaryConditionsMobileMeshForm):
"""
Boundary condifition for mobil mesh (ALE and/or Fluid-interaction)
"""
def __init__(self, parent):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_BoundaryConditionsMobileMeshForm.__init__(self)
self.setupUi(self)
def setup(self, case):
"""
Setup the widget
"""
self.__case = case
self.__boundary = None
self.__case.undoStopGlobal()
self.__model = MobileMeshModel(self.__case)
self.notebook = NotebookModel(self.__case)
self.__comboModel = ComboModel(self.comboMobilBoundary, 6, 1)
self.__comboModel.addItem(self.tr("Fixed boundary"), "fixed_boundary")
self.__comboModel.addItem(self.tr("Sliding boundary"),
"sliding_boundary")
self.__comboModel.addItem(self.tr("Internal coupling"),
"internal_coupling")
self.__comboModel.addItem(self.tr("External coupling"),
"external_coupling")
self.__comboModel.addItem(self.tr("Fixed velocity"), "fixed_velocity")
self.__comboModel.addItem(self.tr("Fixed displacement"),
"fixed_displacement")
self.comboMobilBoundary.activated[str].connect(self.__slotCombo)
self.pushButtonMobilBoundary.clicked.connect(self.__slotFormula)
self.__case.undoStartGlobal()
@pyqtSlot()
def __slotFormula(self):
"""
Run formula editor.
"""
exp = self.__boundary.getFormula()
aleChoice = self.__boundary.getALEChoice()
if aleChoice == "fixed_velocity":
if not exp:
exp = 'mesh_velocity_U ='
req = [('mesh_velocity_U', 'Fixed velocity of the mesh'),
('mesh_velocity_V', 'Fixed velocity of the mesh'),
('mesh_velocity_W', 'Fixed velocity of the mesh')]
exa = 'mesh_velocity_U = 1000;\nmesh_velocity_V = 1000;\nmesh_velocity_W = 1000;'
elif aleChoice == "fixed_displacement":
if not exp:
exp = 'mesh_x ='
req = [('mesh_x', 'Fixed displacement of the mesh'),
('mesh_y', 'Fixed displacement of the mesh'),
('mesh_z', 'Fixed displacement of the mesh')]
exa = 'mesh_x = 1000;\nmesh_y = 1000;\nmesh_z = 1000;'
symbs = [('dt', 'time step'), ('t', 'current time'),
('iter', 'number of iteration')]
for (nme, val) in self.notebook.getNotebookList():
symbs.append((nme, 'value (notebook) = ' + str(val)))
dialog = QMeiEditorView(
self,
check_syntax=self.__case['package'].get_check_syntax(),
expression=exp,
required=req,
symbols=symbs,
examples=exa)
if dialog.exec_():
result = dialog.get_result()
log.debug("slotFormulaMobileMeshBoundary -> %s" % str(result))
self.__boundary.setFormula(str(result))
self.pushButtonMobilBoundary.setStyleSheet(
"background-color: green")
self.pushButtonMobilBoundary.setToolTip(result)
@pyqtSlot(str)
def __slotCombo(self, text):
"""
Called when the combobox changed.
"""
modelData = self.__comboModel.dicoV2M[str(text)]
if modelData == self.__boundary.getALEChoice():
return
self.__boundary.setALEChoice(modelData)
exp = self.__boundary.getFormula()
# Hide/Show formula button.
# Formula is always reset when changing values, so set
# color to red.
if modelData in ["fixed_velocity", "fixed_displacement"]:
self.pushButtonMobilBoundary.show()
else:
self.pushButtonMobilBoundary.hide()
if exp:
self.pushButtonMobilBoundary.setStyleSheet("background-color: red")
self.pushButtonMobilBoundary.setToolTip(exp)
else:
self.pushButtonMobilBoundary.setStyleSheet("background-color: red")
def showWidget(self, b):
"""
Show the widget
"""
if self.__model.getMethod() != "off":
self.__boundary = Boundary("mobile_boundary", b.getLabel(),
self.__case)
modelData = self.__boundary.getALEChoice()
self.__comboModel.setItem(str_model=modelData)
if modelData in ["fixed_velocity", "fixed_displacement"]:
self.pushButtonMobilBoundary.show()
else:
self.pushButtonMobilBoundary.hide()
self.show()
else:
self.hideWidget()
def hideWidget(self):
"""
Hide all
"""
self.hide()
def tr(self, text):
"""
Translation
"""
return text
class BoundaryConditionsHydraulicHeadView(
QWidget, Ui_BoundaryConditionsHydraulicHeadForm):
def __init__(self, parent):
"""
Constructor
"""
QWidget.__init__(self, parent)
Ui_BoundaryConditionsHydraulicHeadForm.__init__(self)
self.setupUi(self)
def setup(self, case):
"""
Setup the widget
"""
self.__case = case
self.__boundary = None
self.notebook = NotebookModel(self.__case)
self.__case.undoStopGlobal()
# Validators
validatorHh = DoubleValidator(self.lineEditValueHydraulicHead)
validatorExHh = DoubleValidator(self.lineEditExHydraulicHead)
# Apply validators
self.lineEditValueHydraulicHead.setValidator(validatorHh)
self.lineEditExHydraulicHead.setValidator(validatorHh)
self.modelTypeHydraulic = ComboModel(self.comboBoxTypeHydraulicHead, 1,
1)
self.modelTypeHydraulic.addItem(self.tr("Prescribed value"),
'dirichlet')
self.modelTypeHydraulic.addItem(
self.tr("Prescribed value (user law)"), 'dirichlet_formula')
self.modelTypeHydraulic.addItem(self.tr("Prescribed flux"), 'neumann')
# Connections
self.lineEditValueHydraulicHead.textChanged[str].connect(
self.slotHydraulicHeadValue)
self.lineEditExHydraulicHead.textChanged[str].connect(
self.slotHydraulicHeadFlux)
self.pushButtonHydraulicHead.clicked.connect(
self.slotHydraulicHeadFormula)
self.comboBoxTypeHydraulicHead.activated[str].connect(
self.slotHydraulicHeadChoice)
self.__case.undoStartGlobal()
def showWidget(self, boundary):
"""
Show the widget
"""
label = boundary.getLabel()
self.nature = boundary.getNature()
self.__boundary = Boundary(self.nature, label, self.__case)
self.initialize()
def initialize(self):
self.labelValueHydraulicHead.hide()
self.labelExHydraulicHead.hide()
self.lineEditValueHydraulicHead.hide()
self.lineEditExHydraulicHead.hide()
self.pushButtonHydraulicHead.setEnabled(False)
self.pushButtonHydraulicHead.setStyleSheet("background-color: None")
HydraulicChoice = self.__boundary.getHydraulicHeadChoice()
self.modelTypeHydraulic.setItem(str_model=HydraulicChoice)
if HydraulicChoice == 'dirichlet':
self.labelValueHydraulicHead.show()
self.lineEditValueHydraulicHead.show()
h_head = self.__boundary.getHydraulicHeadValue()
self.lineEditValueHydraulicHead.setText(str(h_head))
elif HydraulicChoice == 'neumann':
self.labelExHydraulicHead.show()
self.lineEditExHydraulicHead.show()
h_head = self.__boundary.getHydraulicHeadFlux()
self.lineEditExHydraulicHead.setText(str(h_head))
elif HydraulicChoice == 'dirichlet_formula':
self.pushButtonHydraulicHead.setEnabled(True)
exp = self.__boundary.getHydraulicHeadFormula()
if exp:
self.pushButtonHydraulicHead.setStyleSheet(
"background-color: green")
self.pushButtonHydraulicHead.setToolTip(exp)
else:
self.pushButtonHydraulicHead.setStyleSheet(
"background-color: red")
self.show()
def hideWidget(self):
"""
Hide all
"""
self.hide()
@pyqtSlot(str)
def slotHydraulicHeadValue(self, text):
"""
INPUT hydraulic head value
"""
if self.lineEditValueHydraulicHead.validator(
).state == QValidator.Acceptable:
t = from_qvariant(text, float)
self.__boundary.setHydraulicHeadValue(t)
@pyqtSlot(str)
def slotHydraulicHeadFlux(self, text):
"""
INPUT hydraulic head flux
"""
if self.lineEditExHydraulicHead.validator(
).state == QValidator.Acceptable:
t = from_qvariant(text, float)
self.__boundary.setHydraulicHeadFlux(t)
@pyqtSlot()
def slotHydraulicHeadFormula(self):
"""
"""
exp = self.__boundary.getHydraulicHeadFormula()
exa = """#example: """
req = [("H", "hydraulic head")]
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("slotHydraulicHeadFormula -> %s" % str(result))
self.__boundary.setHydraulicHeadFormula(str(result))
self.pushButtonHydraulicHead.setStyleSheet(
"background-color: green")
self.pushButtonHydraulicHead.setToolTip(result)
@pyqtSlot(str)
def slotHydraulicHeadChoice(self, text):
"""
INPUT label for choice of zone
"""
HydraulicChoice = self.modelTypeHydraulic.dicoV2M[str(text)]
self.__boundary.setHydraulicHeadChoice(HydraulicChoice)
self.initialize()
def tr(self, text):
"""
Translation
"""
return text
