def setProcAndRef(self):
procTunit = self.mainView.comboBox_procTunit.currentText()
procPunit = self.mainView.comboBox_procPunit.currentText()
refTunit = self.mainView.comboBox_refTunit.currentText()
refPunit = self.mainView.comboBox_refPunit.currentText()
try:
T = conv_unit(
float(self.mainView.le_procT.text()), procTunit, "K"
) # convert to Kelvin
P = conv_unit(
float(self.mainView.le_procP.text()), procPunit, "Pa"
) # convert to pascal
Tref = conv_unit(
float(self.mainView.le_refT.text()), refTunit, "K"
) # convert to Kelvin
Pref = conv_unit(
float(self.mainView.le_refP.text()), refPunit, "Pa"
) # convert to pascal
self.model.setPref(Pref)
self.model.setTref(Tref)
self.model.setT(T)
self.model.setP(P)
except:
# TODO
print("error process variables")
msg = QtWidgets.QMessageBox.about(
self.mainView, "Error", "Invalid values for T and/or P"
)
raise ValueError("Invalid T and/or P numbers")
def isothermalBinaryMixturePlot(self,
T,
x=None,
Punit="Pa",
Tunit="K",
expfilename="",
plottype="both"):
assert self.n == 2
if x is None:
x = x_vec_for_plot
x, y, P, phiv, phil, kvec = self.isothermalBinaryMixtureGenData(
T, x, Punit=Punit, Tunit=Tunit)
if self.vle_method == "UNIFAC":
gamma_title = "UNIFAC + "
else:
gamma_title = ""
title = "{} (1) / {} (2) at {:0.3f} {}\n{}Equation of state: {}".format(
self.substances[0].Name,
self.substances[1].Name,
conv_unit(T, "K", Tunit),
Tunit,
gamma_title,
self.eosname,
)
vleplot = VLEBinaryDiagrams.VLEBinaryMixturePlot(
"isothermal", P, x, y, Punit, title, plottype)
if os.path.exists(expfilename):
vleplot.expPlot(expfilename)
vleplot.plot()
def isothermalBinaryMixtureGenData(self, T, x=None, Punit="Pa", Tunit="K"):
assert self.n == 2
if x is None:
x = [
0,
0.01,
0.02,
0.03,
0.04,
0.06,
0.08,
0.1,
0.15,
0.2,
0.25,
0.3,
0.35,
0.4,
0.45,
0.5,
0.55,
0.6,
0.65,
0.7,
0.75,
0.8,
0.85,
0.9,
0.92,
0.94,
0.96,
0.97,
0.98,
0.99,
1,
]
x = np.atleast_1d(x)
xmix = np.empty(2, dtype=np.float64)
y = np.empty(len(x), dtype=np.float64)
P = np.empty(len(x), dtype=np.float64)
for i in range(len(x)):
xmix[0] = x[i]
xmix[1] = 1.0 - x[i]
yres, P[i], pv, pl, k, ite = self.getBubblePointPressure(xmix,
T,
tol=1e-5,
kmax=100)
P[i] = conv_unit(P[i], "Pa", Punit)
y[i] = yres[0]
return x, y, P
def isobaricBinaryMixtureGenData(self, P, x=None, Punit="Pa", Tunit="K"):
assert self.n == 2
if x is None:
x = [
0,
0.01,
0.02,
0.03,
0.04,
0.06,
0.08,
0.1,
0.15,
0.2,
0.25,
0.3,
0.35,
0.4,
0.45,
0.5,
0.55,
0.6,
0.65,
0.7,
0.75,
0.8,
0.85,
0.9,
0.92,
0.94,
0.96,
0.97,
0.98,
0.99,
1,
]
x = np.atleast_1d(x)
xmix = np.empty(2, dtype=np.float64)
y = np.empty(len(x), dtype=np.float64)
T = np.empty(len(x), dtype=np.float64)
for i in range(len(x)):
xmix[0] = x[i]
xmix[1] = 1.0 - x[i]
yres, T[i], pv, pl, k, ite = self.getBubblePointTemperature(
xmix, P)
T[i] = conv_unit(T[i], "K", Tunit)
y[i] = yres[0]
return x, y, T
def isothermalBinaryMixtureGenData(self, T, x=None, Punit="Pa", Tunit="K"):
assert self.n == 2
if x is None:
x = x_vec_for_plot
x = np.atleast_1d(x)
xmix = np.empty(2, dtype=np.float64)
y = np.empty(len(x), dtype=np.float64)
P = np.empty(len(x), dtype=np.float64)
kvec = np.empty(len(x), dtype=np.float64)
phi_vap_vec = np.empty(len(x), dtype=np.float64)
phi_liq_vec = np.empty(len(x), dtype=np.float64)
phi_vap = np.empty(len(x), dtype=np.float64)
phi_liq = np.empty(len(x), dtype=np.float64)
kv = np.empty(len(x), dtype=np.float64)
for i in range(len(x)):
xmix[0] = x[i]
xmix[1] = 1.0 - x[i]
try:
yres, P[
i], phi_vap, phi_liq, kv, ite = self.getBubblePointPressure(
xmix, T, tol=1e-5, kmax=100)
except:
try:
yres = [0, 0]
yres[0] = y[i - 1]
P[i] = P[i - 1]
x[i] = x[i - 1]
phi_vap[0] = phi_vap_vec[i - 1]
phi_liq[0] = phi_liq_vec[i - 1]
kv[0] = kvec[i - 1]
except:
yres = [0, 0]
yres[0] = y[i + 1]
P[i] = P[i + 1]
x[i] = x[i + 1]
phi_vap[0] = phi_vap_vec[i + 1]
phi_liq[0] = phi_liq_vec[i + 1]
kv[0] = kv[i + 1]
P[i] = conv_unit(P[i], "Pa", Punit)
y[i] = yres[0]
phi_vap_vec[i] = phi_vap[0]
phi_liq_vec[i] = phi_liq[0]
kvec[i] = kv[0]
return x, y, P, phi_vap_vec, phi_liq_vec, kvec
def plotPV(
self,
xunit: str,
yunit: str,
lnscale=True,
smooth=True,
grid=True,
plotisothermals=False,
):
self.x_letter, self.y_letter = "V", "P"
self.xliq, self.yliq = self.Vliq, self.Pliq
self.xvap, self.yvap = self.Vvap, self.Pvap
self.xcp, self.ycp = self.cpoint.V, self.cpoint.P
self.xunit, self.yunit = xunit, yunit
self.xliq = conv_unit(self.xliq, SI_dict[self.x_letter], self.xunit)
self.xvap = conv_unit(self.xvap, SI_dict[self.x_letter], self.xunit)
self.lnscale = lnscale
self.grid = grid
self.smooth = smooth
self.plotisotherms = plotisothermals
def isobaricBinaryMixtureGenData(self, P, x=None, Punit="Pa", Tunit="K"):
assert self.n == 2
if x is None:
x = x_vec_for_plot
x = np.atleast_1d(x)
xmix = np.empty(2, dtype=np.float64)
y = np.empty(len(x), dtype=np.float64)
T = np.empty(len(x), dtype=np.float64)
kvec = np.empty(len(x), dtype=np.float64)
phi_vap_vec = np.empty(len(x), dtype=np.float64)
phi_liq_vec = np.empty(len(x), dtype=np.float64)
pv = np.empty(len(x), dtype=np.float64)
pl = np.empty(len(x), dtype=np.float64)
k = np.empty(len(x), dtype=np.float64)
for i in range(len(x)):
xmix[0] = x[i]
xmix[1] = 1.0 - x[i]
try:
yres, T[i], pv, pl, k, ite = self.getBubblePointTemperature(
xmix, P)
except:
try:
yres = [0, 0]
yres[0] = y[i - 1]
T[i] = T[i - 1]
x[i] = x[i - 1]
pv[0] = phi_vap_vec[i - 1]
pl[0] = phi_liq_vec[i - 1]
k[0] = kvec[i - 1]
except:
yres = [0, 0]
yres[0] = y[i + 1]
T[i] = T[i + 1]
x[i] = x[i + 1]
pv[0] = phi_vap_vec[i + 1]
pl[0] = phi_liq_vec[i + 1]
k[0] = kvec[i + 1]
T[i] = conv_unit(T[i], "K", Tunit)
y[i] = yres[0]
phi_vap_vec[i] = pv[0]
phi_liq_vec[i] = pl[0]
kvec[i] = k[0]
return x, y, T, phi_vap_vec, phi_liq_vec, kvec
def expPlot(self, expfilename):
import os
type = self.plottype
if os.path.exists(expfilename):
import shlex
with open(expfilename, "r") as file:
try:
content = [
line.rstrip("\n") for line in file if line != "\n"
]
n_exp = len(content) - 1
var_exp = np.empty(n_exp, dtype=np.float64)
x_exp = np.empty(n_exp, dtype=np.float64)
y_exp = np.empty(n_exp, dtype=np.float64)
var_exp_unit = shlex.split(content[0])[0]
for i in range(n_exp):
ret3 = shlex.split(content[1 + i])
var_exp[i] = conv_unit(float(ret3[0]), var_exp_unit,
self.varunit)
x_exp[i] = float(ret3[1])
y_exp[i] = float(ret3[2])
except Exception as e:
raise ValueError("Error in experimental data\n" + str(e))
x_exp_var_label = "Exp. data"
y_exp_var_label = "Exp. data"
color = "k"
lw = 1.0
zorder = 1
fc = "none"
if type == "x":
self.ax.scatter(
x_exp,
var_exp,
label=x_exp_var_label,
color=color,
linewidths=lw,
zorder=zorder,
facecolors=fc,
edgecolors=color,
)
elif type == "y":
self.ax.scatter(
y_exp,
var_exp,
label=y_exp_var_label,
color=color,
linewidths=lw,
zorder=zorder,
facecolors=fc,
edgecolors=color,
)
else:
self.ax.scatter(
x_exp,
var_exp,
label=x_exp_var_label,
color=color,
linewidths=lw,
zorder=zorder,
facecolors=fc,
edgecolors=color,
)
self.ax.scatter(
y_exp,
var_exp,
color=color,
linewidths=lw,
zorder=zorder,
facecolors=fc,
edgecolors=color,
)
self.setLegends()
else:
raise ValueError("Invalid file")
def genDiagrams(self):
Tunit = self.diagramsView.comboBox_TrangeUnit.currentText()
try:
self.Ti = float(units.conv_unit(self.diagramsView.le_Ti.text(), Tunit, "K"))
self.Tf = float(units.conv_unit(self.diagramsView.le_Tf.text(), Tunit, "K"))
except Exception as e:
print(str(e))
QtWidgets.QMessageBox.about(
self.diagramsView, "Error", "T values are not valid numbers"
)
return -1
try:
self.points = float(self.diagramsView.le_points.text())
except:
QtWidgets.QMessageBox.about(
self.diagramsView, "Error", "Invalid number of points"
)
return -1
try:
if self.diagramsView.le_isotherms.text().strip() != "":
self.isotherms_range = [
float(i)
for i in self.diagramsView.le_isotherms.text()
.replace(",", " ")
.split()
]
else:
self.isotherms_range = []
except:
QtWidgets.QMessageBox.about(
self.diagramsView, "Error", "Invalid isotherms values"
)
return -1
from time import time
try:
s1 = time()
self.rl, self.rv, self.cp, isotherm_data = diagrams.gen_data(
self.model.system,
[self.Ti, self.Tf],
self.model.getPref(),
self.model.getTref(),
int(self.points),
isotherms=self.isotherms_range,
)
s2 = time()
QtWidgets.QMessageBox.information(
self.diagramsView,
"Data generated",
"Computation time: {:.3f} sec".format(s2 - s1),
)
self.diag = diagrams.PlotPureSubstanceDiagrams(
self.rl,
self.rv,
self.cp,
self.model.getSubstanceName(),
self.model.getEOS(),
isotherms=isotherm_data,
)
except Exception as e:
QtWidgets.QMessageBox.about(
self.diagramsView, "Error generating data", str(e)
)
return
self.data_is_gen = True
def _plot(self):
if not self._isGenDataVarValid():
title = "Variable not valid"
msg = "Variable is not a valid number"
QtWidgets.QMessageBox.about(self, title, msg)
return -1
gendata_header = ["{} [{}]", "x1", "y1"]
try:
# self.VLEeq = VLE(self.subsInSystem, self.eosname, self.k)
self.VLEeq = createEOSMix(self.subsInSystem, self.eosname, self.k)
if self.diagtype == diagram_types[0]: # isothermal
_v = conv_unit(
float(self.le_varValue.text()),
self.comboBox_varUnit.currentText(),
"K",
)
x, y, var = self.VLEeq.isothermalBinaryMixtureGenData(
_v,
Tunit=self.comboBox_varUnit.currentText(),
Punit=self.comboBox_Punit.currentText(),
)
gendata_header[0] = "{} [{}]".format(
"P", self.comboBox_Punit.currentText()
)
else:
_v = conv_unit(
float(self.le_varValue.text()),
self.comboBox_varUnit.currentText(),
"Pa",
)
x, y, var = self.VLEeq.isobaricBinaryMixtureGenData(
_v,
Tunit=self.comboBox_Tunit.currentText(),
Punit=self.comboBox_varUnit.currentText(),
)
gendata_header[0] = "{} [{}]".format(
"T", self.comboBox_Tunit.currentText()
)
except Exception as e:
title = "Error generating data to plot"
msg = str(e)
QtWidgets.QMessageBox.about(self, title, msg)
return -1
# populate table
n = len(x)
self.tableWidget_DataResult.setRowCount(n)
self.tableWidget_DataResult.setColumnCount(3)
self.tableWidget_DataResult.setHorizontalHeaderLabels(gendata_header)
for i in range(n):
item_var = QtWidgets.QTableWidgetItem("{:3.5e}".format(var[i]))
item_x = QtWidgets.QTableWidgetItem("{:0.5f}".format(x[i]))
item_y = QtWidgets.QTableWidgetItem("{:0.5f}".format(y[i]))
self.tableWidget_DataResult.setItem(i, 0, item_var)
self.tableWidget_DataResult.setItem(i, 1, item_x)
self.tableWidget_DataResult.setItem(i, 2, item_y)
if self.checkBox_plotExpData.isChecked():
expfilename = self.expfilename
else:
expfilename = ""
if self.checkBox_plotx.isChecked():
plottype = "x"
elif self.checkBox_ploty.isChecked():
plottype = "y"
else:
plottype = "both"
try:
if self.diagtype == diagram_types[0]: # isothermal
self.VLEeq.isothermalBinaryMixturePlot(
_v,
Tunit=self.comboBox_varUnit.currentText(),
Punit=self.comboBox_Punit.currentText(),
expfilename=expfilename,
plottype=plottype,
)
else:
self.VLEeq.isobaricBinaryMixturePlot(
_v,
Tunit=self.comboBox_Tunit.currentText(),
Punit=self.comboBox_varUnit.currentText(),
expfilename=expfilename,
plottype=plottype,
)
except Exception as e:
title = "Error plotting"
msg = str(e)
QtWidgets.QMessageBox.about(self, title, msg)
return -1
def calculateClicked(self):
eosname = self.vleView.comboBox_EOS.currentText()
self.model.setEOS(eosname)
# check if P and T are numbers
if not self._PandTareValidNumbers():
title = "P and T error"
msg = "P and/or T are not valid numbers"
QtWidgets.QMessageBox.about(self.vleView, title, msg)
return -1
# get molar fractions values
if not self._areMolarFractonsValidNumbers():
title = "Molar fraction error"
msg = "Molar fraction have one or more invalid numbers"
QtWidgets.QMessageBox.about(self.vleView, title, msg)
return -1
p = conv_unit(
float(self.vleView.le_Pvalue.text()),
self.vleView.comboBox_Punit.currentText(),
"Pa",
)
t = conv_unit(
float(self.vleView.le_Tvalue.text()),
self.vleView.comboBox_Tunit.currentText(),
"K",
)
n = self.model.getNumberOfSubstancesInSystem()
z = np.empty(n, dtype=np.float64)
rn = 2
for i in range(n):
z[i] = float(
self.vleView.tableWidget_MolarFractions.item(i, rn).text())
if self.calctype == "bubbleP":
y, p, pv, pl, k, ite = self.model.system.getBubblePointPressure(
z, t)
p = conv_unit(p, "Pa", self.vleView.comboBox_Punit.currentText())
self.vleView.le_scalarAnswer.setText("{:.5e}".format(p))
# col_headers = ["Name", "Formula", "y", "Phivap", "Philiq", "K"]
for i in range(n):
sy = QtWidgets.QTableWidgetItem("{:.5f}".format(y[i]))
spv = QtWidgets.QTableWidgetItem("{:.5f}".format(pv[i]))
spl = QtWidgets.QTableWidgetItem("{:.5f}".format(pl[i]))
sk = QtWidgets.QTableWidgetItem("{:.5f}".format(k[i]))
self.vleView.tableWidget_Results.setItem(i, 2, sy)
self.vleView.tableWidget_Results.setItem(i, 3, spv)
self.vleView.tableWidget_Results.setItem(i, 4, spl)
self.vleView.tableWidget_Results.setItem(i, 5, sk)
elif self.calctype == "dewP":
x, p, pv, pl, k, ite = self.model.system.getDewPointPressure(z, t)
p = conv_unit(p, "Pa", self.vleView.comboBox_Punit.currentText())
self.vleView.le_scalarAnswer.setText("{:.5e}".format(p))
# col_headers = ["Name", "Formula", "y", "Phivap", "Philiq", "K"]
for i in range(n):
sy = QtWidgets.QTableWidgetItem("{:.5f}".format(x[i]))
spv = QtWidgets.QTableWidgetItem("{:.5f}".format(pv[i]))
spl = QtWidgets.QTableWidgetItem("{:.5f}".format(pl[i]))
sk = QtWidgets.QTableWidgetItem("{:.5f}".format(k[i]))
self.vleView.tableWidget_Results.setItem(i, 2, sy)
self.vleView.tableWidget_Results.setItem(i, 3, spv)
self.vleView.tableWidget_Results.setItem(i, 4, spl)
self.vleView.tableWidget_Results.setItem(i, 5, sk)
elif self.calctype == "bubbleT":
y, t, pv, pl, k, ite = self.model.system.getBubblePointTemperature(
z, p)
t = conv_unit(t, "K", self.vleView.comboBox_Tunit.currentText())
self.vleView.le_scalarAnswer.setText("{:.5e}".format(t))
# col_headers = ["Name", "Formula", "y", "Phivap", "Philiq", "K"]
for i in range(n):
sy = QtWidgets.QTableWidgetItem("{:.5f}".format(y[i]))
spv = QtWidgets.QTableWidgetItem("{:.5f}".format(pv[i]))
spl = QtWidgets.QTableWidgetItem("{:.5f}".format(pl[i]))
sk = QtWidgets.QTableWidgetItem("{:.5f}".format(k[i]))
self.vleView.tableWidget_Results.setItem(i, 2, sy)
self.vleView.tableWidget_Results.setItem(i, 3, spv)
self.vleView.tableWidget_Results.setItem(i, 4, spl)
self.vleView.tableWidget_Results.setItem(i, 5, sk)
elif self.calctype == "dewT":
x, t, pv, pl, k, ite = self.model.system.getDewPointTemperature(
z, p)
t = conv_unit(t, "K", self.vleView.comboBox_Tunit.currentText())
self.vleView.le_scalarAnswer.setText("{:.5e}".format(t))
# col_headers = ["Name", "Formula", "y", "Phivap", "Philiq", "K"]
for i in range(n):
sy = QtWidgets.QTableWidgetItem("{:.5f}".format(x[i]))
spv = QtWidgets.QTableWidgetItem("{:.5f}".format(pv[i]))
spl = QtWidgets.QTableWidgetItem("{:.5f}".format(pl[i]))
sk = QtWidgets.QTableWidgetItem("{:.5f}".format(k[i]))
self.vleView.tableWidget_Results.setItem(i, 2, sy)
self.vleView.tableWidget_Results.setItem(i, 3, spv)
self.vleView.tableWidget_Results.setItem(i, 4, spl)
self.vleView.tableWidget_Results.setItem(i, 5, sk)
else:
try:
x, y, v, pv, pl, k, ite = self.model.system.getFlash(z, p, t)
except Exception as e:
title = "Error calculating flash"
msg = str(e)
QtWidgets.QMessageBox.about(self.vleView, title, msg)
return -1
self.vleView.le_scalarAnswer.setText("{:.7f}".format(v))
col_headers = [
"Name", "Formula", "x", "y", "Phivap", "Philiq", "K"
]
for i in range(n):
sx = QtWidgets.QTableWidgetItem("{:.5f}".format(x[i]))
sy = QtWidgets.QTableWidgetItem("{:.5f}".format(y[i]))
spv = QtWidgets.QTableWidgetItem("{:.5f}".format(pv[i]))
spl = QtWidgets.QTableWidgetItem("{:.5f}".format(pl[i]))
sk = QtWidgets.QTableWidgetItem("{:.5f}".format(k[i]))
self.vleView.tableWidget_Results.setItem(i, 2, sx)
self.vleView.tableWidget_Results.setItem(i, 3, sy)
self.vleView.tableWidget_Results.setItem(i, 4, spv)
self.vleView.tableWidget_Results.setItem(i, 5, spl)
self.vleView.tableWidget_Results.setItem(i, 6, sk)
tn = self.vleView.tableWidget_Results.columnCount()
h_header = self.vleView.tableWidget_Results.horizontalHeader()
for i in range(tn - 2):
# h_header.setSectionResizeMode(i+2, QtWidgets.QHeaderView.Stretch)
h_header.setSectionResizeMode(
i + 2, QtWidgets.QHeaderView.ResizeToContents)
def batch_flite(batch_file):
# v4.2 subtle bug processing home directory ... I was writing a / at
# the tail of * ArgBuf [2] -- Possibly on top of sombody else's data
# space ! Adding a work buffer for doing the deed.
if not batch_file:
print("\nno batch file!")
return
try:
with open(batch_file, "r") as fp:
rasp_bat = RocketBat()
stage = rasp_bat.stages[0]
for num, line in enumerate(fp.readlines(), start=1):
# break up line and filter comments
args = []
for arg in line.split():
if arg.startswith('#'):
break
args.append(arg)
if args:
if args[0].lower() not in MNEMONICS:
print('bad line:', line)
continue
if len(MNEMONICS[args[0].lower()]) < 4:
print('short line:', args)
continue
dfu, cmd, typ, measure = MNEMONICS[args[0].lower()]
itmp, dtmp, stmp = 0, 0.0, ""
if cmd == "TITLE":
if len(args) > 1:
rasp_bat.title = re.split(r'\s+',
line.strip(),
maxsplit=1)[1]
continue
elif cmd == "LAUNCH":
to_da_moon_alice(rasp_bat)
continue
elif cmd == "QUIT":
return
elif cmd == "DUMP":
rasp_bat.dump()
break
elif typ == "DOUBLE":
if len(args) > 2:
src_unit = args[2]
else:
src_unit = dfu
# convert the units to SI
dtmp = units.conv_unit(measure, float(args[1]),
src_unit)
elif typ == "INTEGER":
if len(args) > 1:
itmp = int(args[1])
else:
itmp = 0
else:
if len(args) > 1:
stmp = args[1]
else:
stmp = None
if cmd == "UNITS":
rasp_bat.units = stmp
elif cmd == "HOME":
if stmp[-1] != os.sep:
rasp_bat.home = stmp + os.sep
else:
rasp_bat.home = stmp
elif cmd == "MODE":
if len(args) > 1:
if args[1].lower() in ('quiet', 'summa'):
rasp_bat.mode = 0
elif args[1].lower() in ('verbose', ):
rasp_bat.mode = 1
elif args[1].lower() in ('debug', ):
rasp_bat.mode = 2
elif cmd == "QUIET":
rasp_bat.mode = 0
elif cmd == "VERBOSE":
rasp_bat.mode = 1
elif cmd == "DEBUG":
rasp_bat.mode = 2
elif cmd == "SITEPRESS":
rasp_bat.sitepress = dtmp
elif cmd == "SITETEMP":
rasp_bat.sitetemp = dtmp
elif cmd == "SITEALT":
rasp_bat.sitealt = dtmp
elif cmd == "FINALALT":
rasp_bat.finalalt = dtmp
elif cmd == "COASTTIME":
rasp_bat.coasttime = dtmp
elif cmd == "RAILLENGTH":
rasp_bat.raillength = dtmp
elif cmd == "DESTINATION":
rasp_bat.destination = stmp
elif cmd == "OUTFILE":
rasp_bat.outfile = stmp
elif cmd == "THETA":
rasp_bat.theta = dtmp
elif cmd == "NUMSTAGES":
rasp_bat.set_stages(itmp)
elif cmd == "NOSETYPE":
rasp_bat.nosetype = stmp
elif cmd == "STAGE":
if itmp > 0:
rasp_bat.set_stages(itmp)
stage = rasp_bat.stages[itmp - 1]
elif cmd == "STAGEDELAY":
stage.stagedelay = dtmp
elif cmd == "DIAMETER":
stage.diameter = dtmp
elif cmd == "NUMFINS":
stage.numfins = itmp
elif cmd == "FINTHICKNESS":
stage.finthickness = dtmp
elif cmd == "FINSPAN":
stage.finspan = dtmp
elif cmd == "DRYMASS":
stage.drymass = dtmp
elif cmd == "LAUNCHMASS":
stage.launchmass = dtmp
elif cmd == "CD":
stage.cd = dtmp
elif cmd == "ENGINEFILE":
stage.enginefile = stmp
elif cmd == "MOTORNAME":
stage.motorname = stmp
elif cmd == "NUMMOTOR":
stage.nummotor = itmp
else:
print("unknown cmd: ", cmd)
rasp_bat.dump()
rasp_bat.export()
except OSError as e:
print(e.strerror, e.filename)
def conv_unit(self, unit):
return units.conv_unit(float(self.inp), self.unit, unit)
def _plot(self):
self.title = "{}: {}\n{}".format(
self.compound,
"{} vs {}".format(labels_dict[self.y_letter],
labels_dict[self.x_letter]),
self.eosname,
)
self.xlabel = "{} [{}]".format(labels_dict[self.x_letter], self.xunit)
self.ylabel = "{} [{}]".format(labels_dict[self.y_letter], self.yunit)
try:
self.xliq = conv_unit(self.xliq, SI_dict[self.x_letter],
self.xunit)
self.xvap = conv_unit(self.xvap, SI_dict[self.x_letter],
self.xunit)
self.yliq = conv_unit(self.yliq, SI_dict[self.y_letter],
self.yunit)
self.yvap = conv_unit(self.yvap, SI_dict[self.y_letter],
self.yunit)
self.xcp = conv_unit(self.xcp, SI_dict[self.x_letter], self.xunit)
self.ycp = conv_unit(self.ycp, SI_dict[self.y_letter], self.yunit)
except Exception as e:
print("Error converting units in diagram\n{}".format(str(e)))
raise
if self.lnscale:
try:
self.xliq, self.xvap = np.log(self.xliq), np.log(self.xvap)
self.yliq, self.yvap = np.log(self.yliq), np.log(self.yvap)
self.xcp, self.ycp = np.log(self.xcp), np.log(self.ycp)
self.xlabel = "ln " + self.xlabel
self.ylabel = "ln " + self.ylabel
except Exception as e:
print("Error changing to log scale")
print(str(e))
raise
if self.smooth:
try:
n = 100
tliq = interpolate.splrep(np.sort(self.xliq),
self.yliq[self.xliq.argsort()])
self.xliq = np.linspace(np.min(self.xliq), np.max(self.xliq),
n)
self.yliq = interpolate.splev(self.xliq, tliq)
tvap = interpolate.splrep(np.sort(self.xvap),
self.yvap[self.xvap.argsort()])
self.xvap = np.linspace(np.min(self.xvap), np.max(self.xvap),
n)
self.yvap = interpolate.splev(self.xvap, tvap)
except Exception as e:
print("Error calculating spline")
print(str(e))
raise
fig, ax = plt.subplots()
if self.grid:
ax.grid()
try:
ax.plot(self.xliq, self.yliq, label="Liquid")
ax.plot(self.xvap, self.yvap, label="Vapor")
except Exception as e:
print("Error plotting liquid and vapor lines\n{}".format(str(e)))
raise
try:
ax.plot(self.xcp, self.ycp, label="Critical point", marker="o")
except Exception as e:
print("Error plotting critical point\n{}".format(str(e)))
raise
try:
if self.plotisotherms and self.has_isotherms:
v = conv_unit(np.atleast_1d(self.isotherms.V),
SI_dict[self.x_letter], self.xunit)
if self.lnscale:
v = np.log(v)
for i in range(len(self.isotherms.T)):
t = self.isotherms.T[i]
p = conv_unit(
np.atleast_1d(self.isotherms.P[i]),
SI_dict[self.y_letter],
self.yunit,
)
if self.lnscale:
p = np.log(p)
label = "isothermal at {:.3f} K".format(t)
ax.plot(v, p, label=label, linestyle="--")
except Exception as e:
print("Error plotting isothermal data\n{}".format(str(e)))
raise
ax.set_xlabel(self.xlabel)
ax.set_ylabel(self.ylabel)
ax.set_title(self.title)
ax.legend()
plt.show()
return
def updateCalculations(self):
self.plainTextEdit_information.clear()
self.tableWidget_results.setRowCount(0)
self.plainTextEdit_log.clear()
self.sname = self.model.getSubstanceName()
self.sformula = self.model.getSubstanceFormula()
self.eosname = self.model.getEOS()
self.T = self.model.getT()
self.Tref = self.model.getTref()
self.P = self.model.getP()
self.Pref = self.model.getPref()
self.info = ""
self.info += "Compound: {:s} ({:s})\n".format(self.sname,
self.sformula)
self.info += "Equation of state: {0:s}\n".format(self.eosname)
self.info += "Process state: {0:.3f} {1:s}, {2:s} {3:s}\n".format(
conv_unit(self.T, "K", self.units["T"]),
self.units["T"],
utils.f2str(conv_unit(self.P, "Pa", self.units["P"]),
3,
lt=1e-2,
gt=1e4),
self.units["P"],
)
self.info += "Reference state: {0:.3f} {1:s}, {2:s} {3:s}\n".format(
conv_unit(self.Tref, "K", self.units["T"]),
self.units["T"],
utils.f2str(conv_unit(self.Pref, "Pa", self.units["P"]),
3,
lt=1e-2,
gt=1e4),
self.units["P"],
)
self.info += "State: {0:s}".format(self.model.getFluidState())
self.plainTextEdit_information.appendPlainText(self.info)
self.propsliq = self.model.getPropsLiq()
self.propsvap = self.model.getPropsVap()
try:
self.rowlabels, self.liq, self.vap = reports.tablewidget_vap_liq_reports(
self.propsliq,
self.propsvap,
self.model.getPvp(),
state=self.model.getFluidStateFlag(),
isMixture=False,
**self.units)
for i in range(len(self.rowlabels)):
self.tableWidget_results.insertRow(i)
liqitem = QtWidgets.QTableWidgetItem(self.liq[i])
vapitem = QtWidgets.QTableWidgetItem(self.vap[i])
liqitem.setTextAlignment(QtCore.Qt.AlignRight)
vapitem.setTextAlignment(QtCore.Qt.AlignRight)
self.tableWidget_results.setItem(i, 0, liqitem)
self.tableWidget_results.setItem(i, 1, vapitem)
self.tableWidget_results.setVerticalHeaderLabels(self.rowlabels)
except Exception as e:
msg = QtWidgets.QMessageBox.about(self, "Error showing results",
str(e))
return 1
try:
self.log = self.model.getLog()
self.plainTextEdit_log.appendPlainText(self.log)
except Exception as e:
print("Couldn't generate report")
print(str(e))
def isothermalBinaryMixturePlot(self,
T,
x=None,
Punit="Pa",
Tunit="K",
expfilename="",
plottype="both"):
assert self.n == 2
if x is None:
x = [
0,
0.01,
0.02,
0.03,
0.04,
0.06,
0.08,
0.1,
0.15,
0.2,
0.25,
0.3,
0.35,
0.4,
0.45,
0.5,
0.55,
0.6,
0.65,
0.7,
0.75,
0.8,
0.85,
0.9,
0.92,
0.94,
0.96,
0.97,
0.98,
0.99,
1,
]
x, y, P = self.isothermalBinaryMixtureGenData(T,
x,
Punit=Punit,
Tunit=Tunit)
title = "{} (1) / {} (2) at {:0.3f} {}\nEquation of state: {}".format(
self.mix[0].Name,
self.mix[1].Name,
conv_unit(T, "K", Tunit),
Tunit,
self.eos,
)
vleplot = VLEBinaryDiagrams.VLEBinaryMixturePlot(
"isothermal", P, x, y, Punit, title, plottype)
if os.path.exists(expfilename):
vleplot.expPlot(expfilename)
vleplot.plot()
def plot(self):
if not self._isGenDataVarValid():
title = "Variable not valid"
msg = "Variable is not a valid number"
QtWidgets.QMessageBox.about(self.vleView, title, msg)
return -1
# gendata_header = ["{} [{}]", "x1", "y1"]
gendata_header = ["{} [{}]", "x1", "y1", "K", "Phi_liq", "Phi_vap"]
try:
diagtype = self.vleView.comboBox_diagramType.currentText()
if diagtype == diagram_types[0]: # isothermal
_v = conv_unit(
float(self.vleView.le_varValue.text()),
self.vleView.comboBox_varUnit.currentText(),
"K",
)
x, y, var, phiv, phil, kvec = self.model.system.isothermalBinaryMixtureGenData(
_v,
Tunit=self.vleView.comboBox_varUnit.currentText(),
Punit=self.vleView.comboBox_Punit.currentText(),
)
gendata_header[0] = "{} [{}]".format(
"P", self.vleView.comboBox_Punit.currentText())
else:
_v = conv_unit(
float(self.vleView.le_varValue.text()),
self.vleView.comboBox_varUnit.currentText(),
"Pa",
)
x, y, var, phiv, phil, kvec = self.model.system.isobaricBinaryMixtureGenData(
_v,
Tunit=self.vleView.comboBox_Tunit.currentText(),
Punit=self.vleView.comboBox_varUnit.currentText(),
)
gendata_header[0] = "{} [{}]".format(
"T", self.vleView.comboBox_Tunit.currentText())
except Exception as e:
title = "Error generating data to plot"
msg = str(e)
QtWidgets.QMessageBox.about(self.vleView, title, msg)
return -1
# populate table
n = len(x)
self.vleView.tableWidget_DataResult.setRowCount(n)
self.vleView.tableWidget_DataResult.setColumnCount(6)
self.vleView.tableWidget_DataResult.setHorizontalHeaderLabels(
gendata_header)
for i in range(n):
item_var = QtWidgets.QTableWidgetItem("{:3.5e}".format(var[i]))
item_x = QtWidgets.QTableWidgetItem("{:0.5f}".format(x[i]))
item_y = QtWidgets.QTableWidgetItem("{:0.5f}".format(y[i]))
item_kvec = QtWidgets.QTableWidgetItem("{:0.5f}".format(kvec[i]))
item_philiq = QtWidgets.QTableWidgetItem("{:0.5f}".format(phil[i]))
item_phivap = QtWidgets.QTableWidgetItem("{:0.5f}".format(phiv[i]))
self.vleView.tableWidget_DataResult.setItem(i, 0, item_var)
self.vleView.tableWidget_DataResult.setItem(i, 1, item_x)
self.vleView.tableWidget_DataResult.setItem(i, 2, item_y)
self.vleView.tableWidget_DataResult.setItem(i, 3, item_kvec)
self.vleView.tableWidget_DataResult.setItem(i, 4, item_philiq)
self.vleView.tableWidget_DataResult.setItem(i, 5, item_phivap)
if self.vleView.checkBox_plotExpData.isChecked():
expfilename = self.vleView.le_expDataFileName.text()
else:
expfilename = ""
if self.vleView.checkBox_plotx.isChecked():
plottype = "x"
elif self.vleView.checkBox_ploty.isChecked():
plottype = "y"
else:
plottype = "both"
try:
if diagtype == diagram_types[0]: # isothermal
self.model.system.isothermalBinaryMixturePlot(
_v,
Tunit=self.vleView.comboBox_varUnit.currentText(),
Punit=self.vleView.comboBox_Punit.currentText(),
expfilename=expfilename,
plottype=plottype,
)
else:
self.model.system.isobaricBinaryMixturePlot(
_v,
Tunit=self.vleView.comboBox_Tunit.currentText(),
Punit=self.vleView.comboBox_varUnit.currentText(),
expfilename=expfilename,
plottype=plottype,
)
except Exception as e:
title = "Error plotting"
msg = str(e)
QtWidgets.QMessageBox.about(self.vleView, title, msg)
return -1
def calculate(self):
# self.VLEeq = VLE(self.subsInSystem, self.eosname, self.k)
self.VLEeq = createEOSMix(self.subsInSystem, self.eosname, self.k)
# check if P and T are numbers
if not self._PandTareValidNumbers():
title = "P and T error"
msg = "P and/or T are not valid numbers"
QtWidgets.QMessageBox.about(self, title, msg)
return -1
# get molar fractions values
if not self._areMolarFractonsValidNumbers():
title = "Molar fraction error"
msg = "Molar fraction have one or more invalid numbers"
QtWidgets.QMessageBox.about(self, title, msg)
return -1
p = conv_unit(
float(self.le_Pvalue.text()), self.comboBox_Punit.currentText(), "Pa"
)
t = conv_unit(
float(self.le_Tvalue.text()), self.comboBox_Tunit.currentText(), "K"
)
z = np.empty(self.n, dtype=np.float64)
rn = 2
for i in range(self.n):
z[i] = float(self.tableWidget_MolarFractions.item(i, rn).text())
if self.calctype == "bubbleP":
y, p, pv, pl, k, ite = self.VLEeq.getBubblePointPressure(z, t)
p = conv_unit(p, "Pa", self.comboBox_Punit.currentText())
self.le_scalarAnswer.setText("{:.5e}".format(p))
# col_headers = ["Name", "Formula", "y", "Phivap", "Philiq", "K"]
for i in range(self.n):
sy = QtWidgets.QTableWidgetItem("{:.5f}".format(y[i]))
spv = QtWidgets.QTableWidgetItem("{:.5f}".format(pv[i]))
spl = QtWidgets.QTableWidgetItem("{:.5f}".format(pl[i]))
sk = QtWidgets.QTableWidgetItem("{:.5f}".format(k[i]))
self.tableWidget_Results.setItem(i, 2, sy)
self.tableWidget_Results.setItem(i, 3, spv)
self.tableWidget_Results.setItem(i, 4, spl)
self.tableWidget_Results.setItem(i, 5, sk)
elif self.calctype == "dewP":
x, p, pv, pl, k, ite = self.VLEeq.getDewPointPressure(z, t)
p = conv_unit(p, "Pa", self.comboBox_Punit.currentText())
self.le_scalarAnswer.setText("{:.5e}".format(p))
# col_headers = ["Name", "Formula", "y", "Phivap", "Philiq", "K"]
for i in range(self.n):
sy = QtWidgets.QTableWidgetItem("{:.5f}".format(x[i]))
spv = QtWidgets.QTableWidgetItem("{:.5f}".format(pv[i]))
spl = QtWidgets.QTableWidgetItem("{:.5f}".format(pl[i]))
sk = QtWidgets.QTableWidgetItem("{:.5f}".format(k[i]))
self.tableWidget_Results.setItem(i, 2, sy)
self.tableWidget_Results.setItem(i, 3, spv)
self.tableWidget_Results.setItem(i, 4, spl)
self.tableWidget_Results.setItem(i, 5, sk)
elif self.calctype == "bubbleT":
y, t, pv, pl, k, ite = self.VLEeq.getBubblePointTemperature(z, p)
t = conv_unit(t, "K", self.comboBox_Tunit.currentText())
self.le_scalarAnswer.setText("{:.5e}".format(t))
# col_headers = ["Name", "Formula", "y", "Phivap", "Philiq", "K"]
for i in range(self.n):
sy = QtWidgets.QTableWidgetItem("{:.5f}".format(y[i]))
spv = QtWidgets.QTableWidgetItem("{:.5f}".format(pv[i]))
spl = QtWidgets.QTableWidgetItem("{:.5f}".format(pl[i]))
sk = QtWidgets.QTableWidgetItem("{:.5f}".format(k[i]))
self.tableWidget_Results.setItem(i, 2, sy)
self.tableWidget_Results.setItem(i, 3, spv)
self.tableWidget_Results.setItem(i, 4, spl)
self.tableWidget_Results.setItem(i, 5, sk)
elif self.calctype == "dewT":
x, t, pv, pl, k, ite = self.VLEeq.getDewPointTemperature(z, p)
t = conv_unit(t, "K", self.comboBox_Tunit.currentText())
self.le_scalarAnswer.setText("{:.5e}".format(t))
# col_headers = ["Name", "Formula", "y", "Phivap", "Philiq", "K"]
for i in range(self.n):
sy = QtWidgets.QTableWidgetItem("{:.5f}".format(x[i]))
spv = QtWidgets.QTableWidgetItem("{:.5f}".format(pv[i]))
spl = QtWidgets.QTableWidgetItem("{:.5f}".format(pl[i]))
sk = QtWidgets.QTableWidgetItem("{:.5f}".format(k[i]))
self.tableWidget_Results.setItem(i, 2, sy)
self.tableWidget_Results.setItem(i, 3, spv)
self.tableWidget_Results.setItem(i, 4, spl)
self.tableWidget_Results.setItem(i, 5, sk)
else:
try:
x, y, v, pv, pl, k, ite = self.VLEeq.getFlash(z, p, t)
except Exception as e:
title = "Error calculating flash"
msg = str(e)
QtWidgets.QMessageBox.about(self, title, msg)
return -1
self.le_scalarAnswer.setText("{:.7f}".format(v))
col_headers = ["Name", "Formula", "x", "y", "Phivap", "Philiq", "K"]
for i in range(self.n):
sx = QtWidgets.QTableWidgetItem("{:.5f}".format(x[i]))
sy = QtWidgets.QTableWidgetItem("{:.5f}".format(y[i]))
spv = QtWidgets.QTableWidgetItem("{:.5f}".format(pv[i]))
spl = QtWidgets.QTableWidgetItem("{:.5f}".format(pl[i]))
sk = QtWidgets.QTableWidgetItem("{:.5f}".format(k[i]))
self.tableWidget_Results.setItem(i, 2, sx)
self.tableWidget_Results.setItem(i, 3, sy)
self.tableWidget_Results.setItem(i, 4, spv)
self.tableWidget_Results.setItem(i, 5, spl)
self.tableWidget_Results.setItem(i, 6, sk)
def fitKijClicked(self):
expfilename = self.vleView.le_expDataFileName.text()
if expfilename == "":
QtWidgets.QMessageBox.about(self.vleView, "Error",
"No experimental data")
return
import shlex
with open(expfilename, "r") as file:
try:
content = [line.rstrip("\n") for line in file if line != "\n"]
n_exp = len(content) - 1
var_exp = np.empty(n_exp, dtype=np.float64)
x_exp = np.empty(n_exp, dtype=np.float64)
y_exp = np.empty(n_exp, dtype=np.float64)
var_exp_unit = shlex.split(content[0])[0]
if var_exp_unit in pressure_options:
diagtype = "isothermal"
varunit = "Pa"
elif var_exp_unit in temperature_options:
diagtype = "isobaric"
varunit = "K"
else:
raise ValueError(
"Diagram type neither 'isothermal' or 'isobaric'")
for i in range(n_exp):
ret3 = shlex.split(content[1 + i])
var_exp[i] = conv_unit(float(ret3[0]), var_exp_unit,
varunit)
x_exp[i] = float(ret3[1])
y_exp[i] = float(ret3[2])
except Exception as e:
raise ValueError("Error in experimental data\n" + str(e))
if diagtype == "isothermal":
conv_isovar_to = "K"
else:
conv_isovar_to = "Pa"
isovar = conv_unit(
float(self.vleView.le_varValue.text()),
self.vleView.comboBox_varUnit.currentText(),
conv_isovar_to,
)
from Models.FitExpDataToBinaryParameterModel import (
FitExpDataToBinaryParameterModel, )
original_k = self.model.getBinaryInteractionsParameters()
fitExpModel = FitExpDataToBinaryParameterModel(self.model, isovar,
diagtype, x_exp, y_exp,
var_exp)
# WARNING! This method overrides "k" matrix in the model.
kval = fitExpModel.fitBinaryInteractionParameter()
self.model.setBinaryInteractionsParameters(original_k)
self.editBinIntController.createBinInteractionView()
# self.editBinIntController.binInteractionView.tableWidget_BinaryParameters.setItem(
# 0, 1, QtWidgets.QTableWidgetItem(str(kval))
# )
self.editBinIntController.binInteractionView.tableWidget_BinaryParameters.cellWidget(
0, 1).setText("{:.7f}".format(kval))
self.editBinIntController.setSymmetricClicked()
def calculatePropsClicked(self):
# validate system
if self.model.getNumberOfSubstancesInSystem() < 2:
QMessageBox.about(
self.mixtureCalcView,
"No mixture",
"Please, select two or more substances",
)
return
try:
y = self.getMolarFractionsFromTable(
self.mixtureCalcView.tableWidget_MixtureSystem, 2)
except:
QMessageBox.about(self.mixtureCalcView, "Error",
"Invalid molar fraction numbers")
return -1
if np.abs(np.sum(y) - 1.0) > 1e-10:
QMessageBox.about(
self.mixtureCalcView,
"Invalid molar fractions",
"Molar fractions doesn't sum up to one",
)
return
try:
procTunit = self.mixtureCalcView.comboBox_procTunit.currentText()
procPunit = self.mixtureCalcView.comboBox_procPunit.currentText()
refTunit = self.mixtureCalcView.comboBox_refTunit.currentText()
refPunit = self.mixtureCalcView.comboBox_refPunit.currentText()
T = conv_unit(float(self.mixtureCalcView.le_procT.text()),
procTunit, "K") # convert to Kelvin
P = conv_unit(float(self.mixtureCalcView.le_procP.text()),
procPunit, "Pa") # convert to pascal
Tref = conv_unit(float(self.mixtureCalcView.le_refT.text()),
refTunit, "K") # convert to Kelvin
Pref = conv_unit(float(self.mixtureCalcView.le_refP.text()),
refPunit, "Pa") # convert to pascal
self.model.setProc(P, T)
self.model.setRef(Pref, Tref)
except:
print("error process variables")
msg = QtWidgets.QMessageBox.about(
self.mixtureCalcView, "Error",
"Process variables are not numbers")
return 1
try:
eosname = self.mixtureCalcView.listWidget_eos_options.currentItem(
).text()
self.model.setMolarFractions(y)
self.model.setEOS(eosname)
except Exception as e:
raise ValueError("Error in model setup\n", str(e))
self.mixtureCalcView.plainTextEdit_information.clear()
self.mixtureCalcView.tableWidget_results.setRowCount(0)
self.mixtureCalcView.plainTextEdit_log.clear()
try:
# self.eoseq = EOS(self.mix, self.k, self.eosname)
self.info = ""
tab = " "
self.info += "Mixture:\n"
for i in range(self.model.getNumberOfSubstancesInSystem()):
n = self.model.getSubstancesInSystems()[i].Name
f = self.model.getSubstancesInSystems()[i].Formula
z = self.model.getMolarFractions()[i]
self.info += tab + "{:} ({:}) [{:0.4f}]\n".format(n, f, z)
self.info += "Equation of state: {0:s}\n".format(
self.model.getEOS())
self.info += "Process state: {0:.3f} {1:s}, {2:s} {3:s}\n".format(
conv_unit(self.model.getT(), "K", self.units["T"]),
self.units["T"],
utils.f2str(
conv_unit(self.model.getP(), "Pa", self.units["P"]),
3,
lt=1e-2,
gt=1e4,
),
self.units["P"],
)
self.info += "Reference state: {0:.3f} {1:s}, {2:s} {3:s}\n".format(
conv_unit(self.model.getTref(), "K", self.units["T"]),
self.units["T"],
utils.f2str(
conv_unit(self.model.getPref(), "Pa", self.units["P"]),
3,
lt=1e-2,
gt=1e4,
),
self.units["P"],
)
self.info += "State: {0:s}".format(self.model.getFluidState())
self.mixtureCalcView.plainTextEdit_information.appendPlainText(
self.info)
except Exception as e:
print(e)
err = "One or more of the following properties is not set: Tc, Pc, omega"
msg = QtWidgets.QMessageBox.about(self.mixtureCalcView,
"Properties error", str(err))
return 1
try:
self.model.calculations()
except Exception as e:
raise ValueError("Error calculating properties\n", str(e))
def tablewidget_vap_liq_reports(pliq: Props,
pvap: Props,
pvp: VaporPressure,
state: FluidState = FluidState.Unknown,
isMixture: bool = False,
**units):
"""
Generates a table-formatted calculations report.
Parameters
----------
pliq : Props
liquid properties to be reported
pvap : Props
vapor properties to be reported
pvp : VaporPressure
vapor pressure(s) to be reported
state : FluidState, enum
State of the fluid
isMixture : bool
True value if system is a mixture
units : kwarg
units in which the results will be reported
Returns
-------
labels : list of str
formatted properties labels
liq_values : list of str
formatted liquid properties
vap_values : list of str
formatted vapor properties
"""
labels = []
liq_values = []
vap_values = []
has_ig = True if pliq.IGProps != 0 else False
# defines delta string for state properties
delta_char = "delta"
# units
Tu = units["T"] if "T" in units else "K"
Vu = units["V"] if "V" in units else "m3/mol"
Pu = units["P"] if "P" in units else "Pa"
rhou = units["rho"] if "rho" in units else "kg/m3"
ene_per_molu = units[
"energy_per_mol"] if "energy_per_mol" in units else "J/mol"
ene_per_mol_tempu = (units["energy_per_mol_temp"]
if "energy_per_mol_temp" in units else "J/molK")
# Z, V and density
Zl = f2str(pliq.Z, 6, lt=1e-1)
Zv = f2str(pvap.Z, 6, lt=1e-1)
labels.append("Z")
liq_values.append(Zl)
vap_values.append(Zv)
Vs = "V [{0}]".format(Vu)
Vl = f2str(conv_unit(pliq.V, "m3/mol", Vu), 6, lt=1e-2, gt=1e4)
Vv = f2str(conv_unit(pvap.V, "m3/mol", Vu), 6, lt=1e-2, gt=1e4)
labels.append(Vs)
liq_values.append(Vl)
vap_values.append(Vv)
if pliq.rho and pvap.rho:
rhos = "Density [{0}]".format(rhou)
rhol = f2str(conv_unit(pliq.rho, "kg/m3", rhou), 6, lt=1e-2, gt=1e4)
rhov = f2str(conv_unit(pvap.rho, "kg/m3", rhou), 6, lt=1e-2, gt=1e4)
labels.append(rhos)
liq_values.append(rhol)
vap_values.append(rhov)
# Vapor pressure
if state not in (FluidState.Gas, FluidState.Supercritical):
if pvp.EOS:
Pvpeoss = "Vap. P (EOS) [{0}]".format(Pu)
Pvpeosl = f2str(conv_unit(pvp.EOS, "Pa", Pu), 6, lt=1e-2, gt=1e4)
labels.append(Pvpeoss)
liq_values.append(Pvpeosl)
vap_values.append(Pvpeosl)
if pvp.AW:
PvpAWs = "Vap. P (Ambrose-Walton) [{0}]".format(Pu)
PvpAWl = f2str(conv_unit(pvp.AW, "Pa", Pu), 6, lt=1e-2, gt=1e4)
labels.append(PvpAWs)
liq_values.append(PvpAWl)
vap_values.append(PvpAWl)
PvpLKs = "Vap. P (Lee-Kesler) [{0}]".format(Pu)
PvpLKl = f2str(conv_unit(pvp.LK, "Pa", Pu), 6, lt=1e-2, gt=1e4)
labels.append(PvpLKs)
liq_values.append(PvpLKl)
vap_values.append(PvpLKl)
#
if pvp.Antoine:
PvpAntoines = "Vap. P (Antoine) [{0}]".format(Pu)
PvpAntoinel = f2str(conv_unit(pvp.Antoine, "Pa", Pu),
6,
lt=1e-2,
gt=1e4)
labels.append(PvpAntoines)
liq_values.append(PvpAntoinel)
vap_values.append(PvpAntoinel)
# real properties (if any)
if has_ig:
# real properties
dHs = delta_char + "H [{0}]".format(ene_per_molu)
dHliq = f2str(conv_unit(pliq.Props.H, "J/mol", ene_per_molu),
6,
lt=1e-2,
gt=1e4)
dHvap = f2str(conv_unit(pvap.Props.H, "J/mol", ene_per_molu),
6,
lt=1e-2,
gt=1e4)
labels.append(dHs)
liq_values.append(dHliq)
vap_values.append(dHvap)
dSs = delta_char + "S [{0}]".format(ene_per_mol_tempu)
dSliq = f2str(conv_unit(pliq.Props.S, "J/molK", ene_per_mol_tempu),
6,
lt=1e-2,
gt=1e4)
dSvap = f2str(conv_unit(pvap.Props.S, "J/molK", ene_per_mol_tempu),
6,
lt=1e-2,
gt=1e4)
labels.append(dSs)
liq_values.append(dSliq)
vap_values.append(dSvap)
dGs = delta_char + "G [{0}]".format(ene_per_molu)
dGliq = f2str(conv_unit(pliq.Props.G, "J/mol", ene_per_molu),
6,
lt=1e-2,
gt=1e4)
dGvap = f2str(conv_unit(pvap.Props.G, "J/mol", ene_per_molu),
6,
lt=1e-2,
gt=1e4)
labels.append(dGs)
liq_values.append(dGliq)
vap_values.append(dGvap)
dUs = delta_char + "U [{0}]".format(ene_per_molu)
dUliq = f2str(conv_unit(pliq.Props.U, "J/mol", ene_per_molu),
6,
lt=1e-2,
gt=1e4)
dUvap = f2str(conv_unit(pvap.Props.U, "J/mol", ene_per_molu),
6,
lt=1e-2,
gt=1e4)
labels.append(dUs)
liq_values.append(dUliq)
vap_values.append(dUvap)
dAs = delta_char + "A [{0}]".format(ene_per_molu)
dAliq = f2str(conv_unit(pliq.Props.A, "J/mol", ene_per_molu),
6,
lt=1e-2,
gt=1e4)
dAvap = f2str(conv_unit(pvap.Props.A, "J/mol", ene_per_molu),
6,
lt=1e-2,
gt=1e4)
labels.append(dAs)
liq_values.append(dAliq)
vap_values.append(dAvap)
# fugacity
fs = "Fugacity [{0}]".format(Pu)
fliq = f2str(conv_unit(pliq.Fugacity, "Pa", Pu), 8, lt=1e-2, gt=1e4)
fvap = f2str(conv_unit(pvap.Fugacity, "Pa", Pu), 8, lt=1e-2, gt=1e4)
labels.append(fs)
liq_values.append(fliq)
vap_values.append(fvap)
# Ideal properties
# Cp
Cps = "Cp [{0}]".format(ene_per_mol_tempu)
Cpl = f2str(conv_unit(pliq.IGProps.Cp, "J/molK", ene_per_mol_tempu),
6,
lt=1e-2,
gt=1e4)
labels.append(Cps)
liq_values.append(Cpl)
vap_values.append(Cpl)
dHIGs = delta_char + "IG H [{0}]".format(ene_per_molu)
dHIG = f2str(conv_unit(pliq.IGProps.H, "J/mol", ene_per_molu),
6,
lt=1e-2,
gt=1e4)
labels.append(dHIGs)
liq_values.append(dHIG)
vap_values.append(dHIG)
dSIGs = delta_char + "IG S [{0}]".format(ene_per_mol_tempu)
dSIG = f2str(conv_unit(pliq.IGProps.S, "J/molK", ene_per_mol_tempu),
6,
lt=1e-2,
gt=1e4)
labels.append(dSIGs)
liq_values.append(dSIG)
vap_values.append(dSIG)
dGIGs = delta_char + "IG G [{0}]".format(ene_per_molu)
dGIG = f2str(conv_unit(pliq.IGProps.G, "J/mol", ene_per_molu),
6,
lt=1e-2,
gt=1e4)
labels.append(dGIGs)
liq_values.append(dGIG)
vap_values.append(dGIG)
dUIGs = delta_char + "IG U [{0}]".format(ene_per_molu)
dUIG = f2str(conv_unit(pliq.IGProps.U, "J/mol", ene_per_molu),
6,
lt=1e-2,
gt=1e4)
labels.append(dUIGs)
liq_values.append(dUIG)
vap_values.append(dUIG)
dAIGs = delta_char + "IG A [{0}]".format(ene_per_molu)
dAIG = f2str(conv_unit(pliq.IGProps.A, "J/mol", ene_per_molu),
6,
lt=1e-2,
gt=1e4)
labels.append(dAIGs)
liq_values.append(dAIG)
vap_values.append(dAIG)
else:
fs = "Fugacity [{0}]".format(Pu)
fliq = f2str(conv_unit(pliq.Fugacity, "Pa", Pu), 8, lt=1e-2, gt=1e4)
fvap = f2str(conv_unit(pvap.Fugacity, "Pa", Pu), 8, lt=1e-2, gt=1e4)
labels.append(fs)
liq_values.append(fliq)
vap_values.append(fvap)
# log += "Compound have no ideal properties (maybe it doesn't have ideal Cp parameters)\n"
return labels, liq_values, vap_values
