def demo_simpel_Values():
steamTable = XSteam(XSteam.UNIT_SYSTEM_MKS)
# get saturated liquid enthalpy for a preasure of 220 bar
print('hV_p(220.0) =', steamTable.hL_p(220.0))
# get saturated vapour enthalpy for a preasure of 220 bar
print('hV_p(220.0) =', steamTable.hV_p(220.0))
print('tcL_p(1.0) =', steamTable.tcL_p(1.0))
print('tcL_t(25.0) =', steamTable.tcL_t(25.0))
print('tcV_p(1.0) =', steamTable.tcV_p(1.0))
print('tcL_t(25.0) =', steamTable.tcV_t(25.0))
print('tc_hs(100.0, 0.34) =', steamTable.tc_hs(100.0, 0.34))
print('tc_ph(1.0, 100.0) =', steamTable.tc_ph(1.0, 100.0))
print('tc_pt(1.0, 25.0) =', steamTable.tc_pt(1.0, 25.0))
print('w_ps(1.0, 1.0) =', steamTable.w_ps(1.0, 1.0))
def demo_simpel_Values():
steamTable = XSteam(XSteam.UNIT_SYSTEM_MKS)
# get saturated liquid enthalpy for a preasure of 220 bar
print('hV_p(220.0) =', steamTable.hL_p(220.0))
# get saturated vapour enthalpy for a preasure of 220 bar
print('hV_p(220.0) =', steamTable.hV_p(220.0))
print('tcL_p(1.0) =', steamTable.tcL_p(1.0))
print('tcL_t(25.0) =', steamTable.tcL_t(25.0))
print('tcV_p(1.0) =', steamTable.tcV_p(1.0))
print('tcL_t(25.0) =', steamTable.tcV_t(25.0))
print('tc_hs(100.0, 0.34) =', steamTable.tc_hs(100.0, 0.34))
print('tc_ph(1.0, 100.0) =', steamTable.tc_ph(1.0, 100.0))
print('tc_pt(1.0, 25.0) =', steamTable.tc_pt(1.0, 25.0))
print('w_ps(1.0, 1.0) =', steamTable.w_ps(1.0, 1.0))
def demo_simpel_values():
"""calculate values and print the results"""
steam_table = XSteam(XSteam.UNIT_SYSTEM_MKS)
# get saturated liquid enthalpy for a preasure of 220 bar
print("hV_p(220.0) =", steam_table.hL_p(220.0))
# get saturated vapour enthalpy for a preasure of 220 bar
print("hV_p(220.0) =", steam_table.hV_p(220.0))
print("tcL_p(1.0) =", steam_table.tcL_p(1.0))
print("tcL_t(25.0) =", steam_table.tcL_t(25.0))
print("tcV_p(1.0) =", steam_table.tcV_p(1.0))
print("tcL_t(25.0) =", steam_table.tcV_t(25.0))
print("tc_hs(100.0, 0.34) =", steam_table.tc_hs(100.0, 0.34))
print("tc_ph(1.0, 100.0) =", steam_table.tc_ph(1.0, 100.0))
print("tc_pt(1.0, 25.0) =", steam_table.tc_pt(1.0, 25.0))
print("w_ps(1.0, 1.0) =", steam_table.w_ps(1.0, 1.0))
def get_trace_result(input_data):
base_data = {}
pipe_data = {}
for i in input_data[0]:
base_data[i['name']] = i['value']
steam_pressure = float(base_data['steam_pressure'])
TT = float(base_data['steam_temp'])
Tamb = float(base_data['amb_temp'])
wv = float(base_data['wind_velocity'])
for i in input_data[1]:
if i['class'] in pipe_data:
pipe_data[i['class']][next(iter(i))] = i[next(iter(i))]
else:
pipe_data[i['class']] = {next(iter(i)): i[next(iter(i))]}
for i, j in pipe_data.items():
TP = float(j['maintain_temp'])
NPS = float(j['pipe_dia'])
INS = float(j['insulation_thickness'])
ins_type = j['insulation_type']
pipe_length = float(j['pipe_length'])
trace = get_trace_calc(TP, TT, Tamb, NPS, ins_type, INS, wv)[1]
heat_loss = get_trace_calc(TP, TT, Tamb, NPS, ins_type, INS, wv)[0]
pipe_data[i]['trace'] = trace
pipe_data[i]['heat_loss'] = round(heat_loss, 3)
steamTable = XSteam(XSteam.UNIT_SYSTEM_FLS)
h = steamTable.hV_p(steam_pressure +
14.696) - steamTable.hL_p(steam_pressure + 14.696)
#check
pipe_data[i]['steam_require'] = round((pipe_length * heat_loss / h), 3)
tracer_length = get_tracer_length(steam_pressure, trace)
pipe_data[i]['tracer_length'] = tracer_length
return pipe_data
h2 = h1 + w_p
print(f"H2: {round(float(h2),1)} kJ/kg")
T2 = steamTable.t_ph(p2, h2)
print(f"T2: {round(float(T2),1)} degC")
h2dash = steamTable.hL_p(p2)
s2dash = steamTable.sL_p(p2)
T2dash = steamTable.t_ph(p2, h2dash)
print('\nPoint 2dash')
print(f"H2dash: {round(float(h2dash),1)} kJ/kg")
print(f"S2dash: {round(float(s2dash),3)} kJ/kg K")
print(f"T2dash: {round(float(T2dash),1)} degC")
p3 = p2
h3 = steamTable.hV_p(p2)
s3 = steamTable.sV_p(p2)
T3 = T2dash
print('\nPoint 3')
print(f"P3: {round(float(p3),1)} bar")
print(f"T3: {round(float(T3),1)} degC")
print(f"H3: {round(float(h3),1)} kJ/kg")
print(f"S3: {round(float(s3),3)} kJ/kg K")
p4 = p1
s4 = s3
T4 = steamTable.t_ps(p4, s4)
x4 = steamTable.x_ps(p4, s4)
h4 = steamTable.h_px(p4, x4)
print('\nPoint 4')
print(f"P4: {round(float(p4),1)} bar")
h2 = h1 + w_p
print(f"H2: {round(float(h2),1)} kJ/kg")
T2 = steamTable.t_ph(p2, h2)
print(f"T2: {round(float(T2),1)} degC")
h2dash = steamTable.hL_p(p2)
s2dash = steamTable.sL_p(p2)
T2dash = steamTable.t_ph(p2, h2dash)
print('\nPoint 2 dash')
print(f"T2dash: {round(float(T2dash),1)} degC")
print(f"p2dash: {round(float(p2),1)} bar")
print(f"H2dash: {round(float(h2dash),1)} kJ/kg")
print(f"S2dash: {round(float(s2dash),3)} kJ/kg K")
h3dash = steamTable.hV_p(p2)
s3dash = steamTable.sV_p(p2)
T3dash = T2dash
print('\nPoint 3dash')
print(f"T3dash: {round(float(T3dash),1)} degC")
print(f"H3dash: {round(float(h3dash),1)} kJ/kg")
print(f"S3dash: {round(float(s3dash),3)} kJ/kg K")
p3 = p2
T3 = 540
h3 = steamTable.h_pt(p3, T3)
s3 = steamTable.s_pt(p3, T3)
print('\nPoint 3')
print(f"T3: {round(float(T3),1)} degC")
print(f"p3: {round(float(p3),1)} bar")
print(f"H3: {round(float(h3),1)} kJ/kg")
class MKS_FunctionTester(unittest.TestCase):
def setUp(self):
self.maxError = 1E-6
self.steamTable = XSteam(XSteam.UNIT_SYSTEM_MKS)
def tearDown(self):
pass
def test_tsat_p(self):
error = self.steamTable.tsat_p(1.0) - 99.60591861
self.assertLess(error, self.maxError, 'tsat_p not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_t_ph(self):
error = self.steamTable.t_ph(1.0, 100.0) - 23.84481908
self.assertLess(error, self.maxError, 't_ph not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_t_ps(self):
error = self.steamTable.t_ps(1.0, 1.0) - 73.70859421
self.assertLess(error, self.maxError, 't_ps not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_t_hs(self):
error = self.steamTable.t_hs(100.0, 0.2) - 13.84933511
self.assertLess(error, self.maxError, 't_hs not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_psat_t(self):
error = self.steamTable.psat_t(100.0) - 1.014179779
self.assertLess(error, self.maxError, 'psat_t not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_p_hs(self):
error = self.steamTable.p_hs(84.0, 0.296) - 2.295498269
self.assertLess(error, self.maxError, 'p_hs not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_hV_p(self):
error = self.steamTable.hV_p(1.0) - 2674.949641
self.assertLess(error, self.maxError, 'hV_p not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_hL_p(self):
error = self.steamTable.hL_p(1.0) - 417.4364858
self.assertLess(error, self.maxError, 'hL_p not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_hV_t(self):
error = self.steamTable.hV_t(100.0) - 2675.572029
self.assertLess(error, self.maxError, 'hV_t not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_hL_t(self):
error = self.steamTable.hL_t(100.0) - 419.099155
self.assertLess(error, self.maxError, 'hL_t not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_h_pt(self):
error = self.steamTable.h_pt(1.0, 20.0) - 84.01181117
self.assertLess(error, self.maxError, 'h_pt not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_h_ps(self):
error = self.steamTable.h_ps(1.0, 1.0) - 308.6107171
self.assertLess(error, self.maxError, 'h_ps not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_h_px(self):
error = self.steamTable.h_px(1.0, 0.5) - 1546.193063
self.assertLess(error, self.maxError, 'h_px not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_h_prho(self):
error = self.steamTable.h_prho(1.0, 2.0) - 1082.773391
self.assertLess(error, self.maxError, 'h_prho not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_h_tx(self):
error = self.steamTable.h_tx(100.0, 0.5) - 1547.33559211
self.assertLess(error, self.maxError, 'h_tx not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_vV_p(self):
error = self.steamTable.vV_p(1.0) - 1.694022523
self.assertLess(error, self.maxError, 'vV_p not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_vL_p(self):
error = self.steamTable.vL_p(1.0) - 0.001043148
self.assertLess(error, self.maxError, 'vL_p not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_vV_t(self):
error = self.steamTable.vV_t(100.0) - 1.671860601
self.assertLess(error, self.maxError, 'vV_t not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_vL_t(self):
error = self.steamTable.vL_t(100.0) - 0.001043455
self.assertLess(error, self.maxError, 'vL_t not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_v_pt(self):
error = self.steamTable.v_pt(1.0, 100.0) - 1.695959407
self.assertLess(error, self.maxError, 'v_pt not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_v_ph(self):
error = self.steamTable.v_ph(1.0, 1000.0) - 0.437925658
self.assertLess(error, self.maxError, 'v_ph not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_v_ps(self):
error = self.steamTable.v_ps(1.0, 5.0) - 1.03463539
self.assertLess(error, self.maxError, 'v_ps not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_rhoV_p(self):
error = self.steamTable.rhoV_p(1.0) - 0.590310924
self.assertLess(error, self.maxError, 'rhoV_p not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_rhoL_p(self):
error = self.steamTable.rhoL_p(1.0) - 958.6368897
self.assertLess(error, self.maxError, 'rhoL_p not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_rhoV_t(self):
error = self.steamTable.rhoV_t(100.0) - 0.598135993
self.assertLess(error, self.maxError, 'rhoV_t not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_rhoL_t(self):
error = self.steamTable.rhoL_t(100.0) - 958.3542773
self.assertLess(error, self.maxError, 'rhoL_t not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_rho_pt(self):
error = self.steamTable.rho_pt(1.0, 100.0) - 0.589636754
self.assertLess(error, self.maxError, 'rho_pt not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_rho_ph(self):
error = self.steamTable.rho_ph(1.0, 1000.0) - 2.283492601
self.assertLess(error, self.maxError, 'rho_ph not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_rho_ps(self):
error = self.steamTable.rho_ps(1.0, 1.0) - 975.6236788
self.assertLess(error, self.maxError, 'rho_ps not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_sV_p(self):
error = self.steamTable.sV_p(0.006117) - 9.155465556
self.assertLess(error, self.maxError, 'sV_p not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_sL_p(self):
error = self.steamTable.sL_p(0.0061171) - 1.8359e-05
self.assertLess(error, self.maxError, 'sL_p not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_sV_t(self):
error = self.steamTable.sV_t(0.0001) - 9.155756716
self.assertLess(error, self.maxError, 'sV_t not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_sL_t(self):
error = self.steamTable.sL_t(100.0) - 1.307014328
self.assertLess(error, self.maxError, 'sL_t not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_s_pt(self):
error = self.steamTable.s_pt(1.0, 20.0) - 0.296482921
self.assertLess(error, self.maxError, 's_pt not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_s_ph(self):
error = self.steamTable.s_ph(1.0, 84.01181117) - 0.296813845
self.assertLess(error, self.maxError, 's_ph not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_uV_p(self):
error = self.steamTable.uV_p(1.0) - 2505.547389
self.assertLess(error, self.maxError, 'uV_p not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_uL_p(self):
error = self.steamTable.uL_p(1.0) - 417.332171
self.assertLess(error, self.maxError, 'uL_p not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_uV_t(self):
error = self.steamTable.uV_t(100.0) - 2506.015308
self.assertLess(error, self.maxError, 'uV_t not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_uL_t(self):
error = self.steamTable.uL_t(100.0) - 418.9933299
self.assertLess(error, self.maxError, 'uL_t not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_u_pt(self):
error = self.steamTable.u_pt(1.0, 100.0) - 2506.171426
self.assertLess(error, self.maxError, 'u_pt not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_u_ph(self):
error = self.steamTable.u_ph(1.0, 1000.0) - 956.2074342
self.assertLess(error, self.maxError, 'u_ph not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_u_ps(self):
error = self.steamTable.u_ps(1.0, 1.0) - 308.5082185
self.assertLess(error, self.maxError, 'u_ps not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_CpV_p(self):
error = self.steamTable.CpV_p(1.0) - 2.075938025
self.assertLess(error, self.maxError, 'cpV_p not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_CpL_p(self):
error = self.steamTable.CpL_p(1.0) - 4.216149431
self.assertLess(error, self.maxError, 'cpL_p not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_CpV_t(self):
error = self.steamTable.CpV_t(100.0) - 2.077491868
self.assertLess(error, self.maxError, 'cpV_t not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_CpL_t(self):
error = self.steamTable.CpL_t(100.0) - 4.216645119
self.assertLess(error, self.maxError, 'cpL_t not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_Cp_pt(self):
error = self.steamTable.Cp_pt(1.0, 100.0) - 2.074108555
self.assertLess(error, self.maxError, 'cp_pt not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_Cp_ph(self):
error = self.steamTable.Cp_ph(1.0, 200.0) - 4.17913573169
self.assertLess(error, self.maxError, 'Cp_ph not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_Cp_ps(self):
error = self.steamTable.Cp_ps(1.0, 1.0) - 4.190607038
self.assertLess(error, self.maxError, 'Cp_ps not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_CvV_p(self):
error = self.steamTable.CvV_p(1.0) - 1.552696979
self.assertLess(error, self.maxError, 'CvV_p not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_CvL_p(self):
error = self.steamTable.CvL_p(1.0) - 3.769699683
self.assertLess(error, self.maxError, 'CvL_p not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_CvV_t(self):
error = self.steamTable.CvV_t(100.0) - 1.553698696
self.assertLess(error, self.maxError, 'CvV_t not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_CvL_t(self):
error = self.steamTable.CvL_t(100.0) - 3.76770022
self.assertLess(error, self.maxError, 'CvL_t not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_Cv_pt(self):
error = self.steamTable.Cv_pt(1.0, 100.0) - 1.551397249
self.assertLess(error, self.maxError, 'Cv_pt not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_Cv_ph(self):
error = self.steamTable.Cv_ph(1.0, 200.0) - 4.035176364
self.assertLess(error, self.maxError, 'Cv_ph not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_Cv_ps(self):
error = self.steamTable.Cv_ps(1.0, 1.0) - 3.902919468
self.assertLess(error, self.maxError, 'Cv_ps not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_wV_p(self):
error = self.steamTable.wV_p(1.0) - 472.0541571
self.assertLess(error, self.maxError, 'wV_p not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_wL_p(self):
error = self.steamTable.wL_p(1.0) - 1545.451948
self.assertLess(error, self.maxError, 'wL_p not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_wV_t(self):
error = self.steamTable.wV_t(100.0) - 472.2559492
self.assertLess(error, self.maxError, 'wV_t not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_wL_t(self):
error = self.steamTable.wL_t(100.0) - 1545.092249
self.assertLess(error, self.maxError, 'wL_t not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_w_pt(self):
error = self.steamTable.w_pt(1.0, 100.0) - 472.3375235
self.assertLess(error, self.maxError, 'w_pt not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_w_ph(self):
error = self.steamTable.w_ph(1.0, 200.0) - 1542.682475
self.assertLess(error, self.maxError, 'w_ph not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_w_ps(self): # TODO: Check values and calculation
error = self.steamTable.w_ps(1.0, 1.0) - 1557.8585
self.assertLess(error, self.maxError, 'w_ps not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_my_pt(self):
error = self.steamTable.my_pt(1.0, 100.0) - 1.22704e-05
self.assertLess(error, self.maxError, 'my_pt not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_my_ph(self):
error = self.steamTable.my_ph(1.0, 100.0) - 0.000914003770302
self.assertLess(error, self.maxError, 'my_ph not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_my_ps(self):
error = self.steamTable.my_ps(1.0, 1.0) - 0.000384222
self.assertLess(error, self.maxError, 'my_ps not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_tcL_p(self):
error = self.steamTable.tcL_p(1.0) - 0.677593822
self.assertLess(error, self.maxError, 'tcL_p not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_tcV_p(self):
error = self.steamTable.tcV_p(1.0) - 0.024753668
self.assertLess(error, self.maxError, 'tcV_p not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_tcL_t(self):
error = self.steamTable.tcL_t(25.0) - 0.607458162
self.assertLess(error, self.maxError, 'tcL_t not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_tcV_t(self):
error = self.steamTable.tcV_t(25.0) - 0.018326723
self.assertLess(error, self.maxError, 'tcV_t not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_tc_pt(self):
error = self.steamTable.tc_pt(1.0, 25.0) - 0.607509806
self.assertLess(error, self.maxError, 'tc_pt not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_tc_ph(self):
error = self.steamTable.tc_ph(1.0, 100.0) - 0.605710062
self.assertLess(error, self.maxError, 'tc_ph not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_tc_hs(self):
error = self.steamTable.tc_hs(100.0, 0.34) - 0.606283124
self.assertLess(error, self.maxError, 'tc_hs not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_st_t(self):
error = self.steamTable.st_t(100.0) - 0.0589118685877
self.assertLess(error, self.maxError, 'st_t not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_st_p(self):
error = self.steamTable.st_p(1.0) - 0.058987784
self.assertLess(error, self.maxError, 'st_p not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_x_ph(self):
error = self.steamTable.x_ph(1.0, 1000.0) - 0.258055424
self.assertLess(error, self.maxError, 'x_ph not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_x_ps(self):
error = self.steamTable.x_ps(1.0, 4.0) - 0.445397961
self.assertLess(error, self.maxError, 'x_ps not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_vx_ph(self):
error = self.steamTable.vx_ph(1.0, 418.0) - 0.288493093
self.assertLess(error, self.maxError, 'vx_ph not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
def test_vx_ps(self):
error = self.steamTable.vx_ps(1.0, 4.0) - 0.999233827
self.assertLess(error, self.maxError, 'vx_ps not passed Error %(error)e allowed: %(max)e' % {'error': error, 'max': self.maxError})
class FLS_FunctionTester(unittest.TestCase):
def setUp(self):
self.maxError = 1E-6
self.steamTable = XSteam(XSteam.UNIT_SYSTEM_FLS)
def tearDown(self):
pass
def test_tsat_p(self):
error = self.steamTable.tsat_p(1.0) - 99.60591861
self.assertLess(
error, self.maxError,
'tsat_p not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_t_ph(self):
error = self.steamTable.t_ph(1.0, 100.0) - 23.84481908
self.assertLess(
error, self.maxError,
't_ph not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_t_ps(self):
error = self.steamTable.t_ps(1.0, 1.0) - 73.70859421
self.assertLess(
error, self.maxError,
't_ps not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_t_hs(self):
error = self.steamTable.t_hs(100.0, 0.2) - 13.84933511
self.assertLess(
error, self.maxError,
't_hs not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_psat_t(self):
error = self.steamTable.psat_t(100.0) - 1.014179779
self.assertLess(
error, self.maxError,
'psat_t not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_p_hs(self):
error = self.steamTable.p_hs(84.0, 0.296) - 2.295498269
self.assertLess(
error, self.maxError,
'p_hs not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_hV_p(self):
error = self.steamTable.hV_p(1.0) - 2674.949641
self.assertLess(
error, self.maxError,
'hV_p not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_hL_p(self):
error = self.steamTable.hL_p(1.0) - 417.4364858
self.assertLess(
error, self.maxError,
'hL_p not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_hV_t(self):
error = self.steamTable.hV_t(100.0) - 2675.572029
self.assertLess(
error, self.maxError,
'hV_t not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_hL_t(self):
error = self.steamTable.hL_t(100.0) - 419.099155
self.assertLess(
error, self.maxError,
'hL_t not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_h_pt(self):
error = self.steamTable.h_pt(1.0, 20.0) - 84.01181117
self.assertLess(
error, self.maxError,
'h_pt not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_h_ps(self):
error = self.steamTable.h_ps(1.0, 1.0) - 308.6107171
self.assertLess(
error, self.maxError,
'h_ps not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_h_px(self):
error = self.steamTable.h_px(1.0, 0.5) - 1546.193063
self.assertLess(
error, self.maxError,
'h_px not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_h_prho(self):
error = self.steamTable.h_prho(1.0, 2.0) - 1082.773391
self.assertLess(
error, self.maxError,
'h_prho not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_h_tx(self):
error = self.steamTable.h_tx(100.0, 0.5) - 1547.33559211
self.assertLess(
error, self.maxError,
'h_tx not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_vV_p(self):
error = self.steamTable.vV_p(1.0) - 1.694022523
self.assertLess(
error, self.maxError,
'vV_p not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_vL_p(self):
error = self.steamTable.vL_p(1.0) - 0.001043148
self.assertLess(
error, self.maxError,
'vL_p not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_vV_t(self):
error = self.steamTable.vV_t(100.0) - 1.671860601
self.assertLess(
error, self.maxError,
'vV_t not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_vL_t(self):
error = self.steamTable.vL_t(100.0) - 0.001043455
self.assertLess(
error, self.maxError,
'vL_t not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_v_pt(self):
error = self.steamTable.v_pt(1.0, 100.0) - 1.695959407
self.assertLess(
error, self.maxError,
'v_pt not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_v_ph(self):
error = self.steamTable.v_ph(1.0, 1000.0) - 0.437925658
self.assertLess(
error, self.maxError,
'v_ph not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_v_ps(self):
error = self.steamTable.v_ps(1.0, 5.0) - 1.03463539
self.assertLess(
error, self.maxError,
'v_ps not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_rhoV_p(self):
error = self.steamTable.rhoV_p(1.0) - 0.590310924
self.assertLess(
error, self.maxError,
'rhoV_p not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_rhoL_p(self):
error = self.steamTable.rhoL_p(1.0) - 958.6368897
self.assertLess(
error, self.maxError,
'rhoL_p not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_rhoV_t(self):
error = self.steamTable.rhoV_t(100.0) - 0.598135993
self.assertLess(
error, self.maxError,
'rhoV_t not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_rhoL_t(self):
error = self.steamTable.rhoL_t(100.0) - 958.3542773
self.assertLess(
error, self.maxError,
'rhoL_t not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_rho_pt(self):
error = self.steamTable.rho_pt(1.0, 100.0) - 0.589636754
self.assertLess(
error, self.maxError,
'rho_pt not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_rho_ph(self):
error = self.steamTable.rho_ph(1.0, 1000.0) - 2.283492601
self.assertLess(
error, self.maxError,
'rho_ph not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_rho_ps(self):
error = self.steamTable.rho_ps(1.0, 1.0) - 975.6236788
self.assertLess(
error, self.maxError,
'rho_ps not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_sV_p(self):
error = self.steamTable.sV_p(0.006117) - 9.155465556
self.assertLess(
error, self.maxError,
'sV_p not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_sL_p(self):
error = self.steamTable.sL_p(0.0061171) - 1.8359e-05
self.assertLess(
error, self.maxError,
'sL_p not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_sV_t(self):
error = self.steamTable.sV_t(0.0001) - 9.155756716
self.assertLess(
error, self.maxError,
'sV_t not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_sL_t(self):
error = self.steamTable.sL_t(100.0) - 1.307014328
self.assertLess(
error, self.maxError,
'sL_t not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_s_pt(self):
error = self.steamTable.s_pt(1.0, 20.0) - 0.296482921
self.assertLess(
error, self.maxError,
's_pt not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_s_ph(self):
error = self.steamTable.s_ph(1.0, 84.01181117) - 0.296813845
self.assertLess(
error, self.maxError,
's_ph not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_uV_p(self):
error = self.steamTable.uV_p(1.0) - 2505.547389
self.assertLess(
error, self.maxError,
'uV_p not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_uL_p(self):
error = self.steamTable.uL_p(1.0) - 417.332171
self.assertLess(
error, self.maxError,
'uL_p not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_uV_t(self):
error = self.steamTable.uV_t(100.0) - 2506.015308
self.assertLess(
error, self.maxError,
'uV_t not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_uL_t(self):
error = self.steamTable.uL_t(100.0) - 418.9933299
self.assertLess(
error, self.maxError,
'uL_t not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_u_pt(self):
error = self.steamTable.u_pt(1.0, 100.0) - 2506.171426
self.assertLess(
error, self.maxError,
'u_pt not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_u_ph(self):
error = self.steamTable.u_ph(1.0, 1000.0) - 956.2074342
self.assertLess(
error, self.maxError,
'u_ph not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_u_ps(self):
error = self.steamTable.u_ps(1.0, 1.0) - 308.5082185
self.assertLess(
error, self.maxError,
'u_ps not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_CpV_p(self):
error = self.steamTable.cpV_p(1.0) - 2.075938025
self.assertLess(
error, self.maxError,
'cpV_p not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_CpL_p(self):
error = self.steamTable.cpL_p(1.0) - 4.216149431
self.assertLess(
error, self.maxError,
'cpL_p not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_CpV_t(self):
error = self.steamTable.cpV_t(100.0) - 2.077491868
self.assertLess(
error, self.maxError,
'cpV_t not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_CpL_t(self):
error = self.steamTable.cpL_t(100.0) - 4.216645119
self.assertLess(
error, self.maxError,
'cpL_t not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_Cp_pt(self):
error = self.steamTable.cp_pt(1.0, 100.0) - 2.074108555
self.assertLess(
error, self.maxError,
'cp_pt not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_Cp_ph(self):
error = self.steamTable.Cp_ph(1.0, 200.0) - 4.17913573169
self.assertLess(
error, self.maxError,
'Cp_ph not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_Cp_ps(self):
error = self.steamTable.Cp_ps(1.0, 1.0) - 4.190607038
self.assertLess(
error, self.maxError,
'Cp_ps not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_CvV_p(self):
error = self.steamTable.CvV_p(1.0) - 1.552696979
self.assertLess(
error, self.maxError,
'CvV_p not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_CvL_p(self):
error = self.steamTable.CvL_p(1.0) - 3.769699683
self.assertLess(
error, self.maxError,
'CvL_p not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_CvV_t(self):
error = self.steamTable.CvV_t(100.0) - 1.553698696
self.assertLess(
error, self.maxError,
'CvV_t not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_CvL_t(self):
error = self.steamTable.CvL_t(100.0) - 3.76770022
self.assertLess(
error, self.maxError,
'CvL_t not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_Cv_pt(self):
error = self.steamTable.Cv_pt(1.0, 100.0) - 1.551397249
self.assertLess(
error, self.maxError,
'Cv_pt not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_Cv_ph(self):
error = self.steamTable.Cv_ph(1.0, 200.0) - 4.035176364
self.assertLess(
error, self.maxError,
'Cv_ph not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_Cv_ps(self):
error = self.steamTable.Cv_ps(1.0, 1.0) - 3.902919468
self.assertLess(
error, self.maxError,
'Cv_ps not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_wV_p(self):
error = self.steamTable.wV_p(1.0) - 472.0541571
self.assertLess(
error, self.maxError,
'wV_p not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_wL_p(self):
error = self.steamTable.wL_p(1.0) - 1545.451948
self.assertLess(
error, self.maxError,
'wL_p not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_wV_t(self):
error = self.steamTable.wV_t(100.0) - 472.2559492
self.assertLess(
error, self.maxError,
'wV_t not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_wL_t(self):
error = self.steamTable.wL_t(100.0) - 1545.092249
self.assertLess(
error, self.maxError,
'wL_t not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_w_pt(self):
error = self.steamTable.w_pt(1.0, 100.0) - 472.3375235
self.assertLess(
error, self.maxError,
'w_pt not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_w_ph(self):
error = self.steamTable.w_ph(1.0, 200.0) - 1542.682475
self.assertLess(
error, self.maxError,
'w_ph not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_w_ps(self):
error = self.steamTable.w_ps(1.0, 1.0) - 1557.8585
self.assertLess(
error, self.maxError,
'w_ps not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_my_pt(self):
error = self.steamTable.my_pt(1.0, 100.0) - 1.22704e-05
self.assertLess(
error, self.maxError,
'my_pt not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_my_ph(self):
error = self.steamTable.my_ph(1.0, 100.0) - 0.000914003770302
self.assertLess(
error, self.maxError,
'my_ph not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_my_ps(self):
error = self.steamTable.my_ps(1.0, 1.0) - 0.000384222
self.assertLess(
error, self.maxError,
'my_ps not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_tcL_p(self):
error = self.steamTable.tcL_p(1.0) - 0.677593822
self.assertLess(
error, self.maxError,
'tcL_p not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_tcV_p(self):
error = self.steamTable.tcV_p(1.0) - 0.024753668
self.assertLess(
error, self.maxError,
'tcV_p not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_tcL_t(self):
error = self.steamTable.tcL_t(25.0) - 0.607458162
self.assertLess(
error, self.maxError,
'tcL_t not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_tcV_t(self):
error = self.steamTable.tcV_t(25.0) - 0.018326723
self.assertLess(
error, self.maxError,
'tcV_t not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_tc_pt(self):
error = self.steamTable.tc_pt(1.0, 25.0) - 0.607509806
self.assertLess(
error, self.maxError,
'tc_pt not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_tc_ph(self):
error = self.steamTable.tc_ph(1.0, 100.0) - 0.605710062
self.assertLess(
error, self.maxError,
'tc_ph not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_tc_hs(self):
error = self.steamTable.tc_hs(100.0, 0.34) - 0.606283124
self.assertLess(
error, self.maxError,
'tc_hs not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_st_t(self):
error = self.steamTable.st_t(100.0) - 0.0589118685877
self.assertLess(
error, self.maxError,
'st_t not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_st_p(self):
error = self.steamTable.st_p(1.0) - 0.058987784
self.assertLess(
error, self.maxError,
'st_p not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_x_ph(self):
error = self.steamTable.x_ph(1.0, 1000.0) - 0.258055424
self.assertLess(
error, self.maxError,
'x_ph not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_x_ps(self):
error = self.steamTable.x_ps(1.0, 4.0) - 0.445397961
self.assertLess(
error, self.maxError,
'x_ps not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_vx_ph(self):
error = self.steamTable.vx_ph(1.0, 418.0) - 0.288493093
self.assertLess(
error, self.maxError,
'vx_ph not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
def test_vx_ps(self):
error = self.steamTable.vx_ps(1.0, 4.0) - 0.999233827
self.assertLess(
error, self.maxError,
'vx_ps not passed Error %(error)e allowed: %(max)e' % {
'error': error,
'max': self.maxError
})
z_LC = 0.6
else:
print('Erreur ! Experience mal renseigneé')
g = 9.81
G = mpoint/(np.pi*0.25*D**2) # Flux massique du mélange
z_e = 0. # Position de l'entrée
z_s = L_c # Position de la sortie
q = P_th / (np.pi * D*L_c)
# Titre en sortie pour la BC
L_sc = (steamTable.hL_p(P_s)-steamTable.h_pt(P_s,T_e))*mpoint/(np.pi*D*q)
x_s = 4*q*(L_c-L_sc)/(G*D*(steamTable.hV_p(P_s)-steamTable.hL_p(P_s)))
#####################################################################
###################### Imports tensorflow ###########################
#####################################################################
p_tf = tf.placeholder(dtype=tf.float32,shape=[None,1])
t_tf = tf.placeholder(dtype=tf.float32,shape=[None,1])
z_tf = tf.placeholder(dtype=tf.float32,shape=[None,1])
eps_tf = tf.placeholder(dtype=tf.float32,shape=[None,1])
#
#init = tf.compat.v1.global_variables_initializer()
#
#sess = tf.compat.v1.Session(config=tf.compat.v1.ConfigProto(allow_soft_placement=True, log_device_placement=True))
#
steamTable = XSteam(XSteam.UNIT_SYSTEM_MKS) # print(steamTable.hV_p(1.01325)) atm = 1.01325 # bar # atm = 3 # nT = 0.9 # turbine efficiency nT = 1 # nP = 0.9 # pump efficiency nP = 1 rho = 997 # kg/m3 # rho = 1000 T = 20 # celsius # max_press = 60 # 60 bar is close to the operating press of real nuke systems max_press = 100 # maybe we can cheat a bit cause mdot is gonna be lower h6 = steamTable.hV_p(max_press) s6 = steamTable.sV_p(max_press) h5 = steamTable.hL_p(max_press) turbine_powers = np.linspace(35, 85, 6) # mw # pressures = np.linspace(2, 10, 9) # bar pressures = np.linspace(20, 60, 100) # bar, holds the low pressure turbine val flow_tab_low = [] flow_tab_med = [] flow_tab_hig = [] flow_tab = [] pump_tab = [] qcore_tab = [] efficiency_tab = [] # mass_flows = [] # going to first calculate with isentropic pump and turbine
def demo_ms_and_ofwh():
"""
converted example from Stu Blair, found at https://github.com/stu314159/xsteam/blob/42767648a05c6759ad11aea95256cb24e4fc9499/Examples/Rankine_MS_and_OFWH.m
"""
print("converted example from Stu Blair / https://github.com/stu314159")
print(
"Purpose: test XSteam functionality with slightly more complex Rankine. Uses scipy.optimize.fsolve"
)
print(
"""Problem Description:
A Pressurized Water Reactor transfers heat to a Rankine cycle with the following properties:
* Steam Generator Outlet Pressure: 820 psia, quality = 100%
* High Pressure turbine: outlet pressure 164 psia, isentropic efficiency of 94%.
* Moisture separator draining to OFWH (Open Feed Water Heater)
* Flow extraction downstream of M/S set to make OFWH outlet temperature equal to saturation temp at its pressure
* LP Turbine with outlet pressure of 3 psia, isentropic efficiency of 94%.
* Condenser outlet quality = 0.0
* Main condensate pump (efficiency = 84%) outlet pressure 164 psia
* Main Feed pump (efficiency = 84%) outlet pressure 820 psia"""
)
steam_table = XSteam(XSteam.UNIT_SYSTEM_FLS)
# % Calculations
# %% state point 1 - condenser outlet
state_point_1 = dict()
state_point_1["P"] = 3.0 # % psia - given
state_point_1["x"] = 0.0 # % quality - given
state_point_1["T"] = steam_table.hL_p(state_point_1["P"])
state_point_1["h"] = steam_table.tsat_p(state_point_1["P"])
state_point_1["s"] = steam_table.sL_p(state_point_1["P"])
# %% state point 2
# % compression in main condensate pump
eta_mcp = 0.84 # % pump isentropic efficiency - given
state_point_2 = dict()
state_point_2["s_s"] = state_point_1["s"]
state_point_2["P"] = 164.0 # % psia - given
state_point_2["h_s"] = steam_table.h_ps(state_point_2["P"], state_point_2["s_s"])
state_point_2["h"] = (
state_point_1["h"] - (state_point_1["h"] - state_point_2["h_s"]) / eta_mcp
)
# %% state point 3 OFWH exit
state_point_3 = dict()
state_point_3["P"] = state_point_2["P"] # % constant pressure in OFWH
state_point_3["x"] = 0.0
state_point_3["h"] = steam_table.hL_p(state_point_3["P"])
state_point_3["s"] = steam_table.sL_p(state_point_3["P"])
# %% State point 4 MFP exit
eta_mfp = 0.84
state_point_4 = dict()
state_point_4["P"] = 820.0 # % psia - given
state_point_4["s_s"] = state_point_3["s"]
state_point_4["h_s"] = steam_table.h_ps(state_point_4["P"], state_point_4["s_s"])
state_point_4["h"] = (
state_point_3["h"] - (state_point_3["h"] - state_point_4["h_s"]) / eta_mfp
)
# %% State point 5 S/G Exit
state_point_5 = dict()
state_point_5["P"] = state_point_4["P"] # % assume isobaric in S/G
state_point_5["x"] = 1.0 # % saturated steam; given
state_point_5["h"] = steam_table.hV_p(state_point_5["P"])
state_point_5["s"] = steam_table.sV_p(state_point_5["P"])
# %% State point 6 HP Turbine Exhaust
eta_hpt = 0.94 # % hp turbine isentropic efficiency; given
state_point_6 = dict()
state_point_6["P"] = 164.0 # % psia - given
state_point_6["s_s"] = state_point_5["s"]
state_point_6["h_s"] = steam_table.h_ps(state_point_6["P"], state_point_6["s_s"])
state_point_6["h"] = state_point_5["h"] - eta_hpt * (
state_point_5["h"] - state_point_6["h_s"]
)
state_point_6["x"] = steam_table.x_ph(state_point_6["P"], state_point_6["h"])
# %% State point 7 Moisture Separator vapor exit
state_point_7 = dict()
state_point_7["P"] = state_point_6["P"] # assume isobaric process in M/S
state_point_7["x"] = 1.0 # quality - given
state_point_7["h"] = steam_table.hV_p(state_point_7["P"])
state_point_7["s"] = steam_table.sV_p(state_point_7["P"])
# %% State point 8 LP Turbine exhaust
eta_lpt = 0.94 # % lp turbine isentropic efficiency; given
state_point_8 = dict()
state_point_8["P"] = state_point_1["P"]
state_point_8["s_s"] = state_point_7["s"]
state_point_8["h_s"] = steam_table.h_ps(state_point_8["P"], state_point_8["s_s"])
state_point_8["h"] = state_point_7["h"] - eta_lpt * (
state_point_7["h"] - state_point_8["h_s"]
)
state_point_8["x"] = steam_table.x_ph(state_point_8["P"], state_point_8["h"])
# %% State point 9 Moisture Separator liquid drain to OFWH
state_point_9 = dict()
# % same pressure as HP Turbine exhaust
state_point_9["P"] = state_point_6["P"]
state_point_9["h"] = steam_table.hL_p(state_point_9["P"])
# http://mathesaurus.sourceforge.net/matlab-numpy.html
# %% Energy balance on OFWH to find flow fraction f1 at extraction point
# OFWH_Ebal = @(f1) x(6)*(1-f1)*h(2)+x(6)*f1*h(7)+(1-x(6))*h(9) - h(3)
def OFWH_Ebal(f1):
# https://de.mathworks.com/help/matlab/matlab_prog/matlab-operators-and-special-characters.html
# x(6)*(1-f1)*h(2)+x(6)*f1*h(7)+(1-x(6))*h(9) - h(3)
return (
state_point_6["x"] * (1 - f1) * state_point_2["h"]
+ state_point_6["x"] * f1 * state_point_7["h"]
+ (1 - state_point_6["x"]) * state_point_9["h"]
- state_point_3["h"]
)
f1 = fsolve(OFWH_Ebal, 0.05)[0]
# %% Specific Work and Energy Balance
w_mcp = (state_point_1["h"] - state_point_2["h"]) * f1 * state_point_6["x"]
w_mfp = state_point_3["h"] - state_point_4["h"]
w_hpt = state_point_5["h"] - state_point_6["h"]
w_lpt = (state_point_7["h"] - state_point_8["h"]) * (1 - f1) * state_point_6["x"]
w_net = w_mcp + w_mfp + w_hpt + w_lpt
q_cond = (state_point_1["h"] - state_point_8["h"]) * (1 - f1) * state_point_6["x"]
q_sg = state_point_5["h"] - state_point_4["h"]
q_net = q_cond + q_sg
eta_th = w_net / q_sg
print(f"Net heat: {q_net:.3f} BTU/lbm Net work: {w_net:.3f} BTU/lbm")
print(f"Thermal efficiency: {eta_th*100:.2f} percent")
def demo_reheat_ms_ofwh():
"""
converted example from Stu Blair, found at https://github.com/stu314159/xsteam/blob/42767648a05c6759ad11aea95256cb24e4fc9499/Examples/Rankine_Reheat_MS_OFWH.m
"""
print("converted example from Stu Blair / https://github.com/stu314159")
print("Purpose: use fminsearch / scipy.optimize.fmin")
print(
"""Problem Description:
(a picture would be better....)
"""
)
steam_table = XSteam(XSteam.UNIT_SYSTEM_FLS)
# %% State point 1 - condenser exit
state_point_1 = dict()
state_point_1["P"] = 1.5 # % psia
state_point_1["h"] = steam_table.hL_p(state_point_1["P"])
state_point_1["s"] = steam_table.sL_p(state_point_1["P"])
# %% State point 1 -> 2, main condensate pump
eta_mcp = 0.84
state_point_2 = dict()
state_point_2["P"] = 164.0 # % psia
state_point_2["s_s"] = state_point_1["s"]
state_point_2["h_s"] = steam_table.h_ps(state_point_2["P"], state_point_2["s_s"])
state_point_2["h"] = (
state_point_1["h"] - (state_point_1["h"] - state_point_2["h_s"]) / eta_mcp
)
# %% State point 3, OFWH exit, saturated liquid
state_point_3 = dict()
state_point_3["P"] = state_point_2["P"]
state_point_3["h"] = steam_table.hL_p(state_point_3["P"])
state_point_3["s"] = steam_table.sL_p(state_point_3["P"])
# %% State point 3 -> 4, main feed pump
eta_mfp = 0.84
state_point_4 = dict()
state_point_4["P"] = 820.0 # % psia
state_point_4["s_s"] = state_point_3["s"]
state_point_4["h_s"] = steam_table.h_ps(state_point_4["P"], state_point_4["s_s"])
state_point_4["h"] = (
state_point_3["h"] - (state_point_3["h"] - state_point_4["h_s"]) / eta_mfp
)
# %% State point 5 - Steam generator exit
state_point_5 = dict()
state_point_5["P"] = state_point_4["P"]
state_point_5["h"] = steam_table.hV_p(state_point_5["P"])
state_point_5["s"] = steam_table.sV_p(state_point_5["P"])
# %% State point 6 - HP Turbine Exhaust
eta_hpt = 0.94
state_point_6 = dict()
state_point_6["P"] = 164.0 # % psia
state_point_6["s_s"] = state_point_5["s"]
state_point_6["h_s"] = steam_table.h_ps(state_point_6["P"], state_point_6["s_s"])
state_point_6["h"] = state_point_5["h"] - eta_hpt * (
state_point_5["h"] - state_point_6["h_s"]
)
state_point_6["x"] = steam_table.x_ph(state_point_6["P"], state_point_6["h"])
# %% State point 7 - Moisture Separator Exit
state_point_7 = dict()
state_point_7["P"] = state_point_6["P"]
state_point_7["h"] = steam_table.hV_p(state_point_7["P"])
state_point_7["s"] = steam_table.sV_p(state_point_7["P"])
# %% State point 8 - Reheater Mid-Pressure Steam exit
state_point_8 = dict()
state_point_8["P"] = state_point_7["P"]
state_point_8["T"] = 490.0 # % degrees F
state_point_8["h"] = steam_table.h_pt(state_point_8["P"], state_point_8["T"])
state_point_8["s"] = steam_table.s_pt(state_point_8["P"], state_point_8["T"])
# %% State point 9 - LP Turbine Exhaust
state_point_9 = dict()
state_point_9["P"] = state_point_1["P"]
eta_lpt = 0.94
state_point_9["s_s"] = state_point_8["s"]
state_point_9["h_s"] = steam_table.h_ps(state_point_9["P"], state_point_9["s_s"])
state_point_9["h"] = state_point_8["h"] - eta_lpt * (
state_point_8["h"] - state_point_9["h_s"]
)
# %% State point 10 - Reheater HP Steam exit
state_point_10 = dict()
state_point_10["P"] = state_point_5["P"]
# % assume steam exits as a saturated liquid.
state_point_10["h"] = steam_table.hL_p(state_point_10["P"])
# %% State point 11 - pressure trap exit to OFWH
state_point_11 = dict()
state_point_11["P"] = state_point_2["P"]
# % assume isenthalpic expansion in the trap.
state_point_11["h"] = state_point_10["h"]
# %% State point 12 - Moisture Separator liquid drain to OFWH
state_point_12 = dict()
state_point_12["P"] = state_point_6["P"]
state_point_12["h"] = steam_table.hL_p(state_point_12["P"])
# %% Heat Balance - find the flow fractions
def RH_heatBalance(f):
return (
f[0] * state_point_5["h"]
+ (1 - f[0]) * state_point_6["x"] * (1 - f[1]) * state_point_7["h"]
) - (
f[0] * state_point_10["h"]
+ (1 - f[0]) * state_point_6["x"] * (1 - f[1]) * state_point_8["h"]
)
def OFWH_heatBalance(f):
return (
(1 - f[0]) * (1 - f[1]) * state_point_6["x"] * state_point_2["h"]
+ f[0] * state_point_11["h"]
+ (1 - f[0]) * state_point_6["x"] * f[1] * state_point_7["h"]
+ (1 - f[0]) * (1 - state_point_6["x"]) * state_point_12["h"]
) - state_point_3["h"]
def totalFunctional(f):
return math.fabs(RH_heatBalance(f)) + math.fabs(OFWH_heatBalance(f))
# % the strategy is to minimize the total functional. The minimum value is
# % when they are both equal to zero.
initialGuess = [0.1, 0.1]
f = fmin(func=totalFunctional, x0=initialGuess)
# % % calculate heat and energy balances
w_mcp = (
(state_point_1["h"] - state_point_2["h"])
* (1 - f[0])
* (1 - f[1])
* state_point_6["x"]
)
w_mfp = state_point_3["h"] - state_point_4["h"]
w_hpt = (state_point_5["h"] - state_point_6["h"]) * (1 - f[0])
w_lpt = (
(state_point_8["h"] - state_point_9["h"])
* (1 - f[0])
* (1 - f[1])
* state_point_6["x"]
)
w_net = w_mcp + w_mfp + w_hpt + w_lpt
q_cond = (
(state_point_1["h"] - state_point_9["h"])
* (1 - f[0])
* (1 - f[1])
* state_point_6["x"]
)
q_sg = state_point_5["h"] - state_point_4["h"]
q_net = q_cond + q_sg
eta_th = w_net / q_sg
# % % report the results:
print(f"Net heat: {q_net:.3f} BTU/lbm Net work: {w_net:.3f} BTU/lbm")
print(f"Thermal efficiency: {eta_th*100:.2f} percent")
def demo_simple_cycle():
"""
converted example from Stu Blair
found at https://github.com/stu314159/xsteam/blob/42767648a05c6759ad11aea95256cb24e4fc9499/Examples/SimpleRankineCycle.m
"""
print("Purpose: test xsteam functionality for simple Rankine Cycle")
print(
"""Problem Description:
Advanced Boiling Water Reactor (ABWR) produces saturated steam at 7.17 MPa (71.7 bar) to a set of turbine generators.
The turbines exhaust to condensers maintained at 8 kPa (0.08 bar).
Assume the turbines and pumps have isentropic efficiencies of 100%
Assume fluid leaving the condenser is saturated liquid."""
)
print(
"""Goal:
Calculate enthalpy, entropy, and temperature for all state points.
Calculate net work and thermal efficiency for this cycle"""
)
steam_table = XSteam(XSteam.UNIT_SYSTEM_MKS)
# state point 1: condenser outlet / feed pump inlet
# state point 2: feed pump discharge / Reactor core inlet
# state point 3: reactor core outlet / turbine inlet
# state point 4: turbine exhaust / condenser inlet
# %% State Point 1
# condenser outlet / feed pump inlet
state_point_1 = dict()
state_point_1["P"] = 0.08 # bar - given
state_point_1["x"] = 0.0 # given
state_point_1["T"] = steam_table.tsat_p(state_point_1["P"])
state_point_1["h"] = steam_table.hL_p(state_point_1["P"])
state_point_1["s"] = steam_table.sL_p(state_point_1["P"])
# %% State Point 2
# feed pump discharge / Reactor core inlet
# process: isentropic compression
state_point_2 = dict()
state_point_2["s"] = state_point_1["s"]
state_point_2["P"] = 71.1 # bar - given
state_point_2["h"] = steam_table.t_ps(state_point_2["P"], state_point_2["s"])
state_point_2["T"] = steam_table.t_ph(state_point_2["P"], state_point_2["h"])
# state_point_2["x"] = float("NaN")
pump_work = state_point_1["h"] - state_point_2["h"]
# %% State Point 3
# reactor core outlet / turbine inlet
# % process: isobaric heat addition
state_point_3 = dict()
state_point_3["P"] = state_point_2["P"]
state_point_3["x"] = 1.0
state_point_3["T"] = steam_table.tsat_p(state_point_3["P"])
state_point_3["h"] = steam_table.hV_p(state_point_3["P"])
state_point_3["s"] = steam_table.sV_p(state_point_3["P"])
heat_in = state_point_3["h"] - state_point_2["h"]
# %% State Point 4
# turbine exhaust / condenser inlet
# % process: isentropic expansion
state_point_4 = dict()
state_point_4["s"] = state_point_3["s"]
state_point_4["P"] = state_point_1["P"]
# % for isobaric heat rejection in next step
state_point_4["h"] = steam_table.h_ps(state_point_4["P"], state_point_4["s"])
state_point_4["x"] = steam_table.x_ph(state_point_4["P"], state_point_4["h"])
turbine_work = state_point_3["h"] - state_point_4["h"]
# % % State Point 1
# % process: isobaric heat rejection
heat_out = state_point_1["h"] - state_point_4["h"]
# % % Energy Balance
net_heat = heat_in + heat_out
net_work = turbine_work + pump_work
eta_th = net_work / heat_in
print(f"Net heat: {net_heat:.3f} Net work: {net_work:.3f}")
print(f"Thermal efficiency: {eta_th*100:.2f} percent")
