def test_NRTL():
# P05.01b VLE Behavior of Ethanol - Water Using NRTL
gammas = NRTL_gammas([0.252, 0.748], [[0, -0.178], [1.963, 0]],
[[0, 0.2974], [.2974, 0]])
assert_close1d(gammas, [1.9363183763514304, 1.1537609663170014])
# Test the general form against the simpler binary form
def NRTL2(xs, taus, alpha):
x1, x2 = xs
tau12, tau21 = taus
G12 = exp(-alpha * tau12)
G21 = exp(-alpha * tau21)
gamma1 = exp(x2**2 * (tau21 * (G21 /
(x1 + x2 * G21))**2 + G12 * tau12 /
(x2 + x1 * G12)**2))
gamma2 = exp(x1**2 * (tau12 * (G12 /
(x2 + x1 * G12))**2 + G21 * tau21 /
(x1 + x2 * G21)**2))
return gamma1, gamma2
gammas = NRTL2(xs=[0.252, 0.748], taus=[-0.178, 1.963], alpha=0.2974)
assert_close1d(gammas, [1.9363183763514304, 1.1537609663170014])
# Example by
# https://github.com/iurisegtovich/PyTherm-applied-thermodynamics/blob/master/contents/main-lectures/GE1-NRTL-graphically.ipynb
tau = [[0.0, 2.291653777670652, 0.5166949715946564],
[4.308652420938829, 0.0, 1.6753963198550983],
[0.5527434579849811, 0.15106032392136134, 0.0]]
alpha = [[0.0, 0.4, 0.3], [0.4, 0.0, 0.3], [0.3, 0.3, 0.0]]
xs = [.1, .3, .6]
gammas = NRTL_gammas(xs, tau, alpha)
assert_close1d(gammas,
[2.7175098659360413, 2.1373006474468697, 1.085133765593844])
# Test the values which give activity coefficients of 1:
gammas = NRTL_gammas([0.252, 0.748], [[0, 0], [0, 0]], [[0, 0.5], [.9, 0]])
assert_close1d(gammas, [1, 1])
# alpha does not matter
a = b = np.zeros((6, 6)).tolist()
gammas = NRTL_gammas([0., 1, 0, 0, 0, 0], a, b)
assert_close1d(gammas, [1, 1, 1, 1, 1, 1])
# Test vs chemsep parameters, same water ethanol T and P
T = 343.15
b12 = -57.9601 * calorie
b21 = 1241.7396 * calorie
tau12 = b12 / (R * T)
tau21 = b21 / (R * T)
gammas = NRTL_gammas(xs=[0.252, 0.748],
taus=[[0, tau12], [tau21, 0]],
alphas=[[0, 0.2937], [.2937, 0]])
assert_close1d(gammas, [1.9853834856640085, 1.146380779201308])
# Random bad example
alphas = [[0.0, 0.35, 0.35, 0.35, 0.35], [0.35, 0.0, 0.35, 0.35, 0.35],
[0.35, 0.35, 0.0, 0.35, 0.35], [0.35, 0.35, 0.35, 0.0, 0.35],
[0.35, 0.35, 0.35, 0.35, 0.0]]
taus = [[0.0, 0.651, 2.965, 1.738,
0.761], [1.832, 0.0, 2.783, 1.35, 0.629],
[0.528, 1.288, 0.0, 0.419,
2.395], [1.115, 1.838, 2.16, 0.0, 0.692],
[1.821, 2.466, 1.587, 1.101, 0.0]]
xs = [
0.18736982702111407, 0.2154173017033719, 0.2717319464745698,
0.11018333572613222, 0.215297589074812
]
gammas = NRTL_gammas(xs, taus, alphas)
gammas_expect = [
2.503204848288857, 2.910723989902569, 2.2547951278295497,
2.9933258413917154, 2.694165187439594
]
assert_close1d(gammas, gammas_expect)
def test_Kawahara():
alphas_calc = [Kawahara(.4, 800, 2.5, D) for D in [0.001, 100E-6, 1E-7]]
alphas_exp = [0.8291135303265941, 0.9276148194410238, 0.8952146812696503]
assert_close1d(alphas_calc, alphas_exp)
def test_4_components():
# m = Mixture(['acetone', 'chloroform', 'methanol', 'water'], zs=xs, T=300)
xs = [.4, .3, .2, .1]
SPs = [19570.2, 18864.7, 29261.4, 47863.5]
Vs = [7.421e-05, 8.068e-05, 4.083e-05, 1.808e-05]
N = 4
T = 300.0
# Made up asymmetric parameters
lambda_coeffs = [[0.0, 0.01811, 0.01736, 0.02111],
[0.00662, 0.0, 0.00774, 0.01966],
[0.01601, 0.01022, 0.0, 0.00698],
[0.0152, 0.00544, 0.02579, 0.0]]
GE = RegularSolution(T, xs, Vs, SPs, lambda_coeffs)
assert eval(str(GE)).GE() == GE.GE()
GE2 = RegularSolution.from_json(GE.as_json())
assert GE2.__dict__ == GE.__dict__
# Test with no interaction parameters
GE3 = RegularSolution(T, xs, Vs, SPs)
GE4 = eval(str(GE3))
assert GE3 == GE4
assert GE4.GE() == GE3.GE()
GE5 = RegularSolution.from_json(GE4.as_json())
assert GE4.__dict__ == GE3.__dict__
assert GE5.__dict__ == GE3.__dict__
assert GE5 == GE3
assert hash(GE5) == hash(GE3)
GE6 = eval(str(GE4))
assert GE5.model_hash() == GE6.model_hash()
assert GE5.state_hash() == GE6.state_hash()
dT = 1e-7 * T
gammas_expect = [
1.1928784349228994, 1.3043087978251762, 3.2795596493820955,
197.92137114651274
]
assert_close1d(GE.gammas(), gammas_expect, rtol=1e-12)
assert_close1d(GibbsExcess.gammas(GE), gammas_expect)
# Gammas
assert_close(GE.GE(), 2286.257263714889, rtol=1e-12)
gammas = GE.gammas()
GE_from_gammas = R * T * sum(xi * log(gamma)
for xi, gamma in zip(xs, gammas))
assert_close(GE_from_gammas, GE.GE(), rtol=1e-12)
# Gamma direct call
assert_close1d(GE.gammas(),
regular_solution_gammas(T=T,
xs=xs,
Vs=Vs,
SPs=SPs,
lambda_coeffs=lambda_coeffs,
N=N),
rtol=1e-12)
# dGE dT
dGE_dT_numerical = (
(np.array(GE.to_T_xs(T + dT, xs).GE()) - np.array(GE.GE())) / dT)
dGE_dT_analytical = GE.dGE_dT()
assert_close(dGE_dT_analytical, 0, rtol=1e-12, atol=1e-9)
assert_close(dGE_dT_numerical, dGE_dT_analytical)
# d2GE dT2
d2GE_dT2_numerical = (
(np.array(GE.to_T_xs(T + dT, xs).dGE_dT()) - np.array(GE.dGE_dT())) /
dT)
d2GE_dT2_analytical = GE.d2GE_dT2()
assert_close(d2GE_dT2_analytical, 0, rtol=1e-12, atol=1e-9)
assert_close(d2GE_dT2_analytical, d2GE_dT2_numerical, rtol=1e-8)
# d3GE dT3
d3GE_dT3_numerical = ((np.array(GE.to_T_xs(T + dT, xs).d2GE_dT2()) -
np.array(GE.d2GE_dT2())) / dT)
d3GE_dT3_analytical = GE.d3GE_dT3()
assert_close(d3GE_dT3_analytical, 0, rtol=1e-12, atol=1e-9)
assert_close(d3GE_dT3_numerical, d3GE_dT3_analytical, rtol=1e-7)
# d2GE_dTdxs
def dGE_dT_diff(xs):
return GE.to_T_xs(T, xs).dGE_dT()
d2GE_dTdxs_numerical = jacobian(dGE_dT_diff, xs, perturbation=1e-7)
d2GE_dTdxs_analytical = GE.d2GE_dTdxs()
d2GE_dTdxs_expect = [0] * 4
assert_close1d(d2GE_dTdxs_analytical, d2GE_dTdxs_expect, rtol=1e-12)
assert_close1d(d2GE_dTdxs_numerical, d2GE_dTdxs_analytical, rtol=1e-7)
# dGE_dxs
def dGE_dx_diff(xs):
return GE.to_T_xs(T, xs).GE()
dGE_dxs_numerical = jacobian(dGE_dx_diff, xs, perturbation=1e-7)
dGE_dxs_analytical = GE.dGE_dxs()
dGE_dxs_expect = [
439.92463410596037, 662.6790758115604, 2962.5490239819123,
13189.738825326536
]
assert_close1d(dGE_dxs_analytical, dGE_dxs_expect, rtol=1e-12)
assert_close1d(dGE_dxs_analytical, dGE_dxs_numerical, rtol=1e-7)
# d2GE_dxixjs
d2GE_dxixjs_numerical = hessian(dGE_dx_diff, xs, perturbation=1e-5)
d2GE_dxixjs_analytical = GE.d2GE_dxixjs()
d2GE_dxixjs_expect = [[
-1022.4173091041094, -423.20895951381453, 1638.9017092099375,
2081.4926965380164
],
[
-423.20895951381453, -1674.3900233778054,
1920.6043029143648, 2874.797302359955
],
[
1638.901709209937, 1920.6043029143648,
-3788.1956922483323, -4741.028361086175
],
[
2081.4926965380164, 2874.797302359955,
-4741.028361086175, -7468.305971059591
]]
d2GE_dxixjs_sympy = [[
-1022.4173091041112, -423.208959513817, 1638.9017092099352,
2081.492696538016
],
[
-423.208959513817, -1674.3900233778083,
1920.6043029143652, 2874.7973023599534
],
[
1638.9017092099352, 1920.6043029143652,
-3788.1956922483323, -4741.028361086176
],
[
2081.492696538016, 2874.7973023599534,
-4741.028361086176, -7468.305971059591
]]
assert_close2d(d2GE_dxixjs_analytical, d2GE_dxixjs_sympy, rtol=1e-12)
assert_close2d(d2GE_dxixjs_analytical, d2GE_dxixjs_expect, rtol=1e-12)
assert_close2d(d2GE_dxixjs_analytical, d2GE_dxixjs_numerical, rtol=2.5e-4)
d3GE_dxixjxks_analytical = GE.d3GE_dxixjxks()
d3GE_dxixjxks_sympy = [[[
3564.2598967437325, 2275.2388316927168, -3155.248707372427,
-4548.085576267108
],
[
2275.2388316927168, 3015.024292098843,
-4031.740524903445, -5850.4575581223535
],
[
-3155.248707372427, -4031.740524903445,
2306.3682432066844, 3714.462825687298
],
[
-4548.085576267108, -5850.4575581223535,
3714.462825687298, 7499.862362680743
]],
[[
2275.2388316927168, 3015.024292098843,
-4031.740524903445, -5850.4575581223535
],
[
3015.024292098843, 6346.017369615182,
-3782.270609497761, -6789.70782446731
],
[
-4031.740524903445, -3782.270609497761,
2329.947090204009, 3607.836718555389
],
[
-5850.4575581223535, -6789.70782446731,
3607.836718555389, 7807.307245181044
]],
[[
-3155.248707372427, -4031.740524903445,
2306.3682432066844, 3714.462825687298
],
[
-4031.740524903445, -3782.270609497761,
2329.947090204009, 3607.836718555389
],
[
2306.3682432066844, 2329.947090204009,
7265.918548487337, 7134.805582069884
],
[
3714.462825687298, 3607.836718555389,
7134.805582069884, 7459.310988306651
]],
[[
-4548.085576267108, -5850.4575581223535,
3714.462825687298, 7499.862362680743
],
[
-5850.4575581223535, -6789.70782446731,
3607.836718555389, 7807.307245181044
],
[
3714.462825687298, 3607.836718555389,
7134.805582069884, 7459.310988306651
],
[
7499.862362680743, 7807.307245181044,
7459.310988306651, 6343.066547716518
]]]
assert_close3d(d3GE_dxixjxks_analytical, d3GE_dxixjxks_sympy, rtol=1e-12)
# Test with some stored results
GE2 = RegularSolution.from_json(GE.as_json())
assert GE2.__dict__ == GE.__dict__
def test_helical_turbulent_Nu_Schmidt():
Nu = helical_turbulent_Nu_Schmidt(2E5, 0.7, 0.01, .2)
assert_close(Nu, 466.2569996832083)
Nus = [helical_turbulent_Nu_Schmidt(i, 0.7, 0.01, .2) for i in [2.2E4, 2.2E4+1E-9]]
assert_close1d(Nus, [80.1111786843, 79.75161984693375])
def test_C_long_radius_nozzle_full():
Cs = [[0.9673, 0.9759, 0.9834, 0.9873, 0.9900, 0.9924, 0.9936, 0.9952, 0.9956],
[0.9659, 0.9748, 0.9828, 0.9868, 0.9897, 0.9922, 0.9934, 0.9951, 0.9955],
[0.9645, 0.9739, 0.9822, 0.9864, 0.9893, 0.9920, 0.9933, 0.9951, 0.9955],
[0.9632, 0.9730, 0.9816, 0.9860, 0.9891, 0.9918, 0.9932, 0.9950, 0.9954],
[0.9619, 0.9721, 0.9810, 0.9856, 0.9888, 0.9916, 0.9930, 0.9950, 0.9954],
[0.9607, 0.9712, 0.9805, 0.9852, 0.9885, 0.9914, 0.9929, 0.9949, 0.9954],
[0.9596, 0.9704, 0.9800, 0.9848, 0.9882, 0.9913, 0.9928, 0.9948, 0.9953],
[0.9584, 0.9696, 0.9795, 0.9845, 0.9880, 0.9911, 0.9927, 0.9948, 0.9953],
[0.9573, 0.9688, 0.9790, 0.9841, 0.9877, 0.9910, 0.9926, 0.9947, 0.9953],
[0.9562, 0.9680, 0.9785, 0.9838, 0.9875, 0.9908, 0.9925, 0.9947, 0.9952],
[0.9552, 0.9673, 0.9780, 0.9834, 0.9873, 0.9907, 0.9924, 0.9947, 0.9952],
[0.9542, 0.9666, 0.9776, 0.9831, 0.9870, 0.9905, 0.9923, 0.9946, 0.9952],
[0.9532, 0.9659, 0.9771, 0.9828, 0.9868, 0.9904, 0.9922, 0.9946, 0.9951],
[0.9523, 0.9652, 0.9767, 0.9825, 0.9866, 0.9902, 0.9921, 0.9945, 0.9951],
[0.9513, 0.9645, 0.9763, 0.9822, 0.9864, 0.9901, 0.9920, 0.9945, 0.9951],
[0.9503, 0.9639, 0.9759, 0.9819, 0.9862, 0.9900, 0.9919, 0.9944, 0.9950],
[0.9499, 0.9635, 0.9756, 0.9818, 0.9861, 0.9899, 0.9918, 0.9944, 0.9950],
[0.9494, 0.9632, 0.9754, 0.9816, 0.9860, 0.9898, 0.9918, 0.9944, 0.9950],
[0.9490, 0.9629, 0.9752, 0.9815, 0.9859, 0.9898, 0.9917, 0.9944, 0.9950],
[0.9485, 0.9626, 0.9750, 0.9813, 0.9858, 0.9897, 0.9917, 0.9944, 0.9950],
[0.9481, 0.9623, 0.9748, 0.9812, 0.9857, 0.9897, 0.9917, 0.9943, 0.9950],
[0.9476, 0.9619, 0.9746, 0.9810, 0.9856, 0.9896, 0.9916, 0.9943, 0.9950],
[0.9472, 0.9616, 0.9745, 0.9809, 0.9855, 0.9895, 0.9916, 0.9943, 0.9949],
[0.9468, 0.9613, 0.9743, 0.9808, 0.9854, 0.9895, 0.9915, 0.9943, 0.9949],
[0.9463, 0.9610, 0.9741, 0.9806, 0.9853, 0.9894, 0.9915, 0.9943, 0.9949],
[0.9459, 0.9607, 0.9739, 0.9805, 0.9852, 0.9893, 0.9914, 0.9942, 0.9949],
[0.9455, 0.9604, 0.9737, 0.9804, 0.9851, 0.9893, 0.9914, 0.9942, 0.9949],
[0.9451, 0.9601, 0.9735, 0.9802, 0.9850, 0.9892, 0.9914, 0.9942, 0.9949],
[0.9447, 0.9599, 0.9733, 0.9801, 0.9849, 0.9892, 0.9913, 0.9942, 0.9949],
[0.9443, 0.9596, 0.9731, 0.9800, 0.9848, 0.9891, 0.9913, 0.9942, 0.9948],
[0.9439, 0.9593, 0.9730, 0.9799, 0.9847, 0.9891, 0.9912, 0.9941, 0.9948],
[0.9435, 0.9590, 0.9728, 0.9797, 0.9846, 0.9890, 0.9912, 0.9941, 0.9948],
[0.9430, 0.9587, 0.9726, 0.9796, 0.9845, 0.9889, 0.9912, 0.9941, 0.9948],
[0.9427, 0.9584, 0.9724, 0.9795, 0.9845, 0.9889, 0.9911, 0.9941, 0.9948],
[0.9423, 0.9581, 0.9722, 0.9793, 0.9844, 0.9888, 0.9911, 0.9941, 0.9948],
[0.9419, 0.9579, 0.9721, 0.9792, 0.9843, 0.9888, 0.9910, 0.9941, 0.9948],
[0.9415, 0.9576, 0.9719, 0.9791, 0.9842, 0.9887, 0.9910, 0.9940, 0.9948],
[0.9411, 0.9573, 0.9717, 0.9790, 0.9841, 0.9887, 0.9910, 0.9940, 0.9947],
[0.9407, 0.9570, 0.9715, 0.9789, 0.9840, 0.9886, 0.9909, 0.9940, 0.9947],
[0.9403, 0.9568, 0.9714, 0.9787, 0.9839, 0.9886, 0.9909, 0.9940, 0.9947],
[0.9399, 0.9565, 0.9712, 0.9786, 0.9839, 0.9885, 0.9908, 0.9940, 0.9947],
[0.9396, 0.9562, 0.9710, 0.9785, 0.9838, 0.9884, 0.9908, 0.9940, 0.9947],
[0.9392, 0.9560, 0.9709, 0.9784, 0.9837, 0.9884, 0.9908, 0.9939, 0.9947],
[0.9388, 0.9557, 0.9707, 0.9783, 0.9836, 0.9883, 0.9907, 0.9939, 0.9947],
[0.9385, 0.9555, 0.9705, 0.9781, 0.9835, 0.9883, 0.9907, 0.9939, 0.9947],
[0.9381, 0.9552, 0.9704, 0.9780, 0.9834, 0.9882, 0.9907, 0.9939, 0.9947]]
Rd_values = [1E4, 2E4, 5E4, 1E5, 2E5, 5E5, 1E6, 5E6, 1E7]
betas = [i/100. for i in list(range(20, 51, 2)) + list(range(51, 81))]
def C_long_radius_nozzle(D, Do, Re_D):
beta = Do/D
return 0.9965 - 0.00653*beta**0.5*(1E6/Re_D)**0.5
for i in range(len(betas)):
Cs_expect = Cs[i]
beta = betas[i]
Cs_calc = [round(C_long_radius_nozzle(D=1, Do=beta, Re_D=i), 4) for i in Rd_values]
assert_close1d(Cs_expect, Cs_calc, atol=1E-4)
def test_HeatCapacityLiquid():
tol = HeatCapacityLiquid(CASRN='108-88-3', MW=92.13842, Tc=591.75, omega=0.257, Cpgm=115.30398669098454, similarity_variable=0.16279853724428964)
# Cpl_calc = []
# for i in tol.all_methods:
# tol.method = i
# Cpl_calc.append(tol.T_dependent_property(330))
tol.method = ROWLINSON_BONDI
assert_close(tol.T_dependent_property(330.0), 165.45542037912406, rtol=1e-10)
tol.method = ZABRANSKY_QUASIPOLYNOMIAL_C
assert_close(tol.T_dependent_property(330.0), 165.472878778683, rtol=1e-10)
tol.method = CRCSTD
assert_close(tol.T_dependent_property(330.0), 157.3, rtol=1e-10)
tol.method = ROWLINSON_POLING
assert_close(tol.T_dependent_property(330.0), 167.33806248209527, rtol=1e-10)
tol.method = POLING_CONST
assert_close(tol.T_dependent_property(330.0), 157.29, rtol=1e-10)
tol.method = ZABRANSKY_SPLINE_SAT
assert_close(tol.T_dependent_property(330.0), 166.69813077891135, rtol=1e-10)
tol.method = DADGOSTAR_SHAW
assert_close(tol.T_dependent_property(330.0), 175.34392562391267, rtol=1e-10)
tol.method = ZABRANSKY_SPLINE_C
assert_close(tol.T_dependent_property(330.0), 166.7156677848114, rtol=1e-10)
tol.method = VDI_TABULAR
assert_close(tol.T_dependent_property(330.0), 166.52477714085708, rtol=1e-10)
assert eval(str(tol)) == tol
new = HeatCapacityLiquid.from_json(tol.as_json())
assert new == tol
tol.extrapolation = None
for i in tol.all_methods:
tol.method = i
assert tol.T_dependent_property(2000) is None
with pytest.raises(Exception):
tol.test_method_validity('BADMETHOD', 300)
assert False == tol.test_property_validity(-1)
assert False == tol.test_property_validity(1.01E5)
assert True == tol.test_property_validity(100)
propylbenzene = HeatCapacityLiquid(MW=120.19158, CASRN='103-65-1', Tc=638.35)
Cpl_calc = []
for i in propylbenzene.all_methods:
propylbenzene.method = i
Cpl_calc.append(propylbenzene.T_dependent_property(298.15))
Cpls = [214.6499551694668, 214.69679325320664, 214.7, 214.71]
assert_close1d(sorted(Cpl_calc), sorted(Cpls))
new = HeatCapacityLiquid.from_json(propylbenzene.as_json())
assert new == propylbenzene
ctp = HeatCapacityLiquid(MW=118.58462, CASRN='96-43-5')
Cpl_calc = []
for i in ctp.all_methods:
ctp.method = i
Cpl_calc.append(ctp.T_dependent_property(250))
Cpls = [134.1186737739494, 134.1496585096233]
assert_close1d(sorted(Cpl_calc), sorted(Cpls))
new = HeatCapacityLiquid.from_json(ctp.as_json())
assert new == ctp
def test_EnthalpyVaporization():
EtOH = EnthalpyVaporization(Tb=351.39,
Tc=514.0,
Pc=6137000.0,
omega=0.635,
similarity_variable=0.1954,
Psat=7872.2,
Zg=0.9633,
Zl=0.0024,
CASRN='64-17-5')
EtOH.method = COOLPROP
assert_close(EtOH.T_dependent_property(305), 42062.9371631488)
EtOH.method = VDI_PPDS
assert_close(EtOH.T_dependent_property(305), 42099.23631527565)
EtOH.method = CLAPEYRON
assert_close(EtOH.T_dependent_property(305), 39904.512005771176)
EtOH.method = LIU
assert_close(EtOH.T_dependent_property(305), 40315.087291316195)
EtOH.method = ALIBAKHSHI
assert_close(EtOH.T_dependent_property(305), 39244.0137575973)
EtOH.method = MORGAN_KOBAYASHI
assert_close(EtOH.T_dependent_property(305), 42182.87752489718)
EtOH.method = VELASCO
assert_close(EtOH.T_dependent_property(305), 43056.23753606326)
EtOH.method = PITZER
assert_close(EtOH.T_dependent_property(305), 41716.88048400951)
EtOH.method = RIEDEL
assert_close(EtOH.T_dependent_property(305), 44258.89496024996)
EtOH.method = SIVARAMAN_MAGEE_KOBAYASHI
assert_close(EtOH.T_dependent_property(305), 42279.09568184713)
EtOH.method = CHEN
assert_close(EtOH.T_dependent_property(305), 42951.50714053451)
EtOH.method = CRC_HVAP_TB
assert_close(EtOH.T_dependent_property(305), 42423.58947282491)
EtOH.method = DIPPR_PERRY_8E
assert_close(EtOH.T_dependent_property(305), 42115.102057622214)
EtOH.method = VETERE
assert_close(EtOH.T_dependent_property(305), 41382.22039928848)
EtOH.method = CRC_HVAP_298
assert_close(EtOH.T_dependent_property(305), 41804.5417918726)
EtOH.method = VDI_TABULAR
assert_close(EtOH.T_dependent_property(305), 42119.6665416816)
EtOH.method = GHARAGHEIZI_HVAP_298
assert_close(EtOH.T_dependent_property(305), 41686.00339359697)
EtOH.extrapolation = None
for i in EtOH.all_methods:
EtOH.method = i
assert EtOH.T_dependent_property(5000) is None
EtOH = EnthalpyVaporization(CASRN='64-17-5', Tc=514.0)
Hvap_calc = []
for i in [
'GHARAGHEIZI_HVAP_298', 'CRC_HVAP_298', 'VDI_TABULAR', 'COOLPROP'
]:
EtOH.method = i
Hvap_calc.append(EtOH.T_dependent_property(310.0))
Hvap_exp = [
41304.19234346344, 41421.6450231131, 41857.962450207546,
41796.56243049473
]
assert_close1d(Hvap_calc, Hvap_exp)
# Test Clapeyron, without Zl
EtOH = EnthalpyVaporization(Tb=351.39,
Tc=514.0,
Pc=6137000.0,
omega=0.635,
similarity_variable=0.1954,
Psat=7872.2,
Zg=0.9633,
CASRN='64-17-5')
assert_close(EtOH.calculate(298.15, 'CLAPEYRON'), 37864.70507798813)
EtOH = EnthalpyVaporization(Tb=351.39,
Pc=6137000.0,
omega=0.635,
similarity_variable=0.1954,
Psat=7872.2,
Zg=0.9633,
CASRN='64-17-5')
assert EtOH.test_method_validity(351.39, 'CRC_HVAP_TB')
assert not EtOH.test_method_validity(351.39 + 10, 'CRC_HVAP_TB')
assert not EtOH.test_method_validity(351.39, 'CRC_HVAP_298')
Ts = [200, 250, 300, 400, 450]
props = [
46461.62768429649, 44543.08561867195, 42320.381894706225,
34627.726535926406, 27634.46144486471
]
EtOH.add_tabular_data(Ts=Ts, properties=props, name='CPdata')
EtOH.forced = True
assert_close(43499.47575887933, EtOH.T_dependent_property(275), rtol=1E-4)
EtOH.tabular_extrapolation_permitted = False
assert None == EtOH.T_dependent_property(5000)
with pytest.raises(Exception):
EtOH.test_method_validity('BADMETHOD', 300)
def test_cbrt_imag_dd():
ans = cbrt_imag_dd(2.718281828459045, 1.4456468917292502e-16, 3.141592653589793, 1.2246467991473532e-16)
assert_close1d(ans, (1.5423370526780396, 8.764992916723807e-17, 0.45326965450036827, 2.105896617565284e-17), rtol=1e-14)
def test_cbrt_dd():
ans = cbrt_dd(3, 0.0)
assert_close1d(ans, (1.4422495703074083, 8.054912676113696e-17), rtol=1e-13)
ans = cbrt_dd(1.4422495703074083, 8.054912676113696e-17)
assert_close1d(ans, (1.129830963909753, 1.601807086137469e-17), rtol=1e-13)
def test_div_imag_dd():
ans = div_imag_dd(2.718281828459045, 1.4456468917292502e-16, 3.141592653589793, 1.2246467991473532e-16,
3.141592653589793, 1.2246467991473532e-16, 2.718281828459045, 1.4456468917292502e-16)
assert_close1d(ans, (0.9896172675351794, -2.57625629153772e-17, 0.14372774191576643, 1.174077497180584e-17), rtol=1e-13)
def test_imag_inv_dd():
ans = imag_inv_dd(2.718281828459045, 1.4456468917292502e-16, 3.141592653589793, 1.2246467991473532e-16)
assert_close1d(ans, (0.15750247989731844, -3.9415361951446925e-18, -0.18202992367722576, -5.408691854671257e-18), rtol=1e-13)
def test_add_imag_dd():
ans = add_imag_dd(2.718281828459045, 1.4456468917292502e-16, 3.141592653589793, 1.2246467991473532e-16,
3.141592653589793, 1.2246467991473532e-16, 2.718281828459045, 1.4456468917292502e-16)
assert_close1d(ans, (5.859874482048839, -1.770598407624023e-16, 5.859874482048839, -1.770598407624023e-16))
def test_sqrt_imag_dd():
ans = sqrt_imag_dd(2.718281828459045, 1.4456468917292502e-16, 3.141592653589793, 1.2246467991473532e-16)
assert_close1d(ans, (1.853730863795006, 1.8197550334075816e-17, 0.8473702183385572, 4.942630438677856e-17))
ans = sqrt_imag_dd(2.718281828459045, 1.4456468917292502e-16, 0, 0)
assert_close1d(ans, (1.6487212707001282, -4.731568479435833e-17, 0.0, 0.0))
def test_mul_imag_noerrors_dd():
ans = mul_imag_noerrors_dd(1.11, .027, -1.2, .2995)
assert_close1d(ans, (-1.3400865, -1.0926552718171222e-16, 0.300045, 1.1863843241144421e-17), rtol=1e-14)
def test_square_dd():
ans = square_dd(2.718281828459045, 1.4456468917292502e-16)
assert_close1d(ans, (7.38905609893065, -1.7971139497839148e-16), rtol=1e-13)
def test_cube_dd():
ans = cube_dd(2.718281828459045, 1.4456468917292502e-16)
assert_close1d(ans, (20.085536923187668, -1.8275625525512858e-16), rtol=1e-14)
def check_np_output_activity(model, modelnp, modelnp2):
# model is flat, scalar, list-based model
# modelnp is numba model
# modelnp2 is created from the numba model with to_T_xs at a different composition
scalar_attrs = ['d3GE_dT3', 'd2GE_dT2', 'GE', 'dGE_dT']
for attr in scalar_attrs:
if hasattr(model, attr):
# print(attr)
assert_close(getattr(model, attr)(),
getattr(modelnp, attr)(),
rtol=2e-13)
assert_close(getattr(modelnp2, attr)(),
getattr(modelnp, attr)(),
rtol=2e-13)
assert type(getattr(model, attr)()) is float
# assert type(getattr(modelnp, attr)()) is float
# assert type(getattr(modelnp2, attr)()) is float
vec_attrs = [
'dGE_dxs', 'gammas', '_gammas_dGE_dxs', 'd2GE_dTdxs', 'dHE_dxs',
'gammas_infinite_dilution', 'dHE_dns', 'dnHE_dns', 'dSE_dxs',
'dSE_dns', 'dnSE_dns', 'dGE_dns', 'dnGE_dns', 'd2GE_dTdns',
'd2nGE_dTdns', 'dgammas_dT'
]
for attr in vec_attrs:
# print(attr)
assert_close1d(getattr(model, attr)(),
getattr(modelnp, attr)(),
rtol=2e-13)
assert_close1d(getattr(modelnp2, attr)(),
getattr(modelnp, attr)(),
rtol=2e-13)
assert type(getattr(model, attr)()) is list
assert type(getattr(modelnp, attr)()) is np.ndarray
assert type(getattr(modelnp2, attr)()) is np.ndarray
mat_attrs = ['d2GE_dxixjs', 'd2nGE_dninjs', 'dgammas_dns']
for attr in mat_attrs:
# print(attr)
assert_close2d(getattr(model, attr)(),
getattr(modelnp, attr)(),
rtol=1e-12)
assert_close2d(getattr(modelnp2, attr)(),
getattr(modelnp, attr)(),
rtol=1e-12)
assert type(getattr(model, attr)()) is list
assert type(getattr(modelnp, attr)()) is np.ndarray
assert type(getattr(modelnp2, attr)()) is np.ndarray
attrs_3d = ['d3GE_dxixjxks']
for attr in attrs_3d:
if hasattr(model, attr):
# print(attr)
# some models do not have this implemented
assert_close3d(getattr(model, attr)(),
getattr(modelnp, attr)(),
rtol=1e-13)
assert_close3d(getattr(modelnp2, attr)(),
getattr(modelnp, attr)(),
rtol=1e-13)
assert type(getattr(model, attr)()) is list
assert type(getattr(modelnp, attr)()) is np.ndarray
assert type(getattr(modelnp2, attr)()) is np.ndarray
def test_div_imag_dd():
mp_ans = (-6221711.561975023 - 2.5074521914349666e-10j)/(1247.1686953729213 +2160.157819988352j)
ans = div_imag_dd(-6221711.561975023, 0.0, - 2.5074521914349666e-10, 0.0,
1247.1686953729213, 0.0, 2160.157819988352, 0.0)
assert_close1d(ans, (-1247.168695372921, -7.085386715133776e-14, 2160.1578199883515, -1.7404258749820416e-14), rtol=1e-13)
def test_friction_factor_curved():
fd = friction_factor_curved(2E4, 0.01, .02)
assert_close(fd, 0.050134646621603024)
fd = friction_factor_curved(250, .02, .1)
assert_close(fd, 0.47460725672835236)
fd_transition = [
friction_factor_curved(i, 0.01, .02) for i in [16779, 16780]
]
assert_close1d(fd_transition, [0.03323676794260526, 0.057221855744623344])
with pytest.raises(Exception):
friction_factor_curved(16779, 0.01, .02, Method='BADMETHOD')
with pytest.raises(Exception):
friction_factor_curved(16779, 0.01, .02, Rec_method='BADMETHOD')
fd_rough_false = friction_factor_curved(20000,
0.01,
.02,
roughness=.0001,
turbulent_method='Guo')
assert_close(fd_rough_false, 0.1014240343662085)
methods = friction_factor_curved(20000, 0.01, .02, AvailableMethods=True)
assert sorted(methods) == sorted([
'Guo', 'Ju', 'Schmidt turbulent', 'Prasad', 'Mandel Nigam',
'Mori Nakayama turbulent', 'Czop', 'Srinivasan turbulent'
])
methods = friction_factor_curved(2000, 0.01, .02, AvailableMethods=True)
assert sorted(methods) == sorted(
['White', 'Schmidt laminar', 'Mori Nakayama laminar'])
methods = friction_factor_curved_methods(20000,
0.01,
.02,
check_ranges=True)
assert sorted(methods) == sorted([
'Guo', 'Ju', 'Schmidt turbulent', 'Prasad', 'Mandel Nigam',
'Mori Nakayama turbulent', 'Czop', 'Srinivasan turbulent'
])
methods = friction_factor_curved_methods(2000,
0.01,
.02,
check_ranges=True)
assert sorted(methods) == sorted(
['White', 'Schmidt laminar', 'Mori Nakayama laminar'])
assert 'Schmidt turbulent' in friction_factor_curved_methods(Re=1E5,
Di=0.02,
Dc=0.5)
assert 11 == len(
friction_factor_curved_methods(Re=1E5,
Di=0.02,
Dc=0.5,
check_ranges=False))
for m in friction_factor_curved_methods(Re=1E5,
Di=0.02,
Dc=0.5,
check_ranges=False):
friction_factor_curved(2000, 0.01, .02, Method=m)
# Test the Fanning case
fd = friction_factor_curved(2E4, 0.01, .02, Darcy=False)
assert_close(fd, 0.012533661655400756)
for m in [
'Seth Stahel', 'Ito', 'Kubair Kuloor', 'Kutateladze Borishanskii',
'Schmidt', 'Srinivasan'
]:
helical_Re_crit(Di=0.02, Dc=0.5, Method=m)
def test_add_dd():
ans = add_dd(2.718281828459045, 1.4456468917292502e-16, -3.141592653589793, -1.2246467991473532e-16)
assert_close1d(ans, (-0.423310825130748, 2.2100009258189695e-17), rtol=1e-13)
def test_k_IAPWS():
rhos = [1., 122., 222., 272., 322., 372., 422., 750.]
Cps = [
2069.0812064568445, 11353.470032452065, 101243.30196479718,
794916.0384979197, 5420611.2721776245, 500237.6519254826,
62663.67284339393, 4570.624565173062
]
Cvs = [
1595.69907291979, 3243.791325724295, 4523.436913569467,
5491.264195750903, 6188.749461187972, 5181.406642440796,
3904.379773638152, 2833.6557941038973
]
mus = [
2.3377752122053447e-05, 2.5520676836476175e-05, 3.133758919727549e-05,
3.622814313612717e-05, 4.296157881024315e-05, 4.5688204474708324e-05,
4.943625601494995e-05, 9.401498317589303e-05
]
d_rho_d_Ps = [
3.3774067394654917e-06, 1.710930848910942e-05, 0.000175456980972237,
0.0015082800389184703, 0.012136419490369314, 0.0012459172043680759,
0.00013039353796524478, 1.0510776327652118e-06
]
k_CP = [
0.05192989239188059, 0.13092288520449896, 0.3677874588628728,
0.7579597763651718, 1.4437555614266426, 0.6503194015489409,
0.4488834872838822, 0.6009613455848507
]
k_calc = [
k_IAPWS(T=647.35,
rho=rhos[i],
Cp=Cps[i],
Cv=Cvs[i],
mu=mus[i],
drho_dP=d_rho_d_Ps[i]) for i in range(len(rhos))
]
assert_close1d(k_calc, k_CP, rtol=5e-6)
# Region 1, test 2, from IAPWS formulation, exact match:
k = k_IAPWS(T=620.,
rho=699.226043,
Cp=5320.47725,
Cv=2916.92653,
mu=84.1527945E-6,
drho_dP=1.84869007E-6)
assert_close(k, 0.5450389394624772, rtol=1e-13)
# Region 2, test 1, from IAPWS formulation, exact match:
k = k_IAPWS(T=650.,
rho=1.00452141,
Cp=2070.10035,
Cv=1596.75313,
mu=23.4877453E-6,
drho_dP=3.36351419E-6)
assert_close(k, 0.052231102436372065, rtol=1e-13)
# Region 3, test 1, from IAPWS formulation, exact match:
k = k_IAPWS(T=647.35,
rho=222.,
Cp=101054.488,
Cv=4374.66458,
mu=31.2204749E-6,
drho_dP=177.778595E-6)
assert_close(k, 0.36687941154060383, rtol=1e-13)
# Feed P: 8600000.0
# Case where zero division was occuring
kwargs = {
'T': 400,
'rho': 941.720097520186,
'Cp': 4233.740244740559,
'Cv': 3622.5838143014544,
'mu': 0.00022080449914642125,
'drho_dP': 4.996396679875349e-07,
'drho_dP_Tr': 2.3158445867118744e-07
}
assert_close(k_IAPWS(**kwargs), .688018419964361, rtol=1e-11)
def test_mul_dd_mp():
ans = mul_dd(2.718281828459045, 1.4456468917292502e-16, 3.141592653589793, 1.2246467991473532e-16)
assert_close1d(ans, (8.539734222673568, -6.773815290502423e-16), rtol=1e-13)
assert abs(mp.e*mp.pi - (mp.mpf(ans[0]) + mp.mpf(ans[1]))) < 1e-30
def test_ThermalConductivityLiquid():
EtOH = ThermalConductivityLiquid(CASRN='64-17-5',
MW=46.06844,
Tm=159.05,
Tb=351.39,
Tc=514.0,
Pc=6137000.0,
omega=0.635,
Hfus=4931.0)
EtOH.T_dependent_property(305.)
all_methods = EtOH.all_methods
methods = list(all_methods)
methods.remove(VDI_TABULAR)
kl_calcs = []
for i in methods:
EtOH.method = i
kl_calcs.append(EtOH.T_dependent_property(305.))
kl_exp = [
0.162183005823234, 0.16627999999999998, 0.166302, 0.20068212675966418,
0.18526367184633258, 0.18846433785041306, 0.16837295487233528,
0.16883011582627103, 0.09330268101157643, 0.028604363267557775
]
assert_close1d(sorted(kl_calcs), sorted(kl_exp))
assert_close(EtOH.calculate(305., VDI_TABULAR),
0.17417420086033197,
rtol=1E-4)
# Test that methods return None
EtOH.extrapolation = None
kl_calcs = []
for i in all_methods:
EtOH.method = i
kl_calcs.append(EtOH.T_dependent_property(5000))
assert [None] * 11 == kl_calcs
EtOH.method = VDI_TABULAR
EtOH.extrapolation = 'interp1d'
assert_close(EtOH.T_dependent_property(600.), 0.040117737789202995)
EtOH.extrapolation = None
assert None == EtOH.T_dependent_property(600.)
with pytest.raises(Exception):
EtOH.test_method_validity(300, 'BADMETHOD')
assert ThermalConductivityLiquid.from_JSON(EtOH.as_JSON()) == EtOH
# Ethanol compressed
assert [False, True] == [
EtOH.test_method_validity_P(300, P, COOLPROP) for P in (1E3, 1E5)
]
assert [True, True] == [
EtOH.test_method_validity_P(300, P, DIPPR_9G) for P in (1E3, 1E5)
]
assert [True, True, False] == [
EtOH.test_method_validity_P(300, P, MISSENARD)
for P in (1E3, 1E5, 1E10)
]
EtOH = ThermalConductivityLiquid(CASRN='64-17-5',
MW=46.06844,
Tm=159.05,
Tb=351.39,
Tc=514.0,
Pc=6137000.0,
omega=0.635,
Hfus=4931.0)
assert_close(EtOH.calculate_P(298.15, 1E6, COOLPROP), 0.1639626989794703)
assert_close(EtOH.calculate_P(298.15, 1E6, DIPPR_9G), 0.1606146938795702)
assert_close(EtOH.calculate_P(298.15, 1E6, MISSENARD), 0.1641582259181843)
# Ethanol data, calculated from CoolProp
Ts = [275, 300, 350]
Ps = [1E5, 5E5, 1E6]
TP_data = [[0.16848555706973622, 0.16313525757474362, 0.15458068887966378],
[0.16868861153075654, 0.163343255114212, 0.1548036152853355],
[0.16894182645698885, 0.1636025336196736, 0.15508116339039268]]
EtOH.add_tabular_data_P(Ts, Ps, TP_data, name='CPdata')
recalc_pts = [[EtOH.TP_dependent_property(T, P) for T in Ts] for P in Ps]
assert_close1d(TP_data, recalc_pts)
EtOH.forced_P = True
assert_allclose(EtOH.TP_dependent_property(274, 9E4), 0.16848555706973622)
EtOH.tabular_extrapolation_permitted = False
assert None == EtOH.TP_dependent_property(300, 9E4)
with pytest.raises(Exception):
EtOH.test_method_validity_P(300, 1E5, 'BADMETHOD')
assert False == EtOH.test_method_validity_P(-10, 1E5, DIPPR_9G)
assert ThermalConductivityLiquid.from_JSON(EtOH.as_JSON()) == EtOH
def test_div_dd():
ans = div_dd(2.718281828459045, 1.4456468917292502e-16, 3.141592653589793, 1.2246467991473532e-16)
assert_close1d(ans, (0.8652559794322651, 2.1741459631779752e-17), rtol=1e-13)
def test_C_venturi_nozzle_full():
# Many values do not match well, but the equation has been checked with both standards.
betas = [0.32, 0.32, 0.33, 0.34, 0.35, 0.36, 0.37, 0.38, 0.39, 0.40, 0.41, 0.42, 0.43, 0.44, 0.45, 0.46, 0.47, 0.48, 0.49, 0.50, 0.51, 0.52, 0.53, 0.54, 0.55, 0.56, 0.57, 0.58, 0.59, 0.60, 0.61, 0.62, 0.63, 0.64, 0.65, 0.66, 0.67, 0.68, 0.69, 0.70, 0.71, 0.72, 0.73, 0.74, 0.75, 0.76, 0.77, 0.78]
Cs = [0.9847, 0.9846, 0.9845, 0.9843, 0.9841, 0.9838, 0.9836, 0.9833, 0.9830, 0.9826, 0.9823, 0.9818, 0.9814, 0.9809, 0.9804, 0.9798, 0.9792, 0.9786, 0.9779, 0.9771, 0.9763, 0.9755, 0.9745, 0.9736, 0.9725, 0.9714, 0.9702, 0.9689, 0.9676, 0.9661, 0.9646, 0.9630, 0.9613, 0.9595, 0.9576, 0.9556, 0.9535, 0.9512, 0.9489, 0.9464, 0.9438, 0.9411, 0.9382, 0.9352, 0.9321, 0.9288, 0.9253, 0.9236]
Cs_calc = [C_venturi_nozzle(D=1, Do=beta) for beta in betas]
assert_close1d(Cs, Cs_calc, rtol=5E-3)
def test_sqrt_dd():
ans = sqrt_dd(2.718281828459045, 1.4456468917292502e-16)
assert_close1d(ans, (1.6487212707001282, -4.731568479435833e-17), rtol=1e-13)
def test_Tandon_Varma_Gupta():
alphas_calc = [Tandon_Varma_Gupta(.4, 800, 2.5, 1E-3, 1E-5, m, 0.3) for m in [1, .1]]
assert_close1d(alphas_calc, [0.9228265670341428, 0.8799794756817589])
def test_mul_noerrors_dd():
ans = mul_noerrors_dd(2.718281828, 3.1415926)
assert_close1d(ans, (8.539734075559272, 6.111502792870851e-16), rtol=1e-13)
assert_close1d(ans, mul_dd(2.718281828, 0.0, 3.1415926, 0.0), rtol=1e-13)
def test_LMTD_vect():
dTlms = [ht.LMTD(T, 60., 30., 40.2) for T in [100, 101]]
dTlms_vect = ht.vectorized.LMTD([100, 101], 60., 30., 40.2)
assert_close1d(dTlms, dTlms_vect)
def test_water_ethanol_methanol_madeup():
alphas = [[[0.0, 2e-05], [0.2937, 7e-05], [0.2999, 0.0001]],
[[0.2937, 1e-05], [0.0, 4e-05], [0.3009, 8e-05]],
[[0.2999, 1e-05], [0.3009, 3e-05], [0.0, 5e-05]]]
taus = [[[6e-05, 0.0, 7e-05, 7e-05, 0.00788, 3.6e-07],
[3e-05, 624.868, 9e-05, 7e-05, 0.00472, 8.5e-07],
[3e-05, 398.953, 4e-05, 1e-05, 0.00279, 5.6e-07]],
[[1e-05, -29.167, 8e-05, 9e-05, 0.00256, 1e-07],
[2e-05, 0.0, 7e-05, 6e-05, 0.00587, 4.2e-07],
[0.0, -35.482, 8e-05, 4e-05, 0.00889, 8.2e-07]],
[[9e-05, -95.132, 6e-05, 1e-05, 0.00905, 5.2e-07],
[9e-05, 33.862, 2e-05, 6e-05, 0.00517, 1.4e-07],
[0.0001, 0.0, 6e-05, 2e-05, 0.00095, 7.4e-07]]]
N = 3
T = 273.15 + 70
dT = T * 1e-8
xs = [.2, .3, .5]
GE = NRTL(T, xs, taus, alphas)
assert eval(str(GE)).GE() == GE.GE()
assert NRTL.from_JSON(GE.as_JSON()).__dict__ == GE.__dict__
# gammas
assert_close1d(
GE.gammas(),
[1.7795902383749216, 1.1495597830749005, 1.0736702352016942])
### Tau and derivatives
taus_expected = [
[0.06687993075720595, 1.9456413587531054, 1.2322559725492486],
[-0.04186204696272491, 0.07047352903742096, 0.007348860249786843],
[-0.21212866478360642, 0.13596095401379812, 0.0944497207779701]
]
assert_close2d(taus_expected, GE.taus(), rtol=1e-14)
# Tau temperature derivative
dtaus_dT_numerical = (np.array(GE.to_T_xs(T + dT, xs).taus()) -
GE.taus()) / dT
dtaus_dT_analytical = GE.dtaus_dT()
dtaus_dT_expected = [[
0.000317271602387579, -0.004653030923421638, -0.0029936361350323625
], [0.000406561723402744, 0.00034844970187634483, 0.0009043271077256468],
[
0.0011749522864265571, -0.00013143064874333648,
0.0005280368036263511
]]
assert_close2d(dtaus_dT_analytical, dtaus_dT_expected, rtol=1e-12)
assert_close2d(dtaus_dT_numerical, dtaus_dT_analytical, rtol=4e-7)
# tau second derivative
d2taus_dT2_analytical = GE.d2taus_dT2()
d2taus_dT2_expected = [[
7.194089397742681e-07, 3.2628265646047626e-05, 2.0866597625703075e-05
], [
-1.2443543228779117e-06, 8.394080699905074e-07, -1.169244972344292e-07
], [-3.669244570181493e-06, 1.955896362917401e-06, 1.4794908652710361e-06]]
assert_close2d(d2taus_dT2_analytical, d2taus_dT2_expected, rtol=1e-12)
d2taus_dT2_numerical = (np.array(GE.to_T_xs(T + dT, xs).dtaus_dT()) -
GE.dtaus_dT()) / dT
assert_close2d(d2taus_dT2_analytical, d2taus_dT2_numerical, rtol=4e-7)
# tau third derivative
d3taus_dT3_analytical = GE.d3taus_dT3()
d3taus_dT3_expected = [[
3.425034691577827e-12, -2.703935984244539e-07, -1.7263626338812435e-07
], [1.2625331389834536e-08, 3.4351735085462344e-12, 1.535797829031479e-08],
[
4.116922701015044e-08, -1.4652079774338131e-08,
2.9650219270685846e-12
]]
# Not sure why precision of numerical test is so low, but confirmed with sympy.
assert_close2d(d3taus_dT3_analytical, d3taus_dT3_expected, rtol=1e-12)
d3taus_dT3_numerical = (np.array(GE.to_T_xs(T + dT, xs).d2taus_dT2()) -
GE.d2taus_dT2()) / dT
assert_close2d(d3taus_dT3_numerical, d3taus_dT3_analytical, rtol=2e-5)
# alphas
alphas_expect = [[0.006863, 0.3177205, 0.334215],
[0.2971315, 0.013726, 0.328352],
[0.3033315, 0.3111945, 0.0171575]]
assert_close2d(alphas_expect, GE.alphas(), rtol=1e-12)
# dalphas_dT
dalphas_dT_expect = [[2e-05, 7e-05, 0.0001], [1e-05, 4e-05, 8e-05],
[1e-05, 3e-05, 5e-05]]
dalphas_dT_analytical = GE.dalphas_dT()
assert_close2d(dalphas_dT_expect, dalphas_dT_analytical, rtol=1e-12)
dalphas_dT_numerical = (np.array(GE.to_T_xs(T + 1e-4, xs).alphas()) -
GE.alphas()) / 1e-4
assert_close2d(dalphas_dT_expect, dalphas_dT_numerical)
# d2alphas_d2T
d2alphas_d2T_numerical = (np.array(GE.to_T_xs(T + dT, xs).dalphas_dT()) -
GE.dalphas_dT()) / dT
d2alphas_d2T_analytical = GE.d2alphas_dT2()
assert_close2d(d2alphas_d2T_analytical, [[0] * N for _ in range(N)])
assert_close2d(d2alphas_d2T_numerical, d2alphas_d2T_analytical, rtol=1e-12)
# d3alphas_d3T
d3alphas_d3T_numerical = (np.array(GE.to_T_xs(T + dT, xs).d2alphas_dT2()) -
GE.d2alphas_dT2()) / dT
d3alphas_d3T_analytical = GE.d3alphas_dT3()
assert_close2d(d3alphas_d3T_analytical, [[0] * N for _ in range(N)])
assert_close2d(d3alphas_d3T_numerical, d3alphas_d3T_analytical, rtol=1e-12)
# Gs
Gs_expect = [[0.9995411083582052, 0.5389296989069797, 0.6624312965198783],
[1.0125162130984628, 0.999033148043276, 0.9975898960147673],
[1.0664605905163351, 0.9585722883795924, 0.9983807912510595]]
assert_close2d(Gs_expect, GE.Gs())
# dGs_dT
dGs_dT_expect = [[
-3.513420602780159e-06, 0.0007233344205287423, 0.000581146010596799
],
[
-0.00012189042196807427, -7.594411991210204e-06,
-0.00029680845584651057
],
[
-0.000377824327942326, 3.529622902294454e-05,
-1.3759961112813966e-05
]]
dGs_dT_analytical = GE.dGs_dT()
assert_close2d(dGs_dT_expect, dGs_dT_analytical, rtol=1e-12)
dGs_dT_numerical = (np.array(GE.to_T_xs(T + 2.5e-5, xs).Gs()) -
GE.Gs()) / 2.5e-5
assert_close2d(dGs_dT_numerical, dGs_dT_expect,
rtol=3e-7) # Closest I could get
# d2Gs_dT2
d2Gs_dT2_expect = [[
-1.7607728438831442e-08, -4.264997204215131e-06,
-3.7132987505208185e-06
], [
3.808051820202208e-07, -3.9301868673119065e-08, -1.773565965539868e-08
], [1.2957622532360591e-06, -5.745898135094948e-07, -7.78717985147786e-08]]
d2Gs_dT2_analytical = GE.d2Gs_dT2()
assert_close2d(d2Gs_dT2_expect, d2Gs_dT2_analytical, rtol=1e-12)
d2Gs_dT2_numerical = (np.array(GE.to_T_xs(T + 4e-6, xs).dGs_dT()) -
GE.dGs_dT()) / 4e-6
assert_close2d(d2Gs_dT2_numerical, d2Gs_dT2_analytical, rtol=2e-6)
# d3Gs_dT3
d3Gs_dT3_analytical = GE.d3Gs_dT3()
d3Gs_dT3_expect = [[
-4.298246167557067e-11, 2.282743128709054e-08, 2.3406412447900822e-08
], [
-3.894534156411875e-09, -9.978151596051988e-11, -4.934296656436311e-09
], [
-1.448282405010784e-08, 4.1384450135276364e-09, -2.1839009944794027e-10
]]
d3Gs_dT3_numerical = (np.array(GE.to_T_xs(T + dT, xs).d2Gs_dT2()) -
GE.d2Gs_dT2()) / dT
assert_close2d(d3Gs_dT3_analytical, d3Gs_dT3_numerical, rtol=1e-7)
assert_close2d(d3Gs_dT3_expect, d3Gs_dT3_analytical, rtol=1e-12)
# dGE_dT
dGE_dT_expect = 2.258093406765717
dGE_dT_analytical = GE.dGE_dT()
assert_close(dGE_dT_expect, dGE_dT_analytical, rtol=1e-12)
def to_diff(T):
return GE.to_T_xs(T, xs).GE()
dGE_dT_numerical = derivative(to_diff, T, dx=1, order=17)
assert_close(dGE_dT_analytical, dGE_dT_numerical, rtol=1e-12)
# d2GE_dT2
def to_diff(T):
return GE.to_T_xs(T, xs).dGE_dT()
d2GE_dT2_numerical = derivative(to_diff, T, dx=5, order=17)
d2GE_dT2_expected = 0.007412479461681191
d2GE_dT2_analytical = GE.d2GE_dT2()
assert_close(d2GE_dT2_expected, d2GE_dT2_analytical, rtol=1e-12)
assert_close(d2GE_dT2_numerical, d2GE_dT2_analytical, rtol=1e-12)
# dGE_dxs
def to_jac(xs):
return GE.to_T_xs(T, xs).GE()
dGE_dxs_analytical = GE.dGE_dxs()
dGE_dxs_expected = [
1644.4832445701338, 397.6635234141318, 202.8071951151063
]
assert_close1d(dGE_dxs_analytical, dGE_dxs_expected, rtol=1e-12)
dGE_dxs_numerical = jacobian(to_jac, xs, perturbation=1e-8)
assert_close1d(dGE_dxs_numerical, dGE_dxs_expected, rtol=1e-7)
# d2GE_dxixjs - more decimals in numdifftools
def to_hess(xs):
return GE.to_T_xs(T, xs).GE()
d2GE_dxixjs_expect = [
[-1690.7876619180952, 1208.6126803238276, -48.852543427058286],
[1208.6126803238276, -468.99032836115686, -202.0508751128366],
[-48.852543427058606, -202.0508751128365, 140.77154243852513]
]
d2GE_dxixjs_analytical = GE.d2GE_dxixjs()
assert_close2d(d2GE_dxixjs_expect, d2GE_dxixjs_analytical, rtol=1e-12)
d2GE_dxixjs_numerical = hessian(to_hess, xs, perturbation=5e-5)
assert_close2d(d2GE_dxixjs_numerical, d2GE_dxixjs_analytical, rtol=3e-4)
# d2GE_dTdxs - matched really well
d2GE_dTdxs_expect = [
3.053720836458414, 1.8759446742883084, 2.1691316743750826
]
d2GE_dTdxs_analytical = GE.d2GE_dTdxs()
assert_close1d(d2GE_dTdxs_expect, d2GE_dTdxs_analytical, rtol=1e-12)
def to_jac(xs):
return GE.to_T_xs(T, xs).dGE_dT()
d2GE_dTdxs_numerical = jacobian(to_jac, xs, perturbation=3e-8)
assert_close1d(d2GE_dTdxs_analytical, d2GE_dTdxs_numerical, rtol=1e-7)