def slotTemperatureFormula(self):
"""
Input the initial Temperature formula
"""
exp = self.init.getTemperatureFormula(self.zone)
if not exp:
exp = """temperature = 0;\n"""
exa = """#example: """
req = [('temperature', 'temperature')]
sym = [('x', 'cell center coordinate'),
('y', 'cell center coordinate'),
('z', 'cell center coordinate')]
dialog = QMeiEditorView(
self,
check_syntax=self.case['package'].get_check_syntax(),
expression=exp,
required=req,
symbols=sym,
examples=exa)
if dialog.exec_():
result = dialog.get_result()
log.debug("slotTemperatureFormula -> %s" % str(result))
self.init.setTemperatureFormula(self.zone, str(result))
self.pushButtonTemperature.setStyleSheet("background-color: green")
self.pushButtonTemperature.setToolTip(result)
def slotSpeciesFormula(self):
"""
Input the initial formula of species
"""
exp = self.init.getSpeciesFormula(self.zone, self.scalar)
name = self.th_sca.getScalarName(self.scalar)
if not exp:
exp = str(name) + """ = 0;\n"""
exa = """#example: \n""" + str(name) + """ = 0;\n"""
req = [(str(name), str(name))]
sym = [('x', 'cell center coordinate'),
('y', 'cell center coordinate'),
('z', 'cell center coordinate')]
dialog = QMeiEditorView(
self,
check_syntax=self.case['package'].get_check_syntax(),
expression=exp,
required=req,
symbols=sym,
examples=exa)
if dialog.exec_():
result = dialog.get_result()
log.debug("slotFormulaSpecies -> %s" % str(result))
self.init.setSpeciesFormula(self.zone, self.scalar, str(result))
self.pushButtonSpecies.setStyleSheet("background-color: green")
self.pushButtonSpecies.setToolTip(result)
def slotPotVectorFormula(self):
"""
"""
exp = self.__b.getElecScalarFormula(self.potVect, self.potVec_type)
exa = """#example: """
if not exp:
exp = self.potVect + " = 0;"
req = [(self.potVect, 'vector potential')]
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')]
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 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 slotEnergyFormula(self):
"""
Input the initial Energy formula
"""
exp = self.init.getEnergyFormula(self.zone)
if not exp:
exp = """total_energy = 0;\n"""
exa = """#example: """
req = [('total_energy', 'Energy')]
sym = [('x', 'cell center coordinate'),
('y', 'cell center coordinate'),
('z', 'cell center coordinate')]
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("slotEnergyFormula -> %s" % str(result))
self.init.setEnergyFormula(self.zone, str(result))
self.pushButtonEnergy.setStyleSheet("background-color: green")
self.pushButtonEnergy.setToolTip(result)
def slotThermalFormula(self):
"""
Input the initial formula of thermal scalar
"""
exp = self.init.getThermalFormula(self.zone)
if not exp:
exp = self.init.getDefaultThermalFormula()
exa = """#example \n""" + self.init.getDefaultThermalFormula()
if self.therm.getThermalScalarModel() == "enthalpy":
req = [('enthalpy', 'enthalpy')]
elif self.therm.getThermalScalarModel() == "total_energy":
req = [('total_energy', 'total energy')]
else:
req = [('temperature', 'temperature')]
sym = [('x', 'cell center coordinate'),
('y', 'cell center coordinate'),
('z', 'cell center coordinate')]
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("slotFormulaThermal -> %s" % str(result))
self.init.setThermalFormula(self.zone, str(result))
self.pushButtonThermal.setStyleSheet("background-color: green")
self.pushButtonThermal.setToolTip(result)
def slotMeteoFormula(self):
"""
"""
exp = self.init.getMeteoFormula(self.zone, self.scalar_meteo)
name = self.scalar_meteo
if not exp:
exp = str(name)+""" = 0;\n"""
exa = """#example: \n""" + str(name)+""" = 0;\n"""
req = [(str(name), str(name))]
sym = [('x', 'cell center coordinate'),
('y', 'cell center coordinate'),
('z', 'cell center coordinate')]
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("slotFormulaMeteo -> %s" % str(result))
self.init.setMeteoFormula(self.zone, self.scalar_meteo, str(result))
self.pushButtonMeteo.setStyleSheet("background-color: green")
self.pushButtonMeteo.setToolTip(result)
def slotFormulaDiff(self):
"""
User formula for the diffusion coefficient
"""
label, namesca, local = self.modelGroundwaterLaw.getItem(self.entriesNumber)
name = self.m_sca.getScalarDiffusivityName(self.scalar)
exp = self.mdl.getDiffFormula(self.scalar, namesca)
delay_name = str(self.scalar) + "_delay"
req = [(str(name), str(self.scalar) + ' molecular diffusion (dm)'),
(delay_name, str(self.scalar)+ ' delay (R)')]
exa = ''
sym = [('x', 'cell center coordinate'),
('y', 'cell center coordinate'),
('z', 'cell center coordinate'),
('saturation', 'saturation')]
sym.append((str(self.scalar),str(self.scalar)))
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("slotFormulaDiff -> %s" % str(result))
self.mdl.setDiffFormula(self.scalar, namesca, str(result))
self.pushButtonDiff.setStyleSheet("background-color: green")
self.pushButtonDiff.setToolTip(result)
def slotVelocityFormula(self):
"""
"""
exp = self.init.getVelocityFormula(self.zone)
if not exp:
exp = self.init.getDefaultVelocityFormula()
exa = """#example: \n""" + self.init.getDefaultVelocityFormula()
req = [('velocity[0]', "velocity"),
('velocity[1]', "velocity"),
('velocity[2]', "velocity")]
sym = [('uref', 'reference velocity'),
('x', 'cell center coordinate'),
('y', 'cell center coordinate'),
('z', 'cell center coordinate')]
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.init.setVelocityFormula(self.zone, str(result))
self.pushButtonVelocity.setStyleSheet("background-color: green")
self.pushButtonVelocity.setToolTip(result)
def __slotVelocityFormula(self):
"""
"""
exp = self.__boundary.getVelocity()
c = self.__boundary.getVelocityChoice()
if c == 'norm_formula':
exa = "u_norm = 1.0;"
req = [('u_norm', 'Norm of the velocity')]
elif c == 'flow1_formula':
exa = "q_m = 1.0;"
req = [('q_m', 'mass flow rate')]
elif c == 'flow2_formula':
exa = "q_v = 1.0;"
req = [('q_v', 'volumic flow rate')]
sym = [('x', "X face's gravity center"),
('y', "Y face's gravity center"),
('z', "Z face's gravity center"), ('dt', 'time step'),
('t', 'current time'), ('iter', 'number of iteration')]
dialog = QMeiEditorView(
self,
check_syntax=self.__case['package'].get_check_syntax(),
expression=exp,
required=req,
symbols=sym,
examples=exa)
if dialog.exec_():
result = dialog.get_result()
log.debug("slotFormulaVelocity -> %s" % str(result))
self.__boundary.setVelocity(str(result))
self.pushButtonVelocityFormula.setStyleSheet(
"background-color: green")
self.pushButtonVelocityFormula.setToolTip(result)
def slotThermalFormula(self):
"""
Input the initial formula of thermal scalar
"""
exp = self.mdl.getThermalFormula(self.zone, self.th_sca_name)
if not exp:
exp = self.mdl.getDefaultThermalFormula(self.th_sca_name)
exa = """#example: """
req = [('S', 'thermal source term'),
('dS', 'thermal source term derivative')]
sym = [('x', 'cell center coordinate'),
('y', 'cell center coordinate'),
('z', 'cell center coordinate')]
if self.therm.getThermalScalarModel() == 'enthalpy':
sym.append(('enthalpy', 'thermal scalar'))
if self.therm.getThermalScalarModel() == 'total_energy':
sym.append(('total_energy', 'thermal scalar'))
else:
sym.append(('temperature', 'thermal scalar'))
dialog = QMeiEditorView(self,
check_syntax = self.case['package'].get_check_syntax(),
expression = exp,
required = req,
symbols = sym,
examples = exa)
if dialog.exec_():
result = dialog.get_result()
log.debug("slotFormulaThermal -> %s" % str(result))
self.mdl.setThermalFormula(self.zone, self.th_sca_name, str(result))
self.pushButtonThermal.setToolTip(result)
self.pushButtonThermal.setStyleSheet("background-color: green")
def slotSpeciesFormula(self):
"""
"""
exp = self.mdl.getSpeciesFormula(self.zone, self.scalar)
if not exp:
exp = """S = 0;\ndS = 0;\n"""
exa = """#example: """
req = [('S', 'species source term'),
('dS', 'species source term derivative')]
sym = [('x', 'cell center coordinate'),
('y', 'cell center coordinate'),
('z', 'cell center coordinate')]
name = self.th_sca.getScalarName(self.scalar)
sym.append((name, 'current species'))
dialog = QMeiEditorView(self,
check_syntax = self.case['package'].get_check_syntax(),
expression = exp,
required = req,
symbols = sym,
examples = exa)
if dialog.exec_():
result = dialog.get_result()
log.debug("slotFormulaSpecies -> %s" % str(result))
self.mdl.setSpeciesFormula(self.zone, self.scalar, str(result))
self.pushButtonSpecies.setToolTip(result)
self.pushButtonSpecies.setStyleSheet("background-color: green")
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')]
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)
def slotFraction(self):
"""
Formula for fraction
"""
exp = self.mdl.getFormula(self.zone, self.currentid, 'volume_fraction')
if not exp:
if self.currentid == "1":
exp = "vol_f = 1.;\n"
else:
exp = "vol_f = 0.;\n"
req = [('vol_f', 'volume fraction')]
sym = [('x', "X cell's gravity center"),
('y', "Y cell's gravity center"),
('z', "Z cell's gravity center")]
exa = "vol_f = 1.0;\n"
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("slotFormulaRho -> %s" % str(result))
self.mdl.setFormula(self.zone, self.currentid, 'volume_fraction',
result)
self.pushButtonFraction.setStyleSheet("background-color: green")
self.pushButtonFraction.setToolTip(result)
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')]
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)
def slotRichardsFormula(self):
"""
"""
exp = self.mdl.getRichardsFormula(self.zone)
if not exp:
exp = """Qs = 0;\n"""
exa = """#example: """
req = [('Qs', 'volumetric source term')]
sym = [('x', 'cell center coordinate'),
('y', 'cell center coordinate'),
('z', 'cell center coordinate'), ('t', 'current time')]
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("slotRichardsFormula -> %s" % str(result))
self.mdl.setRichardsFormula(self.zone, str(result))
self.pushButtonRichards.setToolTip(result)
self.pushButtonRichards.setStyleSheet("background-color: green")
def slotMomentumFormula(self):
"""
Set momentumFormula of the source term
"""
exa = """#example:\n
tau = 10.; # relaxation time (s)\n
vel_x_imp = 1.5; #target velocity (m/s)\n
Su = rho * (vel_x_imp - velocity[0]) / tau;\n
dSudu = - rho / tau; # Jacobian of the source term"""
exp, req, sym = self.mdl.getMomentumFormulaComponents(self.zone)
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.mdl.setMomentumFormula(self.zone, str(result))
self.pushButtonMomentum.setToolTip(result)
self.pushButtonMomentum.setStyleSheet("background-color: green")
def slotSpeciesGroundWaterFormula(self):
"""
"""
exp = self.mdl.getGroundWaterSpeciesFormula(self.zone, self.scalar)
if not exp:
exp = """Q = 0;"""
exa = """#example: """
req = [('Q', 'species source term')]
sym = [('x', 'cell center coordinate'),
('y', 'cell center coordinate'),
('z', 'cell center coordinate'), ('t', 'current time')]
name = self.th_sca.getScalarName(self.scalar)
sym.append((name, 'current species'))
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("slotSpeciesGroundWaterFormula -> %s" % str(result))
self.mdl.setGroundWaterSpeciesFormula(self.zone, self.scalar,
str(result))
self.pushButtonSpecies2.setToolTip(result)
self.pushButtonSpecies2.setStyleSheet("background-color: green")
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)
def slotFormula(self):
"""
"""
exp = self.mdl.getFormula(self.label_select)
exa = """#example: a line segment between (x0, y0, z0) and (x1, y1, z1)
#(s, the parameter is always between 0 and 1)
x0 = 3.2;
x1 = 2;
y0 = 2;
y1 = 2;
z0 = 5;
z1 = -0.5;
x = x1*s + x0*(1.-s);
y = y1*s + y0*(1.-s);
z = z1*s + z0*(1.-s);"""
req = [('x', "x formula"), ('y', "y formula"), ('z', "z formula")]
sym = [('s', 'parameter')]
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("slotLineFormula -> %s" % str(result))
self.mdl.setFormula(self.label_select, str(result))
self.pushButtonFormula.setToolTip(result)
self.pushButtonFormula.setStyleSheet("background-color: green")
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")
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 slotScalar(self):
"""
Formula for species
"""
exp = self.mdl.getFormulaScalar(self.zone, self.currentid,
self.currentScalar)
if not exp:
exp = self.currentScalarLabel + """ = 0;\n"""
req = [(self.currentScalarLabel, str(self.currentScalarLabel))]
sym = [('x', "X cell's gravity center"),
('y', "Y cell's gravity center"),
('z', "Z cell's gravity center")]
exa = """#example: """
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("slotFormulaRho -> %s" % str(result))
self.mdl.setFormulaScalar(self.zone, self.currentid,
self.currentScalar, result)
self.pushButtonScalar.setStyleSheet("background-color: green")
self.pushButtonScalar.setToolTip(result)
def slotPressure(self):
"""
Formula for pressure
"""
exp = self.mdl.getFormulaPressure(self.zone)
if not exp:
exp = """pressure = 101325.;\n"""
req = [("pressure", str("pressure"))]
sym = [('x', "X cell's gravity center"),
('y', "Y cell's gravity center"),
('z', "Z cell's gravity center")]
exa = """#example :
rho0 = 1.8;
zmax = 1.2;
Po = 1.e6;
pressure = P0 + rho0 * g * (zmax - z);"""
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("slotFormulaRho -> %s" % str(result))
self.mdl.setFormulaPressure(self.zone, result)
self.pushButtonPressure.setStyleSheet("background-color: green")
self.pushButtonPressure.setToolTip(result)
def slotVelocity(self):
"""
Formula for velocity
"""
exp = self.mdl.getFormula(self.zone, self.currentid, 'velocity')
if not exp:
exp = "u = 0.;\nv = 0.;\nw = 0.;"
req = [('u', 'Velocity along X'), ('v', 'Velocity along Y'),
('w', 'Velocity along Z')]
sym = [('x', "X cell's gravity center"),
('y', "Y cell's gravity center"),
('z', "Z cell's gravity center")]
exa = "u = 3.0;\nv = 1.0;\nw = 0.0;\n"
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("slotFormulaRho -> %s" % str(result))
self.mdl.setFormula(self.zone, self.currentid, 'velocity', result)
self.pushButtonVelocity.setStyleSheet("background-color: green")
self.pushButtonVelocity.setToolTip(result)
def slotTurbulenceFormula(self):
"""
INPUT user formula
"""
turb_model = self.turb.getTurbulenceModel()
exa = """#example \n""" + self.init.getDefaultTurbFormula(turb_model)
exp = self.init.getTurbFormula(self.zone, turb_model)
sym = [('rho0', 'density (reference value)'),
('mu0', 'viscosity (reference value)'),
('cp0', 'specific heat (reference value)'),
('lambda0', 'thermal conductivity (reference value)'),
('x', 'cell center coordinate'),
('y', 'cell center coordinate'),
('z', 'cell center coordinate'), ('uref', 'reference velocity'),
('almax', 'reference length')]
if turb_model in ('k-epsilon', 'k-epsilon-PL'):
req = [('k', "turbulent energy"),
('epsilon', "turbulent dissipation")]
elif turb_model in ('Rij-epsilon', 'Rij-SSG'):
req = [('r11', "Reynolds stress R11"),
('r22', "Reynolds stress R22"),
('r33', "Reynolds stress R33"),
('r12', "Reynolds stress R12"),
('r23', "Reynolds stress R23"),
('r13', "Reynolds stress R13"),
('epsilon', "turbulent dissipation")]
elif turb_model == 'Rij-EBRSM':
req = [('r11', "Reynolds stress R11"),
('r22', "Reynolds stress R22"),
('r33', "Reynolds stress R33"),
('r12', "Reynolds stress R12"),
('r23', "Reynolds stress R23"),
('r13', "Reynolds stress R13"),
('epsilon', "turbulent dissipation"), ('alpha', "alpha")]
elif turb_model == 'v2f-BL-v2/k':
req = [('k', "turbulent energy"),
('epsilon', "turbulent dissipation"),
('phi', "variable phi in v2f model"),
('alpha', "variable alpha in v2f model")]
elif turb_model == 'k-omega-SST':
req = [('k', "turbulent energy"),
('omega', "specific dissipation rate")]
elif turb_model == 'Spalart-Allmaras':
req = [('nu_tilda', "nusa")]
dialog = QMeiEditorView(
self,
check_syntax=self.case['package'].get_check_syntax(),
expression=exp,
required=req,
symbols=sym,
examples=exa)
if dialog.exec_():
result = dialog.get_result()
log.debug("slotFormulaTurb -> %s" % str(result))
self.init.setTurbFormula(self.zone, str(result))
self.pushButtonTurbulence.setStyleSheet("background-color: green")
self.pushButtonTurbulence.setToolTip(result)
def slotMomentumFormula(self):
"""
Set momentumFormula of the source term
"""
exp = self.mdl.getMomentumFormula(self.zone)
if not exp:
exp = """Su = 0;\nSv = 0;\nSw = 0;\n
dSudu = 0;\ndSudv = 0;\ndSudw = 0;\n
dSvdu = 0;\ndSvdv = 0;\ndSvdw = 0;\n
dSwdu = 0;\ndSwdv = 0;\ndSwdw = 0;\n"""
exa = """#example:\n
tau = 10.; # relaxation time (s)\n
vel_x_imp = 1.5; #target velocity (m/s)\n
Su = rho * (vel_x_imp - velocity[0]) / tau;\n
dSudu = - rho / tau; # Jacobian of the source term"""
req = [('Su', "x component of the momentum source term"),
('Sv', "y component of the momentum source term"),
('Sw', "z component of the momentum source term"),
('dSudu', "x component x velocity derivative"),
('dSudv', "x component y velocity derivative"),
('dSudw', "x component z velocity derivative"),
('dSvdu', "y component x velocity derivative"),
('dSvdv', "y component y velocity derivative"),
('dSvdw', "y component z velocity derivative"),
('dSwdu', "z component x velocity derivative"),
('dSwdv', "z component y velocity derivative"),
('dSwdw', "z component z velocity derivative")]
sym = [('x', 'cell center coordinate'),
('y', 'cell center coordinate'),
('z', 'cell center coordinate')]
sym.append(("velocity[0]", 'x velocity component'))
sym.append(("velocity[1]", 'y velocity component'))
sym.append(("velocity[2]", 'z velocity component'))
sym.append(("rho", 'local density (kg/m^3)'))
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.mdl.setMomentumFormula(self.zone, str(result))
self.pushButtonMomentum.setToolTip(result)
self.pushButtonMomentum.setStyleSheet("background-color: green")
def slotFormulaPorosity(self):
"""
User formula for density
"""
label, name, local = self.modelPorosity.getItem(self.entriesNumber)
exp = self.mdl.getPorosityFormula(name)
choice = self.mdl.getPorosityModel(name)
if exp == None:
exp = self.getDefaultPorosityFormula(choice)
if choice == "isotropic":
req = [('porosity', 'Porosity')]
else:
req = [('porosity', 'Porosity'),
('porosity[XX]', 'Porosity'),
('porosity[YY]', 'Porosity'),
('porosity[ZZ]', 'Porosity'),
('porosity[XY]', 'Porosity'),
('porosity[XZ]', 'Porosity'),
('porosity[YZ]', 'Porosity')]
exa = """#example: \n""" + self.mdl.getDefaultPorosityFormula(choice)
sym = [('x', 'cell center coordinate'),
('y', 'cell center coordinate'),
('z', 'cell center coordinate')]
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("slotFormulaPorosity -> %s" % str(result))
self.mdl.setPorosityFormula(name, str(result))
self.pushButtonPorosity.setToolTip(result)
self.pushButtonPorosity.setStyleSheet("background-color: green")
def slotVelocityFormula(self):
"""
"""
exa = """#example: \n""" + self.init.getDefaultVelocityFormula()
exp, req, sym = self.init.getVelocityFormulaComponents(self.zone)
dialog = QMeiEditorView(self,
check_syntax = self.case['package'].get_check_syntax(),
expression = exp,
required = req,
symbols = sym,
examples = exa)
if dialog.exec_():
result = dialog.get_result()
log.debug("slotFormulaVelocity -> %s" % str(result))
self.init.setVelocityFormula(self.zone, str(result))
self.pushButtonVelocity.setStyleSheet("background-color: green")
self.pushButtonVelocity.setToolTip(result)
def slotMomentumFormula(self):
"""
Set momentumFormula of the source term
"""
exp = self.mdl.getMomentumFormula(self.zone)
if not exp:
exp = """Su = 0;\nSv = 0;\nSw = 0;\n
dSudu = 0;\ndSudv = 0;\ndSudw = 0;\n
dSvdu = 0;\ndSvdv = 0;\ndSvdw = 0;\n
dSwdu = 0;\ndSwdv = 0;\ndSwdw = 0;\n"""
exa = """#example: """
req = [('Su', "x velocity"),
('Sv', "y velocity"),
('Sw', "z velocity"),
('dSudu', "x component x velocity derivative"),
('dSudv', "x component y velocity derivative"),
('dSudw', "x component z velocity derivative"),
('dSvdu', "y component x velocity derivative"),
('dSvdv', "y component y velocity derivative"),
('dSvdw', "y component z velocity derivative"),
('dSwdu', "z component x velocity derivative"),
('dSwdv', "z component y velocity derivative"),
('dSwdw', "z component z velocity derivative")]
sym = [('x', 'cell center coordinate'),
('y', 'cell center coordinate'),
('z', 'cell center coordinate')]
sym.append( ("velocity[0]", 'X velocity component'))
sym.append( ("velocity[1]", 'Y velocity component'))
sym.append( ("velocity[2]", 'Z velocity component'))
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.mdl.setMomentumFormula(self.zone, str(result))
self.pushButtonMomentum.setToolTip(result)
self.pushButtonMomentum.setStyleSheet("background-color: green")