def test_mu_Yaws():
assert_close(mu_Yaws(300.0, -6.4406 - log10(1000), 1117.6, 0.0137,
-0.000015465),
0.00100666120816515,
rtol=1e-14)
d = dmu_Yaws_dT(300.0, -9.4406, 1117.6, 0.0137, -0.000015465)
d_num = derivative(
lambda T: mu_Yaws(T, -9.4406, 1117.6, 0.0137, -0.000015465),
300.0,
dx=300.0 * 1e-7)
assert_close(d, d_num)
T, A, B, C, D = 300.0, -9.4406, 1117.6, 0.0137, -0.000015465
der_num = [
derivative(lambda A: mu_Yaws(T, A, B, C, D), A, dx=A * 1e-5),
derivative(lambda B: mu_Yaws(T, A, B, C, D), B, dx=B * 1e-5),
derivative(lambda C: mu_Yaws(T, A, B, C, D), C, dx=C * 1e-5),
derivative(lambda D: mu_Yaws(T, A, B, C, D), D, dx=D * 1e-5)
]
der_expect = [[
0.0023179230916164487, 7.726410305388163e-06, 0.6953769274849346,
208.61307824548038
]]
der_analytical = mu_Yaws_fitting_jacobian([T], A, B, C, D)
assert_close1d(der_expect, der_analytical, rtol=1e-13)
assert_close1d(der_analytical, [der_num], rtol=1e-7)
# Point where overflow would occur
kwargs = {'T': 489.2, 'A': 1.0, 'B': 1.0, 'C': 1.0, 'D': 1.0}
mu_Yaws(**kwargs)
def test_PPDS9():
mu = PPDS9(400.0, 1.74793, 1.33728, 482.347, 41.78, 9.963e-05)
assert_close(mu, 0.00035091137378230684, rtol=1e-13)
coeffs = (1.74793, 1.33728, 482.347, 41.78, 9.963e-05)
# normal region
mu_expect = PPDS9(400.0, *coeffs)
dmu, mu = dPPDS9_dT(400.0, *coeffs)
assert_close(mu, mu_expect, rtol=1e-13)
assert_close(dmu, -3.186540635882627e-06, rtol=1e-10)
assert_close(derivative(PPDS9, 400.0, args=coeffs, dx=1e-4),
dmu,
rtol=1e-9)
mu_expect = PPDS9(5.0, *coeffs)
dmu, mu = dPPDS9_dT(5.0, *coeffs)
assert_close(mu, mu_expect, rtol=1e-13)
assert_close(dmu, 1126796480623.1184, rtol=1e-10)
assert_close(derivative(PPDS9, 5.0, args=coeffs, dx=1e-5), dmu, rtol=1e-9)
# Check can go super low T without overflow
coeffs = [1.20479, 0.6058, 216.325, 2.278, 8.756e-05]
assert PPDS9(3, *coeffs) > 1e10
assert PPDS9(2, *coeffs) > 1e10
assert PPDS9(1, *coeffs) > 1e10
dPPDS9_dT(2, *coeffs)
dPPDS9_dT(1, *coeffs)
dPPDS9_dT(3, *coeffs)
def test_VaporPressure_bestfit_derivatives():
obj = VaporPressure(poly_fit=(175.7, 512.49, [-1.446088049406911e-19, 4.565038519454878e-16, -6.278051259204248e-13, 4.935674274379539e-10,
-2.443464113936029e-07, 7.893819658700523e-05, -0.016615779444332356, 2.1842496316772264, -134.19766175812708]))
assert_close(obj.T_dependent_property(300), 18601.061401014867, rtol=1e-11)
assert_close(obj.T_dependent_property_derivative(300), 954.1652489206775, rtol=1e-11)
assert_close(obj.T_dependent_property_derivative(300, order=2), 41.8787546283273, rtol=1e-11)
assert_close(derivative(obj.T_dependent_property, 300, dx=300*1e-7), obj.T_dependent_property_derivative(300))
assert_close(derivative(obj.T_dependent_property_derivative, 300, dx=300*1e-7), obj.T_dependent_property_derivative(300, order=2))
def test_TRC_Antoine_extended():
# Tetrafluoromethane, coefficients from [1]_, at 180 K:
Psat = TRC_Antoine_extended(180.0, 227.51, -120., 8.95894, 510.595, -15.95,
2.41377, -93.74, 7425.9)
assert_close(Psat, 706317.0898414153)
# Test x is restricted to 0
Psat = TRC_Antoine_extended(120.0, 227.51, -120., 8.95894, 510.595, -15.95,
2.41377, -93.74, 7425.9)
assert_close(Psat, 11265.018958511126)
# Confirm that at low x, reverts to the Antoine expression
assert_close(TRC_Antoine_extended(T=100.0,
Tc=227.51,
to=-120.,
A=8.95894,
B=510.595,
C=-15.95,
n=2.41377,
E=-93.74,
F=7425.9),
Antoine(T=100.0, A=8.95894, B=510.595, C=-15.95),
rtol=1e-13)
dPsat_dT_numerical = derivative(TRC_Antoine_extended,
180.0,
dx=1e-3,
args=(227.51, -120., 8.95894, 510.595,
-15.95, 2.41377, -93.74, 7425.9))
dPsat_dT_analytical = dTRC_Antoine_extended_dT(180.0, 227.51, -120.,
8.95894, 510.595, -15.95,
2.41377, -93.74, 7425.9)
assert_close(dPsat_dT_analytical, 31219.606126382252, rtol=1e-13)
assert_close(dPsat_dT_numerical, dPsat_dT_analytical, rtol=1e-8)
for T in (0.0, 1e-150, 1e-200, 1e-250, 1e-300, 1e-100, 1e-400, 1e-308,
1e-307):
assert dTRC_Antoine_extended_dT(T, 227.51, -120., 8.95894, 510.595,
-15.95, 2.41377, -93.74, 7425.9) == 0.0
d2Psat_dT2_numerical = derivative(dTRC_Antoine_extended_dT,
180.0,
dx=1e-3,
args=(227.51, -120., 8.95894, 510.595,
-15.95, 2.41377, -93.74, 7425.9))
d2Psat_dT2_analytical = d2TRC_Antoine_extended_dT2(180.0, 227.51, -120.,
8.95894, 510.595,
-15.95, 2.41377, -93.74,
7425.9)
assert_close(d2Psat_dT2_analytical, 1022.5503689444175, rtol=1e-13)
assert_close(d2Psat_dT2_numerical, d2Psat_dT2_analytical, rtol=1e-8)
for T in (0.0, 1e-150, 1e-200, 1e-250, 1e-300, 1e-100, 1e-400, 1e-308,
1e-307):
assert d2TRC_Antoine_extended_dT2(T, 227.51, -120., 8.95894, 510.595,
-15.95, 2.41377, -93.74,
7425.9) == 0.0
def test_Antoine_fit_extrapolate():
T = 178.01
A, B, C = (24.0989474955895, 4346.793091137991, -18.96968471040141)
Psat, dPsat_dT, d2Psat_dT2 = (0.03946094565666715, 0.006781441203850251, 0.0010801244983894853)
assert_close(Psat, Antoine(T, A, B, C, base=e), rtol=1e-10)
dPsat_dT_num = derivative(lambda T: Antoine(T, A, B, C, base=e), T, dx=T*1e-9)
assert_close(dPsat_dT_num, dPsat_dT, rtol=1e-7)
d2Psat_dT2_num = derivative(lambda T: Antoine(T, A, B, C, base=e), T, dx=T*1e-7, n=2, order=13)
d2Psat_dT2_analytical = B*(B/(C + T) - 2)*exp(A - B/(C + T))/(C + T)**3
assert_close(d2Psat_dT2_num, d2Psat_dT2, rtol=1e-4)
assert_close(d2Psat_dT2_analytical, d2Psat_dT2, rtol=1e-10)
def test_Wagner_original():
# Methane, coefficients from [2]_, at 100 K
Psat = Wagner_original(100.0, 190.53, 4596420., -6.00435, 1.1885,
-0.834082, -1.22833)
assert_close(Psat, 34520.44601450496)
for T in (0.0, 1e-100, 1e-15, 1e-7, 1.0):
assert 0 == Wagner_original(T,
190.53,
4596420.,
a=-6.00435,
b=1.1885,
c=-0.834082,
d=-1.22833)
# First derivative
dPsat_dT_numerical = derivative(Wagner_original,
100.0,
dx=1e-3,
args=(190.53, 4596420., -6.00435, 1.1885,
-0.834082, -1.22833))
dPsat_dT_analytical = dWagner_original_dT(100, 190.53, 4596420., -6.00435,
1.1885, -0.834082, -1.22833)
assert_close(dPsat_dT_analytical, 3593.707832837502, rtol=1e-13)
assert_close(dPsat_dT_numerical, dPsat_dT_analytical, rtol=1e-8)
assert dWagner_original_dT(
1.0, 190.53, 4596420., a=-6.00435, b=1.1885, c=-0.834082,
d=-1.22833) < 1e-100
for T in (0.0, 1e-150, 1e-200, 1e-250, 1e-300, 1e-100, 1e-400, 1e-308,
1e-307):
assert dWagner_original_dT(T, 190.53, 4596420., -6.00435, 1.1885,
-0.834082, -1.22833) == 0.0
# Second derivative
d2Psat_dT2_numerical = derivative(dWagner_original_dT,
100.0,
dx=1e-3,
args=(190.53, 4596420., -6.00435, 1.1885,
-0.834082, -1.22833))
d2Psat_dT2_analytical = d2Wagner_original_dT2(100, 190.53, 4596420.,
-6.00435, 1.1885, -0.834082,
-1.22833)
assert_close(d2Psat_dT2_analytical, 296.87593368224003, rtol=1e-13)
assert_close(d2Psat_dT2_numerical, d2Psat_dT2_analytical, rtol=1e-8)
for T in (0.0, 1e-150, 1e-200, 1e-250, 1e-300, 1e-100, 1e-400, 1e-308,
1e-307):
assert d2Wagner_original_dT2(T, 190.53, 4596420., -6.00435, 1.1885,
-0.834082, -1.22833) == 0.0
def test_lemmon2000_air_d3A0_dtau3():
assert_close(lemmon2000_air_d3A0_dtau3(0.36842, .5),
102.9144884392338,
rtol=2e-12)
assert_close(
derivative(lambda tau: lemmon2000_air_d2A0_dtau2(tau, .5),
0.36842,
dx=1e-7), lemmon2000_air_d3A0_dtau3(0.36842, .5))
for rat in (1000.0, 100.0, 10.0, 5.0, 3.0, 2.5, 2.0, 1.5, 1.0, .5, .2, .1,
.01, .001):
assert_close(
derivative(lambda tau: lemmon2000_air_d2A0_dtau2(tau, .5),
rat,
dx=rat * 1e-5), lemmon2000_air_d3A0_dtau3(rat, .5))
def test_lemmon2000_air_d4A0_dtau4():
assert_close(lemmon2000_air_d4A0_dtau4(126.192 / 200.0, 13000 / 11183.9),
-94.8155327278803,
rtol=1e-13)
assert_close(
derivative(lambda tau: lemmon2000_air_d3A0_dtau3(tau, .5),
0.36842,
dx=4e-7), lemmon2000_air_d4A0_dtau4(0.36842, .5))
for rat in (1000.0, 100.0, 10.0, 5.0, 3.0, 2.5, 2.0, 1.5, 1.0, .5, .2, .1,
.01, .001):
assert_close(
derivative(lambda tau: lemmon2000_air_d3A0_dtau3(tau, .5),
rat,
dx=rat * 1e-5), lemmon2000_air_d4A0_dtau4(rat, .5))
def test_Wagner_fitting_jacobian():
T, Tc, Pc, a, b, c, d = 100.0, 475.03, 2980000.0, -8.32915, 2.37044, -3.75113, -4.6033
der_num = [
derivative(lambda a: Wagner(T, Tc, Pc, a, b, c, d), a, dx=a * 1e-5),
derivative(lambda b: Wagner(T, Tc, Pc, a, b, c, d), b, dx=b * 1e-5),
derivative(lambda c: Wagner(T, Tc, Pc, a, b, c, d), c, dx=c * 1e-5),
derivative(lambda d: Wagner(T, Tc, Pc, a, b, c, d), d, dx=d * 1e-5)
]
der_expect = [[
5.1791400515036586e-11, 4.601825445175529e-11, 3.633081272138977e-11,
2.0120443215711467e-11
]]
der_analytical = Wagner_fitting_jacobian([T], Tc, Pc, a, b, c, d)
assert_close1d(der_expect, der_analytical, rtol=1e-13)
assert_close1d(der_analytical, [der_num], rtol=1e-7)
def calculate_derivative_P(self, P, T, method, order=1):
r'''Method to calculate a derivative of a temperature and pressure
dependent property with respect to pressure at constant temperature,
of a given order using a specified method. Uses SciPy's derivative
function, with a delta of 0.01 Pa and a number of points equal to
2*order + 1.
This method can be overwritten by subclasses who may perfer to add
analytical methods for some or all methods as this is much faster.
If the calculation does not succeed, returns the actual error
encountered.
Parameters
----------
P : float
Pressure at which to calculate the derivative, [Pa]
T : float
Temperature at which to calculate the derivative, [K]
method : str
Method for which to find the derivative
order : int
Order of the derivative, >= 1
Returns
-------
dprop_dP_T : float
Calculated derivative property at constant temperature,
[`units/Pa^order`]
'''
f = lambda P: self.calculate_P(T, P, method)
return derivative(f, P, dx=1e-2, n=order, order=1 + order * 2)
def test_Antoine():
# Methane, coefficients from [1]_, at 100 K:
Psat = Antoine(100.0, 8.7687, 395.744, -6.469)
assert_close(Psat, 34478.367349639906)
# Tetrafluoromethane, coefficients from [1]_, at 180 K
Psat = Antoine(180, A=8.95894, B=510.595, C=-15.95)
assert_close(Psat, 702271.0518579542)
# Oxygen at 94.91 K, with coefficients from [3]_ in units of °C, mmHg, log10,
# showing the conversion of coefficients A (mmHg to Pa) and C (°C to K)
Psat = Antoine(94.91, 6.83706 + 2.1249, 339.2095, 268.70 - 273.15)
assert_close(Psat, 162978.88655572367)
# Extremely low temperature checks
Psat = Antoine(T=60, A=3.45604 + 5, B=1044.038, C=-53.893)
assert Psat < 1e-100
assert Psat > 0.0
assert Antoine(T=53, A=3.45604 + 5, B=1044.038, C=-53.893) == 0.0
assert Antoine(T=53.893, A=3.45604 + 5, B=1044.038, C=-53.893) == 0.0
assert Antoine(T=50, A=3.45604 + 5, B=1044.038, C=-53.893) == 0.0
dPsat_dT = dAntoine_dT(100.0, 8.7687, 395.744, -6.469)
assert_close(dPsat_dT, 3591.4147747481156, rtol=1e-13)
assert_close(dPsat_dT,
derivative(Antoine,
100.0,
dx=100 * 1e-7,
args=(8.7687, 395.744, -6.469)),
rtol=1e-9)
# Extremely low temperature derivative check
assert dAntoine_dT(5, 8.7687, 395.744, -6.469) == 0.0
d2Psat_dT = d2Antoine_dT2(100, 8.7687, 395.744, -6.469)
d2Psat_dT_num = derivative(dAntoine_dT,
100.0,
dx=.01,
args=(8.7687, 395.744, -6.469))
assert_close(d2Psat_dT, 297.30093799054947, rtol=1e-13)
assert_close(d2Psat_dT, d2Psat_dT_num, rtol=1e-7)
# Low T values
for T in (0, 1e-10, 1e-100, 10, 53, 53.893, 54):
assert 0 == d2Antoine_dT2(T=T, A=3.45604 + 5, B=1044.038, C=-53.893)
def test_TEOS10_CAWW_derivatives():
assert_close(TEOS10_CAWW_derivatives(200.0)[0], -0.349872634E-5, rtol=1e-9)
assert_close(TEOS10_CAWW_derivatives(200.0)[1], 0.188025052E-6, rtol=2e-9)
assert_close(TEOS10_CAWW_derivatives(200.0)[2], -0.124996856E-7, rtol=2e-9)
assert_close(derivative(lambda T: TEOS10_CAWW_derivatives(T)[-2],
200.0,
dx=200 * 1e-7),
TEOS10_CAWW_derivatives(200)[-1],
rtol=1e-8)
def test_lemmon2000_air_d4Ar_ddelta3dtau():
for rat in (1000.0, 100.0, 10.0, 5.0, 3.0, 2.5, 2.0, 1.5, 1.0, .5, .2, .1,
.01, .001):
assert_close(
derivative(lambda tau: lemmon2000_air_d3Ar_ddelta3(tau, .5),
rat,
dx=rat * 1e-5),
lemmon2000_air_d4Ar_ddelta3dtau(rat, .5))
def test_TEOS10_BAW_derivatives():
assert_close(TEOS10_BAW_derivatives(200)[0], -0.784874278E-4)
assert_close(TEOS10_BAW_derivatives(200)[1], 0.848076624E-6)
assert_close(TEOS10_BAW_derivatives(200)[2], -0.122622146E-7)
assert_close(derivative(lambda T: TEOS10_BAW_derivatives(T)[-2],
200.0,
dx=200 * 1e-7),
TEOS10_BAW_derivatives(200)[-1],
rtol=1e-8)
def test_lemmon2000_air_dA0_dtau():
assert_close(derivative(
lambda tau: lemmon2000_air_A0(tau, 13000 / 11183.9),
126.192 / 200.0,
dx=1e-7),
lemmon2000_air_dA0_dtau(126.192 / 200.0, 13000 / 11183.9),
rtol=1e-9)
assert_close(lemmon2000_air_dA0_dtau(0.36842, 0.5),
6.764336610288353,
rtol=1e-14)
for rat in (1000.0, 100.0, 10.0, 5.0, 3.0, 2.5, 2.0, 1.5, 1.0, .5, .2, .1,
.01, .001):
assert_close(
derivative(lambda tau: lemmon2000_air_A0(tau, .5),
rat,
dx=rat * 1e-5), lemmon2000_air_dA0_dtau(rat, .5))
def test_lemmon2000_air_d2A0_dtau2():
assert_close(lemmon2000_air_d2A0_dtau2(126.192 / 200.0, 13000 / 11183.9),
-6.260482844274295,
rtol=1e-13)
for rat in (1000.0, 100.0, 10.0, 5.0, 3.0, 2.5, 2.0, 1.5, 1.0, .5, .2, .1,
.01, .001):
assert_close(
derivative(lambda tau: lemmon2000_air_dA0_dtau(tau, .5),
rat,
dx=rat * 1e-5), lemmon2000_air_d2A0_dtau2(rat, .5))
def test_lemmon2000_air_dAr_dtau():
assert_close(lemmon2000_air_dAr_dtau(0.36842, 0.15880050154579475),
-0.20189573196786642,
rtol=1e-13)
for rat in (1000.0, 100.0, 10.0, 5.0, 3.0, 2.5, 2.0, 1.5, 1.0, .5, .2, .1,
.01, .001):
assert_close(
derivative(lambda tau: lemmon2000_air_Ar(tau, .5),
rat,
dx=rat * 1e-5), lemmon2000_air_dAr_dtau(rat, .5))
def test_lemmon2000_air_d2Ar_ddeltadtau():
assert_close(lemmon2000_air_d2Ar_ddeltadtau(0.36842, 0.15880050154579475),
-1.261887383081615,
rtol=1e-13)
for rat in (1000.0, 100.0, 10.0, 5.0, 3.0, 2.5, 2.0, 1.5, 1.0, .5, .2, .1,
.01, .001):
assert_close(
derivative(lambda tau: lemmon2000_air_dAr_ddelta(tau, .5),
rat,
dx=rat * 1e-5), lemmon2000_air_d2Ar_ddeltadtau(rat, .5))
def test_lemmon2000_air_d4Ar_ddelta4():
assert_close(lemmon2000_air_d4Ar_ddelta4(0.36842, 0.15880050154579475),
1.0647113576834495,
rtol=1e-13)
for rat in (1000.0, 100.0, 10.0, 5.0, 3.0, 2.5, 2.0, 1.5, 1.0, .5, .2, .1,
.01, .001):
assert_close(
derivative(lambda delta: lemmon2000_air_d3Ar_ddelta3(.5, delta),
rat,
dx=rat * 1e-5), lemmon2000_air_d4Ar_ddelta4(.5, rat))
def test_lemmon2000_air_d2Ar_ddelta2():
assert_close(lemmon2000_air_d2Ar_ddelta2(0.36842, 0.15880050154579475),
0.15165011962677075,
rtol=1e-13)
for rat in (1000.0, 100.0, 10.0, 5.0, 3.0, 2.5, 2.0, 1.5, 1.0, .5, .2, .1,
.01, .001):
assert_close(
derivative(lambda delta: lemmon2000_air_dAr_ddelta(.5, delta),
rat,
dx=rat * 1e-5), lemmon2000_air_d2Ar_ddelta2(.5, rat))
def test_lemmon2000_air_d4Ar_dtau4():
assert_close(lemmon2000_air_d4Ar_dtau4(132.6312 / 200.0, 13000 / 10447.7),
-8.197368061417675,
rtol=1e-14)
for rat in (1000.0, 100.0, 10.0, 5.0, 3.0, 2.5, 2.0, 1.5, 1.0, .5, .2, .1,
.01, .001):
assert_close(
derivative(lambda tau: lemmon2000_air_d3Ar_dtau3(tau, .5),
rat,
dx=rat * 1e-5), lemmon2000_air_d4Ar_dtau4(rat, .5))
def test_lemmon2000_air_d3Ar_dtau3():
assert_close(lemmon2000_air_d3Ar_dtau3(132.6312 / 200.0, 13000 / 10447.7),
0.27922007457420017,
rtol=1e-13)
for rat in (1000.0, 100.0, 10.0, 5.0, 3.0, 2.5, 2.0, 1.5, 1.0, .5, .2, .1,
.01, .001):
assert_close(
derivative(lambda tau: lemmon2000_air_d2Ar_dtau2(tau, .5),
rat,
dx=rat * 1e-5), lemmon2000_air_d3Ar_dtau3(rat, .5))
def test_lemmon2000_air_d2Ar_dtau2():
assert_close(lemmon2000_air_d2Ar_dtau2(132.6312 / 200.0, 13000 / 10447.7),
-0.7632109061747537,
rtol=1e-14)
for rat in (1000.0, 100.0, 10.0, 5.0, 3.0, 2.5, 2.0, 1.5, 1.0, .5, .2, .1,
.01, .001):
assert_close(
derivative(lambda tau: lemmon2000_air_dAr_dtau(tau, .5),
rat,
dx=rat * 1e-5), lemmon2000_air_d2Ar_dtau2(rat, .5))
def test_lemmon2000_air_d3Ar_ddelta3():
assert_close(lemmon2000_air_d3Ar_ddelta3(0.36842, 0.15880050154579475),
-0.09682239073996685,
rtol=1e-13)
for rat in (1000.0, 100.0, 10.0, 5.0, 3.0, 2.5, 2.0, 1.5, 1.0, .5, .2, .1,
.01, .001):
assert_close(
derivative(lambda delta: lemmon2000_air_d2Ar_ddelta2(.5, delta),
rat,
dx=rat * 1e-5), lemmon2000_air_d3Ar_ddelta3(.5, rat))
def test_lemmon2000_air_d3Ar_ddelta2dtau():
assert_close(lemmon2000_air_d3Ar_ddelta2dtau(132.6312 / 200.0,
13000 / 10447.7),
0.014417881989408202,
rtol=1e-13)
for rat in (1000.0, 100.0, 10.0, 5.0, 3.0, 2.5, 2.0, 1.5, 1.0, .5, .2, .1,
.01, .001):
assert_close(
derivative(lambda tau: lemmon2000_air_d2Ar_ddelta2(tau, .5),
rat,
dx=rat * 1e-5),
lemmon2000_air_d3Ar_ddelta2dtau(rat, .5))
def test_lemmon2000_air_d3Ar_ddeltadtau2():
assert_close(lemmon2000_air_d3Ar_ddeltadtau2(132.6312 / 200.0,
13000 / 10447.7),
-0.19089212184849963,
rtol=1e-13)
for rat in (1000.0, 100.0, 10.0, 5.0, 3.0, 2.5, 2.0, 1.5, 1.0, .5, .2, .1,
.01, .001):
assert_close(
derivative(lambda tau: lemmon2000_air_d2Ar_ddeltadtau(tau, .5),
rat,
dx=rat * 1e-5),
lemmon2000_air_d3Ar_ddeltadtau2(rat, .5))
def test_TEOS10_CAAW_derivatives():
assert_close1d(TEOS10_CAAW_derivatives(200.0)[:3],
(1.05493575e-09, -1.525350000000001e-12, -1.13436375e-13),
rtol=1e-13)
assert_close(derivative(lambda T: TEOS10_CAAW_derivatives(T)[-2],
200.0,
dx=200 * 1e-7),
TEOS10_CAAW_derivatives(200)[-1],
rtol=1e-8)
assert_close1d(TEOS10_CAAW_derivatives(300.0),
(8.019777407407409e-10, -1.9610345679012353e-12,
1.700556378600824e-14, -1.0129827160493834e-16),
rtol=1e-13)
def test_lemmon2000_air_d3Ar_ddelta2dtau():
assert_close(lemmon2000_air_d4Ar_ddelta2dtau2(132.6312 / 200.0,
13000 / 10447.7),
0.11968731127306076,
rtol=1e-13)
for rat in (1000.0, 100.0, 10.0, 5.0, 3.0, 2.5, 2.0, 1.5, 1.0, .5, .2, .1,
.01, .001):
assert_close(
derivative(lambda tau: lemmon2000_air_d3Ar_ddelta2dtau(tau, .5),
rat,
dx=rat * 1e-5),
lemmon2000_air_d4Ar_ddelta2dtau2(rat, .5))
def test_lemmon2000_air_d4Ar_ddeltadtau3():
assert_close(lemmon2000_air_d4Ar_ddeltadtau3(132.6312 / 200.0,
13000 / 10447.7),
2.077739387492131,
rtol=1e-13)
for rat in (1000.0, 100.0, 10.0, 5.0, 3.0, 2.5, 2.0, 1.5, 1.0, .5, .2, .1,
.01, .001):
assert_close(
derivative(lambda tau: lemmon2000_air_d3Ar_ddeltadtau2(tau, .5),
rat,
dx=rat * 1e-5),
lemmon2000_air_d4Ar_ddeltadtau3(rat, .5))
def test_Antoine_AB_fit_extrapolate():
T = 178.01
Psat, dPsat_dT, d2Psat_dT2 = (0.03946094565666715, 0.006781441203850251, 0.0010801244983894853)
A, B = (27.358925161569008, 5445.569591293226)
C = 0.0
assert_close(Psat, Antoine(T, A, B, C, base=e), rtol=1e-10)
dPsat_dT_num = derivative(lambda T: Antoine(T, A, B, C, base=e), T, dx=T*1e-9)
assert_close(dPsat_dT_num, dPsat_dT, rtol=1e-7)
# d2Psat_dT2_num = derivative(lambda T: Antoine(T, A, B, C, base=e), T, dx=T*1e-7, n=2, order=13)
d2Psat_dT2_analytical = B*(B/T - 2)*exp(A - B/T)/T**3
# Second derivative does not match, but is similar - small jump
assert_close(d2Psat_dT2, d2Psat_dT2_analytical, rtol=1e-2)