def test_atom_matrix():
atomss = [{
'C': 1,
'H': 4
}, {
'C': 2,
'H': 6
}, {
'N': 2
}, {
'O': 2
}, {
'H': 2,
'O': 1
}, {
'C': 1,
'O': 2
}]
OCH_expect = [[0.0, 1, 4], [0.0, 2, 6], [0.0, 0.0, 0.0], [2, 0.0, 0.0],
[1, 0.0, 2], [2, 1, 0.0]]
default_expect = [[4, 1, 0.0, 0.0], [6, 2, 0.0, 0.0], [0.0, 0.0, 2, 0.0],
[0.0, 0.0, 0.0, 2], [2, 0.0, 0.0, 1], [0.0, 1, 0.0, 2]]
default = atom_matrix(atomss)
assert_close2d(default, default_expect, rtol=1e-12)
OCH = atom_matrix(atomss, ['O', 'C', 'H'])
assert_close2d(OCH, OCH_expect, rtol=1e-12)
def test_d2ns_to_dn2_partials():
d2ns = [[0.152, 0.08, 0.547], [0.08, 0.674, 0.729], [0.547, 0.729, 0.131]]
res = d2ns_to_dn2_partials(d2ns, [20.0, .124, 900.52])
res_expect = [[40.152, 20.203999999999997, 921.067],
[20.204, 0.922, 901.3729999999999],
[921.067, 901.373, 1801.1709999999998]]
assert_close2d(res, res_expect)
def test_regular_solution_gammas_binaries_jac():
kwargs = dict(xs=[.1, .9, 0.3, 0.7, .85, .15],
Vs=[7.421e-05, 8.068e-05],
SPs=[19570.2, 18864.7],
Ts=[300.0, 400.0, 500.0],
lambda12=0.1759,
lambda21=0.7991)
res = regular_solution_gammas_binaries_jac(**kwargs)
res_expect = [[61651.76714001304, 61651.76714001304],
[0.1134949564269304, 0.1134949564269304],
[265.5654802072593, 265.5654802072593],
[1.4404516377618741, 1.4404516377618741],
[0.20175156664075444, 0.20175156664075444],
[694.1461546179326, 694.1461546179326]]
assert_close2d(res, res_expect, rtol=1e-13)
for i in range(len(res)):
for j in range(len(res[i])):
res[i][j] = -1e100
jac = res
res = regular_solution_gammas_binaries_jac(jac=res, **kwargs)
assert res is jac
assert_close2d(res, res_expect, rtol=1e-13)
'''
def test_air_cooler_Ft():
Ft_1 = Ft_aircooler(Thi=93, Tho=52, Tci=35, Tco=54.59, Ntp=2, rows=4)
assert_close(Ft_1, 0.9570456123827129)
# Example 2 as in [1]_; author rounds to obtain a slightly different result.
Ft_2 = Ft_aircooler(Thi=125., Tho=45., Tci=25., Tco=95., Ntp=1, rows=4)
assert_close(Ft_2, 0.5505093604092708)
Ft_many = [[
Ft_aircooler(Thi=125., Tho=80., Tci=25., Tco=95., Ntp=i, rows=j)
for i in range(1, 6)
] for j in range(1, 6)]
Ft_values = [[
0.6349871996666123, 0.9392743008890244, 0.9392743008890244,
0.9392743008890244, 0.9392743008890244
],
[
0.7993839562360742, 0.9184594715750571,
0.9392743008890244, 0.9392743008890244, 0.9392743008890244
],
[
0.8201055328279105, 0.9392743008890244,
0.9784008071402877, 0.9392743008890244, 0.9392743008890244
],
[
0.8276966706732202, 0.9392743008890244,
0.9392743008890244, 0.9828365967034366, 0.9392743008890244
],
[
0.8276966706732202, 0.9392743008890244,
0.9392743008890244, 0.9392743008890244, 0.9828365967034366
]]
assert_close2d(Ft_many, Ft_values)
def test_ViscosityGas():
EtOH = ViscosityGas(MW=46.06844,
Tc=514.0,
Pc=6137000.0,
Zc=0.2412,
dipole=1.44,
Vmg=0.02357,
CASRN='64-17-5')
EtOH.method = VDI_PPDS
assert_close(EtOH.T_dependent_property(305), 9.13079342291875e-06)
EtOH.method = YOON_THODOS
assert_close(EtOH.T_dependent_property(305), 7.584977640806432e-06)
EtOH.method = STIEL_THODOS
assert_close(EtOH.T_dependent_property(305), 7.699272212598415e-06)
EtOH.method = GHARAGHEIZI
assert_close(EtOH.T_dependent_property(305), 8.12922040122556e-06)
EtOH.method = LUCAS_GAS
assert_close(EtOH.T_dependent_property(305), 9.008160864895763e-06)
EtOH.method = VDI_TABULAR
assert_close(EtOH.T_dependent_property(305), 8.761390047621239e-06)
EtOH.method = DIPPR_PERRY_8E
assert_close(EtOH.T_dependent_property(305), 9.129674918795814e-06)
# Test that methods return None
EtOH.extrapolation = None
for i in EtOH.all_methods:
EtOH.method = i
assert EtOH.T_dependent_property(6000) is None
with pytest.raises(Exception):
EtOH.test_method_validity(300, 'BADMETHOD')
s = EtOH.as_json()
EtOH2 = ViscosityGas.from_json(s)
# Do hash checks before interpolation object exists
assert hash(EtOH) == hash(EtOH2)
assert EtOH == EtOH2
assert id(EtOH) != id(EtOH2)
# Ethanol data, calculated from CoolProp
Ts = [400, 500, 550]
Ps = [1E3, 1E4, 1E5]
TP_data = [[
1.18634700291489e-05, 1.4762189560203758e-05, 1.6162732753470533e-05
], [
1.1862505513959454e-05, 1.4762728590964208e-05, 1.6163602669178767e-05
], [1.1853229260926176e-05, 1.4768417536555742e-05, 1.617257402798515e-05]]
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_close2d(TP_data, recalc_pts)
EtOH.tabular_extrapolation_permitted = False
assert None == EtOH.TP_dependent_property(300, 9E4)
EtOH.tabular_extrapolation_permitted = True
assert_close(EtOH.TP_dependent_property(300, 9E4), 1.1854259955707653e-05)
with pytest.raises(Exception):
EtOH.test_method_validity_P(300, 1E5, 'BADMETHOD')
def assert_pint_allclose2d(value, magnitude, units, rtol=1e-7, atol=0):
assert_close2d(value.to_base_units().magnitude,
magnitude,
rtol=rtol,
atol=atol)
if type(units) != dict:
units = dict(units.dimensionality)
assert dict(value.dimensionality) == units
def test_Nu_vertical_cylinder_Carne_Morgan():
Nu_all = [[
Nu_vertical_cylinder_Carne_Morgan(i, 2E8, j)
for i in (0.999999, 1.000001)
] for j in (True, False, None)]
Nu_all_values = [[216.88764905616722, 216.88781389084312],
[225.77302655456344, 225.77315298749372],
[225.77302655456344, 216.88781389084312]]
assert_close2d(Nu_all, Nu_all_values)
def test_Nu_vertical_cylinder_Jakob_Linke_Morgan():
Nu_all = [[
Nu_vertical_cylinder_Jakob_Linke_Morgan(i, 1E8, j)
for i in (0.999999, 1.000001)
] for j in (True, False, None)]
Nu_all_values = [[59.87647599476619, 59.87651591243016],
[55.499986124994805, 55.5000138749948],
[55.499986124994805, 59.87651591243016]]
assert_close2d(Nu_all, Nu_all_values)
def test_Nu_vertical_cylinder_Griffiths_Davis_Morgan():
Nu_all = [[
Nu_vertical_cylinder_Griffiths_Davis_Morgan(i, 1E9, j)
for i in (0.999999, 1.000001)
] for j in (True, False, None)]
Nu_all_values = [[127.7046167347578, 127.7047079158867],
[119.14469068641654, 119.14475025877677],
[119.14469068641654, 127.7047079158867]]
assert_close2d(Nu_all, Nu_all_values)
def test_stoichiometric_matrix():
res = stoichiometric_matrix([{
'Mg': 1,
'O': 1
}, {
'Mg': 1
}, {
'O': 2
}], [True, False, False])
assert_close2d([[1, -1, 0], [1, 0, -2]], res)
def test_no_interactions():
GE = RegularSolution(T=325.0,
xs=[.25, .75],
Vs=[7.421e-05, 8.068e-05],
SPs=[19570.2, 18864.7])
assert_close2d(GE.lambda_coeffs, [[0, 0], [0, 0]], atol=0, rtol=0)
GE = RegularSolution(T=325.0,
xs=np.array([.25, .75]),
Vs=np.array([7.421e-05, 8.068e-05]),
SPs=np.array([19570.2, 18864.7]))
assert_close2d(GE.lambda_coeffs, [[0, 0], [0, 0]], atol=0, rtol=0)
assert type(GE.lambda_coeffs) is np.ndarray
def test_a_alpha_aijs_composition_independent():
kijs = [[0, .083], [0.083, 0]]
a_alphas = [0.2491099357671155, 0.6486495863528039]
a_alpha_ijs, a_alpha_roots, a_alpha_ij_roots_inv = a_alpha_aijs_composition_independent(
a_alphas, kijs)
assert_close2d(a_alpha_ijs, [[0.2491099357671155, 0.3686123937424334],
[0.3686123937424334, 0.6486495863528038]],
rtol=1e-13)
assert_close1d(a_alpha_roots, [0.4991091421393877, 0.8053878484015039],
rtol=1e-13)
assert_close1d(a_alpha_ij_roots_inv,
[[4.014291910599931, 2.4877079977965977],
[2.4877079977965977, 1.5416644379945614]],
rtol=1e-13)
def check_numba_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
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:
assert_close1d(getattr(model, attr)(),
getattr(modelnp, attr)(),
rtol=1e-13)
assert_close1d(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
mat_attrs = ['d2GE_dxixjs', 'd2nGE_dninjs', 'dgammas_dns']
for attr in mat_attrs:
assert_close2d(getattr(model, attr)(),
getattr(modelnp, attr)(),
rtol=1e-13)
assert_close2d(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
attrs_3d = ['d3GE_dxixjxks']
for attr in attrs_3d:
if hasattr(model, 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_K_separator_Watkins():
calc = [[
K_separator_Watkins(0.88, 985.4, 1.3, horizontal, method)
for method in ['spline', 'branan', 'blackwell']
] for horizontal in [False, True]]
expect = [[0.06361290880381038, 0.06108986837654085, 0.06994527471072351],
[0.07951613600476297, 0.07636233547067607, 0.0874315933884044]]
assert_close2d(calc, expect, rtol=1e-4)
with pytest.raises(Exception):
K_separator_Watkins(0.88,
985.4,
1.3,
horizontal=True,
method='BADMETHOD')
def test_PSDLognormal_cdf_orders():
# Test cdf of different orders a bunch
disc = PSDLognormal(s=0.5, d_characteristic=5E-6)
# 16 x 4 = 64 points
# had 1e-7 here too as a diameter but too many numerical issues, too sensitive to rounding
# errors
ds = [
2E-6, 3E-6, 4E-6, 5E-6, 6E-6, 7E-6, 1E-5, 2E-5, 3E-5, 5E-5, 7E-5, 1E-4,
2E-4, 4E-4, 1E-3
]
ans_expect = [
[
0.36972511868508068, 0.68379899882263917, 0.8539928088656249,
0.93319279873114203, 0.96888427729983861, 0.98510775165387254,
0.99805096305713792, 0.9999903391682271, 0.99999981474719135,
0.99999999948654394, 0.99999999999391231, 0.99999999999996592, 1.0,
1.0, 1.0
],
[
0.20254040832522924, 0.49136307673913149, 0.71011232639847854,
0.84134474606854293, 0.91381737643345484, 0.95283088619207579,
0.99149043874391107, 0.99991921875653167, 0.99999771392273817,
0.99999998959747816, 0.99999999982864851, 0.99999999999863987, 1.0,
1.0, 1.0000000000000002
],
[
0.091334595732478097, 0.30095658738958564, 0.52141804648990697,
0.69146246127401301, 0.80638264936531323, 0.87959096325267294,
0.9703723506333426, 0.999467162897961, 0.99997782059383122,
0.99999983475152954, 0.99999999622288382, 0.99999999995749711,
0.99999999999999833, 1.0000000000000002, 1.0000000000000002
],
[
0.033432418408916864, 0.15347299656473007, 0.3276949357115424, 0.5,
0.64231108623683952, 0.74950869138681098, 0.91717148099830148,
0.99721938213769046, 0.99983050191355338, 0.99999793935660408,
0.99999993474010451, 0.99999999896020164, 0.99999999999991951, 1.0,
1.0
]
]
calc = []
for n in range(0, 4):
calc.append([disc.cdf(i, n=n) for i in ds])
assert_close2d(ans_expect, calc, rtol=1E-9)
def test_a_alpha_aijs_composition_independent():
# TODO: a_alpha_aijs_composition_independent is being overwritten in thermo.numba somehow!
kijs = np.array([[0, .083], [0.083, 0]])
a_alphas = np.array([0.2491099357671155, 0.6486495863528039])
a0, a1, a2 = thermo.numba.eos_mix_methods.a_alpha_aijs_composition_independent(
a_alphas, kijs)
assert type(a0) is np.ndarray
assert type(a1) is np.ndarray
assert type(a2) is np.ndarray
b0, b1, b2 = thermo.eos_mix_methods.a_alpha_aijs_composition_independent(
a_alphas, kijs)
assert_close1d(a1, b1, rtol=1e-13)
assert_close2d(a0, b0, rtol=1e-13)
assert_close2d(a2, b2, rtol=1e-13)
assert thermo.numba.eos_mix_methods.a_alpha_aijs_composition_independent is not thermo.eos_mix_methods.a_alpha_aijs_composition_independent
def test_Rachford_Rice_solutionN():
ns = [
0.204322076984, 0.070970999150, 0.267194323384, 0.296291964579,
0.067046080882, 0.062489248292, 0.031685306730
]
Ks_y = [
1.23466988745, 0.89727701141, 2.29525708098, 1.58954899888,
0.23349348597, 0.02038108640, 1.40715641002
]
Ks_z = [
1.52713341421, 0.02456487977, 1.46348240453, 1.16090546194,
0.24166289908, 0.14815282572, 14.3128010831
]
ns2, Ks2, betas2 = np.array(ns), np.array([Ks_y, Ks_z]), np.array([.1, .6])
betas_new, zs_new = chemicals.numba.Rachford_Rice_solutionN(
ns2, Ks2, betas2)
betas, zs = Rachford_Rice_solutionN(ns, [Ks_y, Ks_z], [.1, .6])
assert_close1d(betas, betas_new, rtol=1e-14)
assert_close2d(zs, zs_new, rtol=1e-14)
def test_wedge_meter_expansibility():
data = [[1.0000, 0.9871, 0.9741, 0.9610, 0.9478, 0.9345, 0.9007, 0.8662, 0.8308],
[1.0000, 0.9863, 0.9726, 0.9588, 0.9449, 0.9310, 0.8957, 0.8599, 0.8234],
[1.0000, 0.9848, 0.9696, 0.9544, 0.9393, 0.9241, 0.8860, 0.8479, 0.8094],
[1.0000, 0.9820, 0.9643, 0.9467, 0.9292, 0.9119, 0.8692, 0.8272, 0.7857],
[1.0000, 0.9771, 0.9547, 0.9329, 0.9117, 0.8909, 0.8408, 0.7930, 0.7472]]
h_ds = [0.2, 0.3, 0.4, 0.5, 0.6]
pressure_ratios = [1.0, 0.98, 0.96, 0.94, 0.92, 0.9, 0.85, 0.8, 0.75]
calculated = []
for i, h_d in enumerate(h_ds):
row = []
beta = diameter_ratio_wedge_meter(D=1, H=h_d)
for j, p_ratio in enumerate(pressure_ratios):
ans = nozzle_expansibility(D=1, Do=h_d, P1=1E5, P2=1E5*p_ratio, k=1.2, beta=beta)
row.append(ans)
calculated.append(row)
assert_close2d(data, calculated, rtol=1e-4)
def test_NRTL_gammas_binaries_jac():
expect = [[
1.1789916307339643, -0.26111310616433153, -3.3538119188199227,
-6.741171640572135
],
[
0.028442736322554146, 0.12389510256475463,
-0.4669633093241108, -0.24619435634886436
],
[
0.6880803492773255, -0.1604580514041915, -1.2421051941611734,
-3.0460013493889275
],
[
0.07924102114006676, 0.14519919300123013,
-0.9799779542489997, -0.9023280256735463
]]
jac_calc = NRTL_gammas_binaries_jac([.3, .7, .4, .6], 2, 3, .2, .4)
assert_close2d(expect, jac_calc, rtol=1e-12)
# The optimized code was generated as follows with sympy
'''
def test_d2xs_to_d2xsn1():
test_data = [[
-4622.597669746761, 1098.2168754455354, -1014.6525577464832,
210.01951660524486, 974.1035993187835
],
[
1098.2168754455347, -2340.178897128616,
-791.9786180652402, 384.16062898478407, 2502.1075882633986
],
[
-1014.6525577464832, -791.9786180652403,
-6071.991240755533, 3359.1726518884193, 1823.0297151891225
],
[
210.01951660524486, 384.16062898478407,
3359.1726518884193, -2723.623727200983, 319.21808436722444
],
[
974.1035993187835, 2502.1075882633972, 1823.0297151891225,
319.21808436722444, -5223.4014263476565
]]
d2xsn1_expect = [[
-11794.206294731985, -7601.395738484303, -9035.187298602046,
-6306.7035934284195
],
[
-7601.395738484303, -12567.79550000307,
-10340.517347865418, -7660.566469993495
],
[
-9035.187298602046, -10340.517347865418,
-14941.452097481435, -4006.4765740155844
],
[
-6306.7035934284195, -7660.566469993495,
-4006.4765740155844, -8585.461322283089
]]
assert_close2d(d2xs_to_d2xsn1(test_data), d2xsn1_expect, rtol=1e-12)
def test_basic_chemsep_PR():
kij = IPDB.get_ip_specific('ChemSep PR', ['124-38-9', '67-56-1'], 'kij')
assert_close(kij, 0.0583)
kij_auto = IPDB.get_ip_automatic(['124-38-9', '67-56-1'], 'PR kij', 'kij')
assert_close(kij, kij_auto)
kij_missing = IPDB.get_ip_specific('ChemSep PR', ['1249-38-9', '67-56-1'], 'kij')
assert kij_missing == 0
assert False == IPDB.has_ip_specific('ChemSep PR', ['1249-38-9', '67-56-1'], 'kij')
assert True == IPDB.has_ip_specific('ChemSep PR', ['124-38-9', '67-56-1'], 'kij')
assert IPDB.get_tables_with_type('PR kij') == ['ChemSep PR']
# interaction parameter matrix
kij_C1C4 = IPDB.get_ip_symmetric_matrix('ChemSep PR', ['74-82-8', '74-84-0', '74-98-6', '106-97-8'], 'kij')
kij_C1C4_known = [[0.0, -0.0059, 0.0119, 0.0185],
[-0.0059, 0.0, 0.0011, 0.0089],
[0.0119, 0.0011, 0.0, 0.0033],
[0.0185, 0.0089, 0.0033, 0.0]]
assert_close2d(kij_C1C4, kij_C1C4_known)
# Test for asymetric works the same since the model is asymmetric
kij_C1C4 = IPDB.get_ip_symmetric_matrix('ChemSep PR', ['74-82-8', '74-84-0', '74-98-6', '106-97-8'], 'kij')
assert_close2d(kij_C1C4, kij_C1C4_known)
def test_basic_chemsep_NRTL():
# ethanol water, converted to metric, simple T dependence
bijs = IPDB.get_ip_asymmetric_matrix('ChemSep NRTL', ['64-17-5', '7732-18-5'], 'bij')
assert_close2d(bijs, [[0.0, -29.166654483541816], [624.8676222389441, 0.0]], rtol=1e-7)
alphas_known = [[0.0, 0.2937, 0.3009], [0.2937, 0.0, 0.2999], [0.3009, 0.2999, 0.0]]
# Test is works both symmetric and asymmetric
alphas = IPDB.get_ip_asymmetric_matrix('ChemSep NRTL', ['64-17-5', '7732-18-5', '67-56-1'], 'alphaij')
assert_close2d(alphas, alphas_known)
alphas = IPDB.get_ip_symmetric_matrix('ChemSep NRTL', ['64-17-5', '7732-18-5', '67-56-1'], 'alphaij')
assert_close2d(alphas, alphas_known)
def test_multicomnent_madeup():
T = 273.15 + 70
xs = [1 / 7.0] * 7
# m = Mixture(['water', 'ethanol', 'methanol', '1-pentanol', '2-pentanol', '3-pentanol',
# '1-decanol'],
# P=1e5, zs=xs, T=T)
# Main coefficients with temperature inverse dependency
lambdasB = [[0.0, -35.3, 40.0, -139.0, -129.0, -128.0, -242.0],
[-557.0, 0.0, -200.0, 83.2, 84.6, 80.2, 140.0],
[-280.0, 95.5, 0.0, 88.2, 85.3, 89.1, 119.0],
[-1260.0, -128.0, -220.0, 0.0, -94.4, -85.5, 59.7],
[-1280.0, -121.0, -236.0, 80.3, 0.0, -88.8, 61.4],
[-1370.0, -121.0, -238.0, 75.7, 78.2, 0.0, 63.1],
[-2670.0, -304.0, -403.0, -93.4, -91.1, -86.6, 0.0]]
# Add in some random noise for numerical stuff
lambdasA = [
[0.0092, 0.00976, 0.00915, 0.00918, 0.00974, 0.00925, 0.00908],
[0.00954, 0.00927, 0.00902, 0.00948, 0.00934, 0.009, 0.00995],
[0.00955, 0.00921, 0.0098, 0.00926, 0.00952, 0.00912, 0.00995],
[0.00924, 0.00938, 0.00941, 0.00992, 0.00935, 0.00996, 0.0092],
[0.00992, 0.00946, 0.00935, 0.00917, 0.00998, 0.00903, 0.00924],
[0.00937, 0.00973, 0.00924, 0.00991, 0.00997, 0.00968, 0.00975],
[0.00983, 0.00934, 0.00921, 0.00977, 0.00944, 0.00902, 0.00916]
]
lambdasC = [
[0.000956, 0.000958, 0.000993, 0.000949, 0.000913, 0.000947, 0.000949],
[0.000945, 0.000928, 0.000935, 0.000999, 0.000986, 0.000959, 0.000924],
[0.000957, 0.000935, 0.00097, 0.000906, 0.00098, 0.000952, 0.000939],
[0.000956, 0.000948, 0.0009, 0.000903, 0.000967, 0.000972, 0.000969],
[0.000917, 0.000949, 0.000973, 0.000922, 0.000978, 0.000944, 0.000905],
[0.000947, 0.000996, 0.000961, 0.00091, 0.00096, 0.000982, 0.000998],
[0.000934, 0.000929, 0.000955, 0.000975, 0.000924, 0.000979, 0.001]
]
lambdasD = [
[3.78e-05, 3.86e-05, 3.62e-05, 3.83e-05, 3.95e-05, 3.94e-05, 3.92e-05],
[3.88e-05, 3.88e-05, 3.75e-05, 3.82e-05, 3.8e-05, 3.76e-05, 3.71e-05],
[3.93e-05, 3.67e-05, 4e-05, 4e-05, 3.67e-05, 3.72e-05, 3.82e-05],
[3.95e-05, 3.67e-05, 3.64e-05, 3.62e-05, 3.62e-05, 3.63e-05, 3.97e-05],
[3.83e-05, 3.68e-05, 3.73e-05, 3.78e-05, 3.9e-05, 3.79e-05, 3.94e-05],
[3.67e-05, 3.82e-05, 3.76e-05, 3.61e-05, 3.67e-05, 3.88e-05, 3.64e-05],
[3.7e-05, 3.7e-05, 3.82e-05, 3.91e-05, 3.73e-05, 3.93e-05, 3.89e-05]
]
lambdasE = [[493.0, 474.0, 481.0, 468.0, 467.0, 474.0, 460.0],
[478.0, 454.0, 460.0, 488.0, 469.0, 479.0, 483.0],
[469.0, 493.0, 470.0, 476.0, 466.0, 451.0, 478.0],
[481.0, 470.0, 467.0, 455.0, 473.0, 465.0, 465.0],
[470.0, 487.0, 472.0, 460.0, 467.0, 468.0, 500.0],
[480.0, 464.0, 475.0, 469.0, 462.0, 476.0, 469.0],
[492.0, 460.0, 458.0, 494.0, 465.0, 461.0, 496.0]]
lambdasF = [
[8.25e-08, 8.27e-08, 8.78e-08, 8.41e-08, 8.4e-08, 8.93e-08, 8.98e-08],
[8.28e-08, 8.35e-08, 8.7e-08, 8.96e-08, 8.15e-08, 8.46e-08, 8.53e-08],
[8.51e-08, 8.65e-08, 8.24e-08, 8.89e-08, 8.86e-08, 8.71e-08, 8.21e-08],
[8.75e-08, 8.89e-08, 8.6e-08, 8.42e-08, 8.83e-08, 8.52e-08, 8.53e-08],
[8.24e-08, 8.27e-08, 8.43e-08, 8.19e-08, 8.74e-08, 8.3e-08, 8.35e-08],
[8.79e-08, 8.84e-08, 8.31e-08, 8.15e-08, 8.68e-08, 8.55e-08, 8.2e-08],
[8.63e-08, 8.76e-08, 8.52e-08, 8.46e-08, 8.67e-08, 8.9e-08, 8.38e-08]
]
GE = Wilson(T=T,
xs=xs,
ABCDEF=(lambdasA, lambdasB, lambdasC, lambdasD, lambdasE,
lambdasF))
dT = T * 4e-8
dlambdas_dT_numerical = ((np.array(GE.to_T_xs(T=T + dT, xs=xs).lambdas()) -
np.array(GE.lambdas())) / dT)
dlambdas_dT_analytical = GE.dlambdas_dT()
dlambdas_dT_expect = [[
7.590031904561817e-05, 0.00035248336206849656, -0.0003094799547918734,
0.0008734144675894445, 0.0008398355729456691, 0.0008388484248830437,
0.0011010388136697634
],
[
0.0009887057582300238, 7.958864330150294e-05,
0.0010333738209314847, -0.0008357318798642386,
-0.0008603154287867674, -0.000798471407040265,
-0.0017482651322616297
],
[
0.0011329768794643754, -0.0010143841833093821,
7.944935494096504e-05, -0.0009028095210965592,
-0.0008655087807908184, -0.0009179733398931945,
-0.0013825890320730938
],
[
0.00028607514753594, 0.0008361255545973125,
0.001066623152184149, 7.722830239720729e-05,
0.0006952398032090327, 0.0006509200113968528,
-0.0005326090692151773
],
[
0.00027384494917044615, 0.0008057486827319439,
0.001089620949611226, -0.000800537779412656,
8.220344880607542e-05, 0.0006666235375135453,
-0.0005573837108687875
],
[
0.00022537157737850808, 0.0008117920594539006,
0.0010915605157597842, -0.0007424034499493812,
-0.0007702925324798186, 8.014036862597122e-05,
-0.0005807961723267018
],
[
9.912129903248681e-06, 0.001142970658771038,
0.00112743688620555, 0.0006908346953600135,
0.0006797401776554298, 0.000661487700579681,
7.80163901524144e-05
]]
assert_close2d(dlambdas_dT_analytical, dlambdas_dT_expect, rtol=1e-13)
assert_close2d(GE.dlambdas_dT(), dlambdas_dT_numerical, rtol=4e-7)
d2lambdas_dT2_expect = [[
3.9148862097941074e-07, -1.1715575536585707e-06, 2.841056708836699e-06,
-3.4348594220311783e-06, -3.3305413029034426e-06,
-3.30503660953987e-06, -3.6315706582334585e-06
],
[
-8.471983417828227e-07, 3.7679068485264176e-07,
-3.7137380864269715e-06, 6.512351301871582e-06,
6.618281668596983e-06, 6.196655250267148e-06,
1.3401585927323754e-05
],
[
-3.445457199491784e-06, 7.777520320436478e-06,
3.8176318059273734e-07, 7.003390983275993e-06,
6.702713977066079e-06, 7.0719354763776695e-06,
1.0522581265135932e-05
],
[
1.4383544948858643e-06,
-3.3086241806901887e-06,
-3.7030893425862076e-06, 3.784586533299158e-07,
-2.794563476850137e-06, -2.623796179953121e-06,
4.348980938675828e-06
],
[
1.4208967586173933e-06, -3.2319878656258e-06,
-3.6664691274893067e-06, 6.187296499210411e-06,
3.913709343027832e-07, -2.6938291442926234e-06,
4.508630881673789e-06
],
[
1.341457154534956e-06, -3.2254094007592747e-06,
-3.6611570052888056e-06, 5.757845600966917e-06,
6.003019989380841e-06, 3.909269296593175e-07,
4.632022286150103e-06
],
[
1.6807740689825766e-07, -3.272186668663736e-06,
-2.3655959455488764e-06,
-2.778154773804601e-06,
-2.7342339993722627e-06,
-2.6363752589934457e-06, 3.957722151854727e-07
]]
d2lambdas_dT2_analytical = GE.d2lambdas_dT2()
d2lambdas_dT2_numerical = (
(np.array(GE.to_T_xs(T=T + dT, xs=xs).dlambdas_dT()) -
np.array(GE.dlambdas_dT())) / dT)
assert_close2d(d2lambdas_dT2_analytical, d2lambdas_dT2_expect, rtol=1e-13)
assert_close2d(d2lambdas_dT2_numerical,
d2lambdas_dT2_analytical,
rtol=1e-7)
d3lambdas_dT3_expect = [[
-2.458523153557734e-09, 1.075750588231061e-08, -2.5272393065722066e-08,
2.4517104581274395e-08, 2.431790858429151e-08, 2.427274202635229e-08,
1.9490204463227542e-08
],
[
-8.757802083086752e-09,
-2.2542994182376097e-09, 2.274425631180586e-08,
-6.272451551020672e-08, -6.401893152558163e-08,
-5.9505339021928453e-08, -1.3924656024261e-07
],
[
1.580721350387629e-08, -7.635453830620122e-08,
-2.338277642369151e-09, -6.793661773544476e-08,
-6.473586412797368e-08, -6.868136383836727e-08,
-1.0662459524200453e-07
],
[
-5.556692877523925e-09, 2.4287244013271755e-08,
2.1341219536976808e-08, -2.262235043655526e-09,
2.2067296896708128e-08, 2.1072746826311852e-08,
-4.033020732041565e-08
],
[
-5.1501733514971684e-09,
2.3982486346807567e-08, 2.0021555356784153e-08,
-5.943967388445255e-08,
-2.3179928186947205e-09, 2.144234022725535e-08,
-4.2054010358506494e-08
],
[
-3.323181667271306e-09, 2.404402632258137e-08,
1.9839516484420424e-08,
-5.4961048857581214e-08,
-5.7383559610513795e-08,
-2.366287903394162e-09, -4.330885396751575e-08
],
[
1.7135848473209763e-09, 1.331477284270524e-08,
3.0148603800370024e-09, 2.1913464581918025e-08,
2.1725189171286703e-08, 2.120416180853968e-08,
-2.4707966753243437e-09
]]
d3lambdas_dT3_analytical = GE.d3lambdas_dT3()
d3lambdas_dT3_numerical = (
(np.array(GE.to_T_xs(T=T + dT, xs=xs).d2lambdas_dT2()) -
np.array(GE.d2lambdas_dT2())) / dT)
assert_close2d(d3lambdas_dT3_analytical, d3lambdas_dT3_expect, rtol=1e-13)
assert_close2d(d3lambdas_dT3_numerical,
d3lambdas_dT3_analytical,
rtol=2e-7)
def test_ThermalConductivityGas():
EtOH = ThermalConductivityGas(MW=46.06844,
Tb=351.39,
Tc=514.0,
Pc=6137000.0,
Vc=0.000168,
Zc=0.2412,
omega=0.635,
dipole=1.44,
Vmg=0.02357,
Cpgm=56.98 + R,
mug=7.903e-6,
CASRN='64-17-5')
all_methods = list(EtOH.all_methods)
EtOH.method = EUCKEN_MOD
assert_close(EtOH.T_dependent_property(305), 0.015427445804245578)
EtOH.method = EUCKEN
assert_close(EtOH.T_dependent_property(305), 0.012984130473277289)
EtOH.method = VDI_PPDS
assert_close(EtOH.T_dependent_property(305), 0.015661846372995)
EtOH.method = BAHADORI_G
assert_close(EtOH.T_dependent_property(305), 0.018297587287579457)
EtOH.method = GHARAGHEIZI_G
assert_close(EtOH.T_dependent_property(305), 0.016862968023145547)
EtOH.method = DIPPR_9B
assert_close(EtOH.T_dependent_property(305), 0.014372770946906635)
EtOH.method = ELI_HANLEY
assert_close(EtOH.T_dependent_property(305), 0.011684946002735508)
EtOH.method = VDI_TABULAR
assert_close(EtOH.T_dependent_property(305), 0.015509857659914554)
EtOH.method = CHUNG
assert_close(EtOH.T_dependent_property(305), 0.011710616856383785)
EtOH.method = DIPPR_PERRY_8E
assert_close(EtOH.T_dependent_property(305), 0.015836254853225484)
EtOH.extrapolation = None
for i in (DIPPR_PERRY_8E, VDI_TABULAR, GHARAGHEIZI_G, ELI_HANLEY,
BAHADORI_G, VDI_PPDS):
EtOH.method = i
assert EtOH.T_dependent_property(5E20) is None
# Test tabular limits/extrapolation
EtOH.method = VDI_TABULAR
EtOH.extrapolation = 'interp1d'
assert_close(EtOH.T_dependent_property(600.), 0.05755089974293061)
EtOH.extrapolation = None
assert None == EtOH.T_dependent_property(600.)
with pytest.raises(Exception):
EtOH.test_method_validity(300, 'BADMETHOD')
# Ethanol compressed
assert [True, False] == [
EtOH.test_method_validity_P(300, P, ELI_HANLEY_DENSE)
for P in (1E5, -1E5)
]
assert [True, False] == [
EtOH.test_method_validity_P(300, P, CHUNG_DENSE) for P in (1E5, -1E5)
]
assert [True, False] == [
EtOH.test_method_validity_P(300, P, STIEL_THODOS_DENSE)
for P in (1E5, -1E5)
]
assert ThermalConductivityGas.from_json(EtOH.as_json()) == EtOH
EtOH = ThermalConductivityGas(MW=46.06844,
Tb=351.39,
Tc=514.0,
Pc=6137000.0,
Vc=0.000168,
Zc=0.2412,
omega=0.635,
dipole=1.44,
Vmg=0.02357,
Cpgm=56.98 + R,
mug=7.903e-6,
CASRN='64-17-5')
assert_close(EtOH.calculate_P(298.15, 1E6, ELI_HANLEY_DENSE),
0.011210125242396791)
assert_close(EtOH.calculate_P(298.15, 1E6, CHUNG_DENSE),
0.011770368783141446)
EtOH.method = DIPPR_PERRY_8E
assert_close(EtOH.calculate_P(298.15, 1E6, STIEL_THODOS_DENSE),
0.015422777479549062)
# Ethanol data, calculated from CoolProp
Ts = [400, 500, 600]
Ps = [1E4, 1E5, 2E5]
TP_data = [
[0.025825794817543015, 0.037905383602635095, 0.05080124980338535],
[0.02601702567554805, 0.03806794452306919, 0.050946301396380594],
[0.026243171168075605, 0.03825284803978187, 0.05110925652065333]
]
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_close2d(TP_data, recalc_pts)
EtOH.tabular_extrapolation_permitted = True
assert_close(EtOH.TP_dependent_property(399, 9E3), 0.025825794817543015)
EtOH.tabular_extrapolation_permitted = False
assert None == EtOH.TP_dependent_property(399, 9E3)
with pytest.raises(Exception):
EtOH.test_method_validity_P(300, 1E5, 'BADMETHOD')
assert ThermalConductivityGas.from_json(EtOH.as_json()) == EtOH
def test_VolumeGas():
eos = [PR(T=300, P=1E5, Tc=430.8, Pc=7884098.25, omega=0.251)]
SO2 = VolumeGas(CASRN='7446-09-5',
MW=64.0638,
Tc=430.8,
Pc=7884098.25,
omega=0.251,
dipole=1.63,
eos=eos)
SO2.method_P = ABBOTT
assert_close(SO2.TP_dependent_property(305, 1E5),
0.024995877483424613,
rtol=1e-13)
SO2.method_P = PITZER_CURL
assert_close(SO2.TP_dependent_property(305, 1E5),
0.024996281566986505,
rtol=1e-13)
SO2.method_P = EOS
assert_close(SO2.TP_dependent_property(305, 1E5),
0.02502431104578071,
rtol=1e-13)
SO2.method_P = TSONOPOULOS_EXTENDED
assert_close(SO2.TP_dependent_property(305, 1E5),
0.02499979467057479,
rtol=1e-13)
SO2.method_P = IDEAL
assert_close(SO2.TP_dependent_property(305, 1E5),
0.02535911098536738,
rtol=1e-13)
# Test that methods return None
for i in SO2.all_methods_P:
SO2.method_P = i
assert SO2.TP_dependent_property(-100, 1E5) is None
assert SO2.TP_dependent_property(100, -1E5) is None
with pytest.raises(Exception):
SO2.test_method_validity_P(300, 1E5, 'BADMETHOD')
# Ethanol data, calculated from CoolProp
EtOH = VolumeGas(MW=46.06844,
Tc=514.0,
Pc=6137000.0,
omega=0.635,
dipole=1.44,
CASRN='64-17-5')
Ts = [400, 500, 600]
Ps = [5E3, 1E4, 5E4]
TP_data = [[0.6646136629870959, 0.8312205608372635, 0.9976236498685168],
[0.33203434186506636, 0.4154969056659669, 0.49875532241189763],
[0.06596765735649, 0.08291758227639608, 0.09966060658661156]]
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_close2d(TP_data, recalc_pts)
assert_close(EtOH.TP_dependent_property(300, 9E4), 0.06596765735649)
EtOH.tabular_extrapolation_permitted = False
assert None == EtOH.TP_dependent_property(300, 9E4)
# Test CRC Virial data
H2 = VolumeGas(CASRN='1333-74-0')
H2.method_P = CRC_VIRIAL
assert_close(H2.TP_dependent_property(300, 1E5), 0.024958843346854165)
def test_basic_chemsep_UNIQUAC():
tausB = IPDB.get_ip_asymmetric_matrix(name='ChemSep UNIQUAC', CASs=['64-17-5', '7732-18-5'], ip='bij')
assert_close2d(tausB, [[0.0, -87.46005814161899], [-55.288075960115854, 0.0]], rtol=1e-5)
def test_ViscosityLiquid():
EtOH = ViscosityLiquid(MW=46.06844, Tm=159.05, Tc=514.0, Pc=6137000.0, Vc=0.000168, omega=0.635, Psat=7872.16, Vml=5.8676e-5, CASRN='64-17-5')
# Test json export
EtOH2 = ViscosityLiquid.from_JSON(EtOH.as_JSON())
assert EtOH.__dict__ == EtOH2.__dict__
# Test json export with interpolator objects
EtOH.method = VDI_TABULAR
EtOH.T_dependent_property(315)
s = EtOH.as_JSON()
EtOH2 = ViscosityLiquid.from_JSON(s)
# Do hash checks before interpolation object exists
assert hash(EtOH) == hash(EtOH2)
assert EtOH == EtOH2
assert id(EtOH) != id(EtOH2)
assert EtOH.T_dependent_property(315) == EtOH2.T_dependent_property(315)
EtOH.method = (COOLPROP)
assert_close(EtOH.T_dependent_property(298.15), 0.0010823506202025659, rtol=1e-9)
EtOH.method = (DIPPR_PERRY_8E)
assert_close(EtOH.T_dependent_property(298.15), 0.0010774308462863267, rtol=1e-9)
EtOH.method = (VDI_PPDS)
assert_close(EtOH.T_dependent_property(298.15), 0.0010623746999654108, rtol=1e-9)
EtOH.method = (DUTT_PRASAD)
assert_close(EtOH.T_dependent_property(298.15), 0.0010720812586059744, rtol=1e-9)
EtOH.method = (VISWANATH_NATARAJAN_3)
assert_close(EtOH.T_dependent_property(298.15), 0.0031157679801337825, rtol=1e-9)
EtOH.method = (VDI_TABULAR)
assert_close(EtOH.T_dependent_property(310), 0.0008726933038017184, rtol=1e-9)
EtOH.method = (LETSOU_STIEL)
assert_close(EtOH.T_dependent_property(298.15), 0.0004191198228004421, rtol=1e-9)
EtOH.method = (PRZEDZIECKI_SRIDHAR)
assert EtOH.T_dependent_property(298.15) is None
assert_close(EtOH.T_dependent_property(400.0), 0.00039598337518386806, rtol=1e-9)
EtOH.extrapolation = None
for i in EtOH.all_methods:
EtOH.method = i
assert EtOH.T_dependent_property(600) is None
with pytest.raises(Exception):
EtOH.test_method_validity(300, 'BADMETHOD')
# Acetic acid to test Viswanath_Natarajan_2_exponential
acetic_acid = ViscosityLiquid(CASRN='64-19-7', Tc=590.7, method=VISWANATH_NATARAJAN_2E)
assert_close(acetic_acid.T_dependent_property(350.0), 0.000587027903931889, rtol=1e-12)
acetic_acid.extrapolation = None
for i in acetic_acid.all_methods:
acetic_acid.method = i
assert acetic_acid.T_dependent_property(650.0) is None
# Test Viswanath_Natarajan_2 with boron trichloride
mu = ViscosityLiquid(CASRN='10294-34-5').T_dependent_property(250)
assert_close(mu, 0.0003389255178814321)
assert None == ViscosityLiquid(CASRN='10294-34-5', extrapolation=None).T_dependent_property(350)
# Ethanol compressed
EtOH = ViscosityLiquid(MW=46.06844, Tm=159.05, Tc=514.0, Pc=6137000.0, Vc=0.000168, omega=0.635, Psat=7872.16, Vml=5.8676e-5, CASRN='64-17-5')
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, LUCAS) for P in (1E3, 1E5)]
assert_close(EtOH.calculate_P(298.15, 1E6, LUCAS), 0.0010880229239312313)
assert_close(EtOH.calculate_P(298.15, 1E6, COOLPROP), 0.0010885493279015608)
EtOH = ViscosityLiquid(MW=46.06844, Tm=159.05, Tc=514.0, Pc=6137000.0, Vc=0.000168, omega=0.635, Psat=7872.16, Vml=5.8676e-5, CASRN='64-17-5')
# Ethanol data, calculated from CoolProp
Ts = [275, 300, 350]
Ps = [1E5, 5E5, 1E6]
TP_data = [[0.0017455993713216815, 0.0010445175985089377, 0.00045053170256051774], [0.0017495149679815605, 0.0010472128172002075, 0.000452108003076486], [0.0017543973013034444, 0.0010505716944451827, 0.00045406921275411145]]
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_close2d(TP_data, recalc_pts)
# TEst thta we can export to json, create a new instance with P interpolation objects
EtOH2 = ViscosityLiquid.from_JSON( EtOH.as_JSON())
recalc_pts2 = [[EtOH2.TP_dependent_property(T, P) for T in Ts] for P in Ps]
assert_close2d(recalc_pts, recalc_pts2, atol=0, rtol=0)
EtOH.tabular_extrapolation_permitted = False
EtOH.forced_P = True
assert None == EtOH.TP_dependent_property(300, 9E4)
EtOH.tabular_extrapolation_permitted = True
assert_close(EtOH.TP_dependent_property(300, 9E4), 0.0010445175985089377)
with pytest.raises(Exception):
EtOH.test_method_validity_P(300, 1E5, 'BADMETHOD')
def test_UNIQUAC_madeup_ternary():
N = 3
T = 331.42
xs = [0.229, 0.175, 0.596]
rs = [2.5735, 2.87, 1.4311]
qs = [2.336, 2.41, 1.432]
# madeup numbers to match Wilson example roughly
tausA = [[0.0, -1.05e-4, -2.5e-4], [3.9e-4, 0.0, 1.6e-4],
[-1.123e-4, 6.5e-4, 0]]
tausB = [[0.0, 235.0, -169.0], [-160, 0.0, -715.0], [11.2, 144.0, 0.0]]
tausC = [[0.0, -4.23e-4, 2.9e-4], [6.1e-4, 0.0, 8.2e-5],
[-7.8e-4, 1.11e-4, 0]]
tausD = [[0.0, -3.94e-5, 2.22e-5], [8.5e-5, 0.0, 4.4e-5],
[-7.9e-5, 3.22e-5, 0]]
tausE = [[0.0, -4.2e2, 8.32e2], [2.7e2, 0.0, 6.8e2], [3.7e2, 7.43e2, 0]]
tausF = [[0.0, 9.64e-8, 8.94e-8], [1.53e-7, 0.0, 1.11e-7],
[7.9e-8, 2.276e-8, 0]]
ABCDEF = (tausA, tausB, tausC, tausD, tausE, tausF)
GE = UNIQUAC(T=T, xs=xs, rs=rs, qs=qs, ABCDEF=ABCDEF)
assert eval(str(GE)).GE() == GE.GE()
with pytest.raises(ValueError):
UNIQUAC(T=T, xs=xs, rs=rs, qs=qs, ABCDEF=(tausA, None, None, []))
with pytest.raises(ValueError):
UNIQUAC(T=T, xs=xs, rs=rs, qs=qs, ABCDEF=(tausA, None, None, [1, 1]))
with pytest.raises(ValueError):
UNIQUAC(T=T,
xs=xs,
rs=rs,
qs=qs,
ABCDEF=(tausA, None, None, [1, 1, 1]))
with pytest.raises(ValueError):
UNIQUAC(T=T,
xs=xs,
rs=rs,
qs=qs,
ABCDEF=(tausA, None, None, [[0.0, 9.64e-8],
[1.53e-7, 0.0, 1.11e-7],
[7.9e-8, 2.276e-8, 0]]))
with pytest.raises(ValueError):
UNIQUAC(T=T,
xs=xs,
rs=rs,
qs=qs,
ABCDEF=(tausA, None, None, [[0.0, 9.64e-8, 8.94e-8],
[1.53e-7, 0.0, 1.11e-7]]))
GE2 = UNIQUAC.from_json(GE.as_json())
assert GE2.__dict__ == GE.__dict__
# GE
GE_expect = 415.5805110962149
GE_analytical = GE.GE()
assert_close(GE_expect, GE_analytical, rtol=1e-13)
gammas = UNIQUAC_gammas(taus=GE.taus(), rs=rs, qs=qs, xs=xs)
GE_identity = R * T * sum(xi * log(gamma) for xi, gamma in zip(xs, gammas))
assert_close(GE_identity, GE_analytical, rtol=1e-12)
# dGE_dT
dGE_dT_expect = 0.9907140284750982
dGE_dT_analytical = GE.dGE_dT()
dGE_dT_numerical = derivative(lambda T: GE.to_T_xs(T, xs).GE(),
T,
order=7,
dx=T * 1e-3)
assert_close(dGE_dT_analytical, dGE_dT_numerical, rtol=1e-12)
assert_close(dGE_dT_expect, dGE_dT_analytical, rtol=1e-13)
# d2GE_dT2
d2GE_dT2_expect = -0.007148011229475758
d2GE_dT2_analytical = GE.d2GE_dT2()
d2GE_dT2_numerical = derivative(lambda T: GE.to_T_xs(T, xs).dGE_dT(),
T,
order=7,
dx=T * 1e-3)
assert_close(d2GE_dT2_expect, d2GE_dT2_analytical, rtol=1e-12)
assert_close(d2GE_dT2_analytical, d2GE_dT2_numerical, rtol=1e-12)
# d3GE_dT3
d3GE_dT3_expect = 2.4882477326368877e-05
d3GE_dT3_analytical = GE.d3GE_dT3()
assert_close(d3GE_dT3_expect, d3GE_dT3_analytical, rtol=1e-13)
d3GE_dT3_numerical = derivative(lambda T: GE.to_T_xs(T, xs).d2GE_dT2(),
T,
order=11,
dx=T * 1e-2)
assert_close(d3GE_dT3_analytical, d3GE_dT3_numerical, rtol=1e-12)
# dphis_dxs
dphis_dxs_analytical = GE.dphis_dxs()
dphis_dxs_expect = [
[0.9223577846000854, -0.4473196931643269, -0.2230519905531248],
[-0.3418381934661886, 1.094722540086528, -0.19009311780433752],
[-0.5805195911338968, -0.6474028469222008, 0.41314510835746243]
]
assert_close2d(dphis_dxs_expect, dphis_dxs_analytical, rtol=1e-12)
dphis_dxs_numerical = jacobian(lambda xs: GE.to_T_xs(T, xs).phis(),
xs,
scalar=False,
perturbation=2e-8)
assert_close2d(dphis_dxs_numerical, dphis_dxs_analytical, rtol=3e-8)
# d2phis_dxixjs - checked to the last decimal with sympy
d2phis_dxixjs_expect = [
[[-2.441416183656415, 0.9048216556030662, 1.536594528053349],
[-0.7693373390462084, -0.9442924629794809, 1.7136298020256895],
[-0.3836232285397313, 0.5031631130108988, -0.11953988447116741]],
[[-0.7693373390462084, -0.9442924629794809, 1.7136298020256895],
[1.3204383950972896, -3.231500191022578, 1.9110617959252876],
[0.658424873597119, -0.5251124708645561, -0.13331240273256284]],
[[-0.3836232285397313, 0.5031631130108987, -0.11953988447116741],
[0.6584248735971189, -0.5251124708645561, -0.13331240273256284],
[0.32831771310273056, 0.27980444182238084, -0.6081221549251116]]
]
d2phis_dxixjs_analytical = GE.d2phis_dxixjs()
assert_close3d(d2phis_dxixjs_analytical, d2phis_dxixjs_expect, rtol=1e-12)
d2phis_dxixjs_numerical = hessian(lambda xs: GE.to_T_xs(T, xs).phis(),
xs,
scalar=False,
perturbation=1e-5)
assert_close3d(d2phis_dxixjs_numerical,
d2phis_dxixjs_analytical,
rtol=8e-5)
d2thetas_dxixjs_expect = [
[[-2.346422740416712, 0.7760247163009644, 1.5703980241157476],
[-0.7026345706138027, -0.9175106511836936, 1.6201452217974965],
[-0.4174990477672056, 0.47571378156805694, -0.05821473380085118]],
[[-0.7026345706138027, -0.9175106511836936, 1.6201452217974965],
[1.0476523499983839, -2.7191206652946023, 1.6714683152962189],
[0.6225054627376287, -0.5624465978146614, -0.06005886492296719]],
[[-0.4174990477672056, 0.47571378156805694, -0.05821473380085118],
[0.6225054627376287, -0.5624465978146614, -0.06005886492296719],
[0.3698870633362176, 0.2916190647283637, -0.6615061280645813]]
]
d2thetas_dxixjs_analytical = GE.d2thetas_dxixjs()
assert_close3d(d2thetas_dxixjs_analytical,
d2thetas_dxixjs_expect,
rtol=1e-12)
d2thetas_dxixjs_numerical = hessian(lambda xs: GE.to_T_xs(T, xs).thetas(),
xs,
scalar=False,
perturbation=2e-5)
assert_close3d(d2thetas_dxixjs_numerical,
d2thetas_dxixjs_analytical,
rtol=1e-4)
def to_jac(xs):
return GE.to_T_xs(T, xs).GE()
# Obtained 12 decimals of precision with numdifftools
dGE_dxs_analytical = GE.dGE_dxs()
dGE_dxs_expect = [
-2651.3181821109024, -2085.574403592012, -2295.0860830203587
]
assert_close1d(dGE_dxs_analytical, dGE_dxs_expect, rtol=1e-12)
dGE_dxs_numerical = jacobian(to_jac, xs, perturbation=1e-8)
assert_close1d(dGE_dxs_numerical, dGE_dxs_analytical, rtol=1e-6)
# d2GE_dTdxs
def to_jac(xs):
return GE.to_T_xs(T, xs).dGE_dT()
d2GE_dTdxs_expect = [
-9.940433543371945, -3.545963210296949, -7.427593534302016
]
d2GE_dTdxs = GE.d2GE_dTdxs()
d2GE_dTdxs_numerical = jacobian(to_jac, xs, perturbation=1e-8)
assert_close1d(d2GE_dTdxs_numerical, d2GE_dTdxs, rtol=1e-6)
assert_close1d(d2GE_dTdxs, d2GE_dTdxs_expect, rtol=1e-12)
# d2GE_dxixjs
def to_hess(xs):
return GE.to_T_xs(T, xs).GE()
d2GE_dxixjs_numerical = hessian(to_hess, xs, perturbation=1e-4)
d2GE_dxixjs_sympy = [
[-2890.4327598108343, -6687.099054095988, -1549.3754436994557],
[-6687.099054095988, -2811.283290487096, -1228.622385377738],
[-1549.3754436994557, -1228.622385377738, -3667.3880987585053]
]
d2GE_dxixjs_analytical = GE.d2GE_dxixjs()
assert_close2d(d2GE_dxixjs_numerical, d2GE_dxixjs_analytical, rtol=1e-4)
assert_close2d(d2GE_dxixjs_analytical, d2GE_dxixjs_sympy, rtol=1e-12)
# Check json storage again, with some results
GE2 = UNIQUAC.from_json(GE.as_json())
assert GE2.__dict__ == GE.__dict__
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()
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)
# 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)
def test_DDBST_example():
# One good numerical example - acetone, chloroform, methanol
T = 331.42
N = 3
Vs_ddbst = [74.04, 80.67, 40.73]
as_ddbst = [[0, 375.2835, 31.1208], [-1722.58, 0, -1140.79],
[747.217, 3596.17, 0.0]]
bs_ddbst = [[0, -3.78434, -0.67704], [6.405502, 0, 2.59359],
[-0.256645, -6.2234, 0]]
cs_ddbst = [[0.0, 7.91073e-3, 8.68371e-4], [-7.47788e-3, 0.0, 3.1e-5],
[-1.24796e-3, 3e-5, 0.0]]
dis = eis = fis = [[0.0] * N for _ in range(N)]
params = Wilson.from_DDBST_as_matrix(Vs=Vs_ddbst,
ais=as_ddbst,
bis=bs_ddbst,
cis=cs_ddbst,
dis=dis,
eis=eis,
fis=fis,
unit_conversion=False)
A_expect = [[0.0, 3.870101271243586, 0.07939943395502425],
[-6.491263271243587, 0.0, -3.276991837288562],
[0.8542855660449756, 6.906801837288562, 0.0]]
B_expect = [[0.0, -375.2835, -31.1208], [1722.58, 0.0, 1140.79],
[-747.217, -3596.17, -0.0]]
D_expect = [[-0.0, -0.00791073, -0.000868371],
[0.00747788, -0.0, -3.1e-05], [0.00124796, -3e-05, -0.0]]
C_expect = E_expect = F_expect = [[0.0] * N for _ in range(N)]
assert_close2d(params[0], A_expect, rtol=1e-12, atol=0)
assert_close2d(params[1], B_expect, rtol=1e-12, atol=0)
assert_close2d(params[2], C_expect, rtol=1e-12, atol=0)
assert_close2d(params[3], D_expect, rtol=1e-12, atol=0)
assert_close2d(params[4], E_expect, rtol=1e-12, atol=0)
assert_close2d(params[5], F_expect, rtol=1e-12, atol=0)
xs = [0.229, 0.175, 0.596]
GE = Wilson(T=T, xs=xs, ABCDEF=params)
# Test __repr__ contains the needed information
assert eval(str(GE)).GE() == GE.GE()
GE2 = Wilson.from_JSON(GE.as_JSON())
assert GE2.__dict__ == GE.__dict__
gammas_expect = [1.223393433488855, 1.1009459024701462, 1.2052899281172034]
assert_close1d(GE.gammas(), gammas_expect, rtol=1e-12)
assert_close1d(GibbsExcess.gammas(GE), gammas_expect)
lambdas = GE.lambdas()
lambdas_expect = [[1.0, 1.1229699812593041, 0.7391181616283594],
[3.2694762162029805, 1.0, 1.1674967844769508],
[0.37280197780931773, 0.019179096486191153, 1.0]]
assert_close2d(lambdas, lambdas_expect, rtol=1e-12)
dlambdas_dT = GE.dlambdas_dT()
dlambdas_dT_expect = [[0.0, -0.005046703220379676, -0.0004324140595259853],
[-0.026825598419319092, 0.0, -0.012161812924715213],
[0.003001348681882189, 0.0006273541924400231, 0.0]]
assert_close2d(dlambdas_dT, dlambdas_dT_expect)
dT = T * 1e-8
dlambdas_dT_numerical = (np.array(GE.to_T_xs(T + dT, xs).lambdas()) -
GE.to_T_xs(T, xs).lambdas()) / dT
assert_close2d(dlambdas_dT, dlambdas_dT_numerical, rtol=1e-7)
d2lambdas_dT2 = GE.d2lambdas_dT2()
d2lambdas_dT2_expect = [
[0.0, -4.73530781420922e-07, -1.0107624477842068e-06],
[0.000529522489227112, 0.0, 0.0001998633344112975],
[8.85872572550323e-06, 1.6731622007033546e-05, 0.0]
]
assert_close2d(d2lambdas_dT2, d2lambdas_dT2_expect, rtol=1e-12)
d2lambdas_dT2_numerical = (np.array(GE.to_T_xs(T + dT, xs).dlambdas_dT()) -
GE.to_T_xs(T, xs).dlambdas_dT()) / dT
assert_close2d(d2lambdas_dT2, d2lambdas_dT2_numerical, rtol=2e-5)
d3lambdas_dT3 = GE.d3lambdas_dT3()
d3lambdas_dT3_expect = [
[0.0, 4.1982403087995867e-07, 1.3509359183777608e-08],
[-1.2223067176509094e-05, 0.0, -4.268843384910971e-06],
[-3.6571009680721684e-08, 3.3369718709496133e-07, 0.0]
]
assert_close2d(d3lambdas_dT3, d3lambdas_dT3_expect, rtol=1e-12)
d3lambdas_dT3_numerical = (
np.array(GE.to_T_xs(T + dT, xs).d2lambdas_dT2()) -
GE.to_T_xs(T, xs).d2lambdas_dT2()) / dT
assert_close2d(d3lambdas_dT3, d3lambdas_dT3_numerical, rtol=1e-7)
# Gammas
assert_allclose(GE.GE(), 480.2639266306882, 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)
# 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, 4.355962766232997, rtol=1e-12)
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.02913038452501723, rtol=1e-12)
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.00019988744724590656, rtol=1e-12)
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 = [
-10.187806161151178, 13.956324059647034, -6.825249918548414
]
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 = [
-2199.97589893946, -2490.5759162306463, -2241.05706053718
]
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 = [
[-3070.205333938506, -7565.029777297412, -1222.5200812237945],
[-7565.029777297412, -2156.7810946064815, -1083.4743126696396],
[-1222.5200812237945, -1083.4743126696396, -3835.5941234746824]
]
assert_close2d(d2GE_dxixjs_analytical, d2GE_dxixjs_expect, rtol=1e-12)
assert_close2d(d2GE_dxixjs_analytical, d2GE_dxixjs_numerical, rtol=1e-4)
# d3GE_dxixjxks - very limited accuracy.
def d2GE_dxixj_diff(xs):
return GE.to_T_xs(T, xs).dGE_dxs()
d3GE_dxixjxks_numerical = hessian(d2GE_dxixj_diff,
xs,
perturbation=2e-5,
scalar=False)
d3GE_dxixjxks_analytical = GE.d3GE_dxixjxks()
d3GE_dxixjxks_expect = [
[[614.0681113650099, 14845.66663517824, 556.3625424156468],
[14845.66663517824, 8308.935636377626, 4549.175136703878],
[556.3625424156469, 4549.175136703878, 501.6902853815983]],
[[14845.66663517824, 8308.935636377626, 4549.175136703878],
[8308.935636377626, 173.08338078843053, 375.4114802651511],
[4549.175136703877, 375.411480265151, -40.24127966770044]],
[[556.3625424156469, 4549.175136703877, 501.6902853815977],
[4549.175136703877, 375.411480265151, -40.241279667700574],
[501.6902853815964, -40.24127966770071, 6254.612872590844]]
]
assert_close3d(d3GE_dxixjxks_analytical, d3GE_dxixjxks_expect, rtol=1e-12)
assert_close3d(d3GE_dxixjxks_numerical,
d3GE_dxixjxks_analytical,
rtol=1e-3)
### TEST WHICH ARE COMMON TO ALL GibbsExcess classes
HE_expected = -963.3892533542517
HE_analytical = GE.HE()
assert_allclose(HE_expected, HE_analytical, rtol=1e-12)
def diff_for_HE(T):
return GE.to_T_xs(T, xs).GE() / T
HE_numerical = -derivative(diff_for_HE, T, order=13) * T**2
assert_close(HE_analytical, HE_numerical, rtol=1e-12)
SE_expected = -4.355962766232997
SE_analytical = GE.SE()
assert_allclose(SE_expected, SE_analytical, rtol=1e-12)
SE_check = (GE.HE() - GE.GE()) / T
assert_close(SE_analytical, SE_check, rtol=1e-12)
def diff_for_Cp(T):
return GE.to_T_xs(T, xs).HE()
Cp_expected = 9.65439203928121
Cp_analytical = GE.CpE()
assert_close(Cp_expected, Cp_analytical, rtol=1e-12)
Cp_numerical = derivative(diff_for_Cp, T, order=13)
assert_close(Cp_numerical, Cp_analytical, rtol=1e-12)
def diff_for_dS_dT(T):
return GE.to_T_xs(T, xs).SE()
dS_dT_expected = 0.02913038452501723
dS_dT_analytical = GE.dSE_dT()
assert_close(dS_dT_expected, dS_dT_analytical, rtol=1e-12)
dS_dT_numerical = derivative(diff_for_dS_dT, T, order=9)
assert_close(dS_dT_analytical, dS_dT_numerical, rtol=1e-12)
def diff_for_dHE_dx(xs):
return GE.to_T_xs(T, xs).HE()
dHE_dx_expected = [
1176.4668189892636, -7115.980836078867, 20.96726746813556
]
dHE_dx_analytical = GE.dHE_dxs()
assert_close1d(dHE_dx_expected, dHE_dx_analytical, rtol=1e-12)
dHE_dx_numerical = jacobian(diff_for_dHE_dx, xs, perturbation=5e-7)
assert_close1d(dHE_dx_expected, dHE_dx_numerical, rtol=4e-6)
def diff_for_dHE_dn(xs):
xs = normalize(xs)
return GE.to_T_xs(T, xs).HE()
dHE_dn_expected = [
2139.856072343515, -6152.591582724615, 984.3565208223869
]
dHE_dn_analytical = GE.dHE_dns()
assert_close1d(dHE_dn_expected, dHE_dn_analytical, rtol=1e-12)
dHE_dn_numerical = jacobian(diff_for_dHE_dn, xs, perturbation=5e-7)
assert_close1d(dHE_dn_expected, dHE_dn_numerical, rtol=1e-6)
def diff_for_dnHE_dn(xs):
nt = sum(xs)
xs = normalize(xs)
return nt * GE.to_T_xs(T, xs).HE()
dnHE_dn_expected = [
1176.4668189892634, -7115.980836078867, 20.967267468135258
]
dnHE_dn_analytical = GE.dnHE_dns()
assert_close1d(dnHE_dn_expected, dnHE_dn_analytical, rtol=1e-12)
dnHE_dn_numerical = jacobian(diff_for_dnHE_dn, xs, perturbation=5e-7)
assert_close1d(dnHE_dn_analytical, dnHE_dn_numerical, rtol=2e-6)
def diff_for_dSE_dx(xs):
return GE.to_T_xs(T, xs).SE()
dSE_dx_expected = [
10.187806161151178, -13.956324059647036, 6.825249918548415
]
dSE_dx_analytical = GE.dSE_dxs()
assert_close1d(dSE_dx_expected, dSE_dx_analytical, rtol=1e-12)
dSE_dx_numerical = jacobian(diff_for_dSE_dx, xs, perturbation=5e-7)
assert_close1d(dSE_dx_expected, dSE_dx_numerical, rtol=4e-6)
def diff_for_dSE_dns(xs):
xs = normalize(xs)
return GE.to_T_xs(T, xs).SE()
dSE_dns_expected = [
6.2293063092309335, -17.91482391156728, 2.8667500666281707
]
dSE_dns_analytical = GE.dSE_dns()
assert_close1d(dSE_dns_expected, dSE_dns_analytical, rtol=1e-12)
dSE_dns_numerical = jacobian(diff_for_dSE_dns, xs, perturbation=5e-7)
assert_close1d(dSE_dns_expected, dSE_dns_numerical, rtol=1e-6)
def diff_for_dnSE_dn(xs):
nt = sum(xs)
xs = normalize(xs)
return nt * GE.to_T_xs(T, xs).SE()
dnSE_dn_expected = [
1.8733435429979384, -22.270786677800274, -1.489212699604825
]
dnSE_dn_analytical = GE.dnSE_dns()
assert_close1d(dnSE_dn_expected, dnSE_dn_analytical, rtol=1e-12)
dnSE_dn_numerical = jacobian(diff_for_dnSE_dn, xs, perturbation=5e-7)
assert_close1d(dnSE_dn_analytical, dnSE_dn_numerical, rtol=2e-6)
def diff_for_dGE_dn(xs):
xs = normalize(xs)
return GE.to_T_xs(T, xs).GE()
dGE_dn_expected = [75.3393753381988, -215.2606419529875, 34.25821374047882]
dGE_dn_analytical = GE.dGE_dns()
assert_close1d(dGE_dn_expected, dGE_dn_analytical, rtol=1e-12)
dGE_dn_numerical = jacobian(diff_for_dGE_dn, xs, perturbation=5e-7)
assert_close1d(dGE_dn_expected, dGE_dn_numerical, rtol=1e-5)
def diff_for_dnGE_dn(xs):
nt = sum(xs)
xs = normalize(xs)
return nt * GE.to_T_xs(T, xs).GE()
dnGE_dn_expected = [
555.6033019688871, 265.0032846777008, 514.5221403711671
]
dnGE_dn_analytical = GE.dnGE_dns()
assert_close1d(dnGE_dn_expected, dnGE_dn_analytical, rtol=1e-12)
dnGE_dn_numerical = jacobian(diff_for_dnGE_dn, xs, perturbation=5e-7)
assert_close1d(dnGE_dn_analytical, dnGE_dn_numerical, rtol=2e-6)
lambdas = GE.lambdas()
def gammas_to_diff(xs):
xs = normalize(xs)
return np.array(Wilson_gammas(xs, lambdas))
dgammas_dns_analytical = GE.dgammas_dns()
dgammas_dn_numerical = jacobian(gammas_to_diff, xs, scalar=False)
dgammas_dn_expect = [
[-0.13968444275751782, -2.135249914756224, 0.6806316652245148],
[-1.9215360979146614, 0.23923983797040177, 0.668061736204089],
[0.6705598284218852, 0.7313784266789759, -0.47239836472723573]
]
assert_close2d(dgammas_dns_analytical, dgammas_dn_numerical, rtol=1e-5)
assert_close2d(dgammas_dns_analytical, dgammas_dn_expect, rtol=1e-11)
'''# Using numdifftools, the result was confirmed to the four last decimal places (rtol=12-13).
from numdifftools import Jacobian
(Jacobian(gammas_to_diff, step=1e-6, order=37)(xs)/dgammas_dns_analytical).tolist()
'''
dgammas_dT_numerical = (
(np.array(GE.to_T_xs(T + dT, xs).gammas()) - np.array(GE.gammas())) /
dT)
dgammas_dT_analytical = GE.dgammas_dT()
dgammas_dT_expect = [
-0.001575992756074107, 0.008578456201039092, -2.7672076632932624e-05
]
assert_close1d(dgammas_dT_analytical, dgammas_dT_expect, rtol=1e-12)
assert_close1d(dgammas_dT_numerical, dgammas_dT_analytical, rtol=2e-6)
d2GE_dTdns_expect = [
-6.229306309230934, 17.91482391156728, -2.8667500666281702
]
d2GE_dTdns_analytical = GE.d2GE_dTdns()
d2GE_dTdns_numerical = (
(np.array(GE.to_T_xs(T + dT, xs).dGE_dns()) - np.array(GE.dGE_dns())) /
dT)
assert_close1d(d2GE_dTdns_expect, d2GE_dTdns_analytical, rtol=1e-12)
assert_close1d(d2GE_dTdns_analytical, d2GE_dTdns_numerical, rtol=1e-7)
d2nGE_dTdns_expect = [
-1.8733435429979375, 22.270786677800274, 1.4892126996048267
]
d2nGE_dTdns_analytical = GE.d2nGE_dTdns()
d2nGE_dTdns_numerical = ((np.array(GE.to_T_xs(T + dT, xs).dnGE_dns()) -
np.array(GE.dnGE_dns())) / dT)
assert_close1d(d2nGE_dTdns_expect, d2nGE_dTdns_analytical, rtol=1e-12)
assert_close1d(d2nGE_dTdns_analytical, d2nGE_dTdns_numerical, rtol=1e-6)
def to_diff_dnGE2_dninj(ns):
nt = sum(ns)
xs = normalize(ns)
return nt * GE.to_T_xs(T, xs).GE()
d2nGE_dninjs_numerical = hessian(to_diff_dnGE2_dninj,
xs,
perturbation=4e-5)
d2nGE_dninjs_analytical = GE.d2nGE_dninjs()
d2nGE_dninjs_expect = [
[-314.62613303015996, -4809.450576389065, 1533.0591196845521],
[-4809.450576389066, 598.7981063018656, 1672.104888238707],
[1533.0591196845517, 1672.1048882387074, -1080.0149225663358]
]
assert_close2d(d2nGE_dninjs_analytical, d2nGE_dninjs_expect, rtol=1e-12)
assert_close2d(d2nGE_dninjs_numerical, d2nGE_dninjs_analytical, rtol=1e-4)
# Test with some results stored
GE2 = Wilson.from_JSON(GE.as_JSON())
assert GE2.__dict__ == GE.__dict__
