|
1
|
|
|
# Copyright (c) 2008-2015 MetPy Developers. |
|
2
|
|
|
# Distributed under the terms of the BSD 3-Clause License. |
|
3
|
|
|
# SPDX-License-Identifier: BSD-3-Clause |
|
4
|
|
|
"""Test the `thermo` module.""" |
|
5
|
|
|
|
|
6
|
|
|
import numpy as np |
|
7
|
|
|
import pytest |
|
8
|
|
|
|
|
9
|
|
|
from metpy.calc import (cape_cin, density, dewpoint, dewpoint_rh, dry_lapse, el, |
|
10
|
|
|
equivalent_potential_temperature, |
|
11
|
|
|
isentropic_interpolation, |
|
12
|
|
|
lcl, lfc, mixing_ratio, |
|
13
|
|
|
mixing_ratio_from_specific_humidity, moist_lapse, |
|
14
|
|
|
most_unstable_parcel, parcel_profile, potential_temperature, |
|
15
|
|
|
psychrometric_vapor_pressure_wet, |
|
16
|
|
|
relative_humidity_from_mixing_ratio, |
|
17
|
|
|
relative_humidity_from_specific_humidity, |
|
18
|
|
|
relative_humidity_wet_psychrometric, |
|
19
|
|
|
saturation_mixing_ratio, |
|
20
|
|
|
saturation_vapor_pressure, vapor_pressure, |
|
21
|
|
|
virtual_potential_temperature, virtual_temperature) |
|
22
|
|
|
|
|
23
|
|
|
from metpy.calc.thermo import _find_append_zero_crossings |
|
24
|
|
|
from metpy.testing import assert_almost_equal, assert_array_almost_equal, assert_nan |
|
25
|
|
|
from metpy.units import units |
|
26
|
|
|
|
|
27
|
|
|
|
|
28
|
|
|
def test_potential_temperature(): |
|
29
|
|
|
"""Test potential_temperature calculation.""" |
|
30
|
|
|
temp = np.array([278., 283., 291., 298.]) * units.kelvin |
|
31
|
|
|
pres = np.array([900., 500., 300., 100.]) * units.mbar |
|
32
|
|
|
real_th = np.array([286.493, 344.961, 410.4335, 575.236]) * units.kelvin |
|
33
|
|
|
assert_array_almost_equal(potential_temperature(pres, temp), real_th, 3) |
|
34
|
|
|
|
|
35
|
|
|
|
|
36
|
|
|
def test_scalar(): |
|
37
|
|
|
"""Test potential_temperature accepts scalar values.""" |
|
38
|
|
|
assert_almost_equal(potential_temperature(1000. * units.mbar, 293. * units.kelvin), |
|
39
|
|
|
293. * units.kelvin, 4) |
|
40
|
|
|
assert_almost_equal(potential_temperature(800. * units.mbar, 293. * units.kelvin), |
|
41
|
|
|
312.2828 * units.kelvin, 4) |
|
42
|
|
|
|
|
43
|
|
|
|
|
44
|
|
|
def test_fahrenheit(): |
|
45
|
|
|
"""Test that potential_temperature handles temperature values in Fahrenheit.""" |
|
46
|
|
|
assert_almost_equal(potential_temperature(800. * units.mbar, 68. * units.degF), |
|
47
|
|
|
(312.444 * units.kelvin).to(units.degF), 2) |
|
48
|
|
|
|
|
49
|
|
|
|
|
50
|
|
|
def test_pot_temp_inhg(): |
|
51
|
|
|
"""Test that potential_temperature can handle pressure not in mb (issue #165).""" |
|
52
|
|
|
assert_almost_equal(potential_temperature(29.92 * units.inHg, 29 * units.degC), |
|
53
|
|
|
301.019735 * units.kelvin, 4) |
|
54
|
|
|
|
|
55
|
|
|
|
|
56
|
|
|
def test_dry_lapse(): |
|
57
|
|
|
"""Test dry_lapse calculation.""" |
|
58
|
|
|
levels = np.array([1000, 900, 864.89]) * units.mbar |
|
59
|
|
|
temps = dry_lapse(levels, 303.15 * units.kelvin) |
|
60
|
|
|
assert_array_almost_equal(temps, |
|
61
|
|
|
np.array([303.15, 294.16, 290.83]) * units.kelvin, 2) |
|
62
|
|
|
|
|
63
|
|
|
|
|
64
|
|
|
def test_dry_lapse_2_levels(): |
|
65
|
|
|
"""Test dry_lapse calculation when given only two levels.""" |
|
66
|
|
|
temps = dry_lapse(np.array([1000., 500.]) * units.mbar, 293. * units.kelvin) |
|
67
|
|
|
assert_array_almost_equal(temps, [293., 240.3723] * units.kelvin, 4) |
|
68
|
|
|
|
|
69
|
|
|
|
|
70
|
|
|
def test_moist_lapse(): |
|
71
|
|
|
"""Test moist_lapse calculation.""" |
|
72
|
|
|
temp = moist_lapse(np.array([1000., 800., 600., 500., 400.]) * units.mbar, |
|
73
|
|
|
293. * units.kelvin) |
|
74
|
|
|
true_temp = np.array([293, 284.64, 272.81, 264.42, 252.91]) * units.kelvin |
|
75
|
|
|
assert_array_almost_equal(temp, true_temp, 2) |
|
76
|
|
|
|
|
77
|
|
|
|
|
78
|
|
|
def test_moist_lapse_degc(): |
|
79
|
|
|
"""Test moist_lapse with Celsius temperatures.""" |
|
80
|
|
|
temp = moist_lapse(np.array([1000., 800., 600., 500., 400.]) * units.mbar, |
|
81
|
|
|
19.85 * units.degC) |
|
82
|
|
|
true_temp = np.array([293, 284.64, 272.81, 264.42, 252.91]) * units.kelvin |
|
83
|
|
|
assert_array_almost_equal(temp, true_temp, 2) |
|
84
|
|
|
|
|
85
|
|
|
|
|
86
|
|
|
def test_parcel_profile(): |
|
87
|
|
|
"""Test parcel profile calculation.""" |
|
88
|
|
|
levels = np.array([1000., 900., 800., 700., 600., 500., 400.]) * units.mbar |
|
89
|
|
|
true_prof = np.array([303.15, 294.16, 288.026, 283.073, 277.058, 269.402, |
|
90
|
|
|
258.966]) * units.kelvin |
|
91
|
|
|
|
|
92
|
|
|
prof = parcel_profile(levels, 30. * units.degC, 20. * units.degC) |
|
93
|
|
|
assert_array_almost_equal(prof, true_prof, 2) |
|
94
|
|
|
|
|
95
|
|
|
|
|
96
|
|
|
def test_parcel_profile_saturated(): |
|
97
|
|
|
"""Test parcel_profile works when LCL in levels (issue #232).""" |
|
98
|
|
|
levels = np.array([1000., 700., 500.]) * units.mbar |
|
99
|
|
|
true_prof = np.array([296.95, 284.381, 271.123]) * units.kelvin |
|
100
|
|
|
|
|
101
|
|
|
prof = parcel_profile(levels, 23.8 * units.degC, 23.8 * units.degC) |
|
102
|
|
|
assert_array_almost_equal(prof, true_prof, 2) |
|
103
|
|
|
|
|
104
|
|
|
|
|
105
|
|
|
def test_sat_vapor_pressure(): |
|
106
|
|
|
"""Test saturation_vapor_pressure calculation.""" |
|
107
|
|
|
temp = np.array([5., 10., 18., 25.]) * units.degC |
|
108
|
|
|
real_es = np.array([8.72, 12.27, 20.63, 31.67]) * units.mbar |
|
109
|
|
|
assert_array_almost_equal(saturation_vapor_pressure(temp), real_es, 2) |
|
110
|
|
|
|
|
111
|
|
|
|
|
112
|
|
|
def test_sat_vapor_pressure_scalar(): |
|
113
|
|
|
"""Test saturation_vapor_pressure handles scalar values.""" |
|
114
|
|
|
es = saturation_vapor_pressure(0 * units.degC) |
|
115
|
|
|
assert_almost_equal(es, 6.112 * units.mbar, 3) |
|
116
|
|
|
|
|
117
|
|
|
|
|
118
|
|
|
def test_sat_vapor_pressure_fahrenheit(): |
|
119
|
|
|
"""Test saturation_vapor_pressure handles temperature in Fahrenheit.""" |
|
120
|
|
|
temp = np.array([50., 68.]) * units.degF |
|
121
|
|
|
real_es = np.array([12.2717, 23.3695]) * units.mbar |
|
122
|
|
|
assert_array_almost_equal(saturation_vapor_pressure(temp), real_es, 4) |
|
123
|
|
|
|
|
124
|
|
|
|
|
125
|
|
|
def test_basic_dewpoint_rh(): |
|
126
|
|
|
"""Test dewpoint_rh function.""" |
|
127
|
|
|
temp = np.array([30., 25., 10., 20., 25.]) * units.degC |
|
128
|
|
|
rh = np.array([30., 45., 55., 80., 85.]) / 100. |
|
129
|
|
|
|
|
130
|
|
|
real_td = np.array([11, 12, 1, 16, 22]) * units.degC |
|
131
|
|
|
assert_array_almost_equal(real_td, dewpoint_rh(temp, rh), 0) |
|
132
|
|
|
|
|
133
|
|
|
|
|
134
|
|
|
def test_scalar_dewpoint_rh(): |
|
135
|
|
|
"""Test dewpoint_rh with scalar values.""" |
|
136
|
|
|
td = dewpoint_rh(10.6 * units.degC, 0.37) |
|
137
|
|
|
assert_almost_equal(td, 26. * units.degF, 0) |
|
138
|
|
|
|
|
139
|
|
|
|
|
140
|
|
|
def test_dewpoint(): |
|
141
|
|
|
"""Test dewpoint calculation.""" |
|
142
|
|
|
assert_almost_equal(dewpoint(6.112 * units.mbar), 0. * units.degC, 2) |
|
143
|
|
|
|
|
144
|
|
|
|
|
145
|
|
|
def test_dewpoint_weird_units(): |
|
146
|
|
|
"""Test dewpoint using non-standard units. |
|
147
|
|
|
|
|
148
|
|
|
Revealed from odd dimensionless units and ending up using numpy.ma math |
|
149
|
|
|
functions instead of numpy ones. |
|
150
|
|
|
""" |
|
151
|
|
|
assert_almost_equal(dewpoint(15825.6 * units('g * mbar / kg')), |
|
152
|
|
|
13.8564 * units.degC, 4) |
|
153
|
|
|
|
|
154
|
|
|
|
|
155
|
|
|
def test_mixing_ratio(): |
|
156
|
|
|
"""Test mixing ratio calculation.""" |
|
157
|
|
|
p = 998. * units.mbar |
|
158
|
|
|
e = 73.75 * units.mbar |
|
159
|
|
|
assert_almost_equal(mixing_ratio(e, p), 0.04963, 2) |
|
160
|
|
|
|
|
161
|
|
|
|
|
162
|
|
|
def test_vapor_pressure(): |
|
163
|
|
|
"""Test vapor pressure calculation.""" |
|
164
|
|
|
assert_almost_equal(vapor_pressure(998. * units.mbar, 0.04963), |
|
165
|
|
|
73.74925 * units.mbar, 5) |
|
166
|
|
|
|
|
167
|
|
|
|
|
168
|
|
|
def test_lcl(): |
|
169
|
|
|
"""Test LCL calculation.""" |
|
170
|
|
|
lcl_pressure, lcl_temperature = lcl(1000. * units.mbar, 30. * units.degC, 20. * units.degC) |
|
171
|
|
|
assert_almost_equal(lcl_pressure, 864.761 * units.mbar, 2) |
|
172
|
|
|
assert_almost_equal(lcl_temperature, 17.676 * units.degC, 2) |
|
173
|
|
|
|
|
174
|
|
|
|
|
175
|
|
|
def test_lcl_convergence(): |
|
176
|
|
|
"""Test LCL calculation convergence failure.""" |
|
177
|
|
|
with pytest.raises(RuntimeError): |
|
178
|
|
|
lcl(1000. * units.mbar, 30. * units.degC, 20. * units.degC, max_iters=2) |
|
179
|
|
View Code Duplication |
|
|
|
|
|
|
|
180
|
|
|
|
|
181
|
|
|
def test_lfc_basic(): |
|
182
|
|
|
"""Test LFC calculation.""" |
|
183
|
|
|
levels = np.array([959., 779.2, 751.3, 724.3, 700., 269.]) * units.mbar |
|
184
|
|
|
temperatures = np.array([22.2, 14.6, 12., 9.4, 7., -49.]) * units.celsius |
|
185
|
|
|
dewpoints = np.array([19., -11.2, -10.8, -10.4, -10., -53.2]) * units.celsius |
|
186
|
|
|
l = lfc(levels, temperatures, dewpoints) |
|
187
|
|
|
assert_almost_equal(l[0], 727.468 * units.mbar, 2) |
|
188
|
|
|
assert_almost_equal(l[1], 9.705 * units.celsius, 2) |
|
189
|
|
|
|
|
190
|
|
|
|
|
191
|
|
|
def test_no_lfc(): |
|
192
|
|
|
"""Test LFC calculation when there is no LFC in the data.""" |
|
193
|
|
|
levels = np.array([959., 867.9, 779.2, 647.5, 472.5, 321.9, 251.]) * units.mbar |
|
194
|
|
|
temperatures = np.array([22.2, 17.4, 14.6, 1.4, -17.6, -39.4, -52.5]) * units.celsius |
|
195
|
|
|
dewpoints = np.array([9., 4.3, -21.2, -26.7, -31., -53.3, -66.7]) * units.celsius |
|
196
|
|
|
lfc_pressure, lfc_temperature = lfc(levels, temperatures, dewpoints) |
|
197
|
|
|
assert assert_nan(lfc_pressure, levels.units) |
|
198
|
|
|
assert assert_nan(lfc_temperature, temperatures.units) |
|
199
|
|
|
|
|
200
|
|
|
|
|
201
|
|
|
def test_lfc_inversion(): |
|
202
|
|
|
"""Test LFC when there is an inversion to be sure we don't pick that.""" |
|
203
|
|
|
levels = np.array([963., 789., 782.3, 754.8, 728.1, 727., 700., |
|
204
|
|
|
571., 450., 300., 248.]) * units.mbar |
|
205
|
|
|
temperatures = np.array([25.4, 18.4, 17.8, 15.4, 12.9, 12.8, |
|
206
|
|
|
10., -3.9, -16.3, -41.1, -51.5]) * units.celsius |
|
207
|
|
|
dewpoints = np.array([20.4, 0.4, -0.5, -4.3, -8., -8.2, -9., |
|
208
|
|
|
-23.9, -33.3, -54.1, -63.5]) * units.celsius |
|
209
|
|
|
l = lfc(levels, temperatures, dewpoints) |
|
210
|
|
|
assert_almost_equal(l[0], 706.0103 * units.mbar, 2) |
|
211
|
|
|
assert_almost_equal(l[1], 10.6232 * units.celsius, 2) |
|
212
|
|
|
|
|
213
|
|
|
|
|
214
|
|
|
def test_lfc_equals_lcl(): |
|
215
|
|
|
"""Test LFC when there is no cap and the lfc is equal to the lcl.""" |
|
216
|
|
|
levels = np.array([912., 905.3, 874.4, 850., 815.1, 786.6, 759.1, |
|
217
|
|
|
748., 732.2, 700., 654.8]) * units.mbar |
|
218
|
|
|
temperatures = np.array([29.4, 28.7, 25.2, 22.4, 19.4, 16.8, |
|
219
|
|
|
14.3, 13.2, 12.6, 11.4, 7.1]) * units.celsius |
|
220
|
|
|
dewpoints = np.array([18.4, 18.1, 16.6, 15.4, 13.2, 11.4, 9.6, |
|
221
|
|
|
8.8, 0., -18.6, -22.9]) * units.celsius |
|
222
|
|
|
l = lfc(levels, temperatures, dewpoints) |
|
223
|
|
|
assert_almost_equal(l[0], 777.0333 * units.mbar, 2) |
|
224
|
|
|
assert_almost_equal(l[1], 15.8714 * units.celsius, 2) |
|
225
|
|
|
|
|
226
|
|
|
|
|
227
|
|
|
def test_saturation_mixing_ratio(): |
|
228
|
|
|
"""Test saturation mixing ratio calculation.""" |
|
229
|
|
|
p = 999. * units.mbar |
|
230
|
|
|
t = 288. * units.kelvin |
|
231
|
|
|
assert_almost_equal(saturation_mixing_ratio(p, t), .01068, 3) |
|
232
|
|
|
|
|
233
|
|
|
|
|
234
|
|
|
def test_equivalent_potential_temperature(): |
|
235
|
|
|
"""Test equivalent potential temperature calculation.""" |
|
236
|
|
|
p = 999. * units.mbar |
|
237
|
|
|
t = 288. * units.kelvin |
|
238
|
|
|
ept = equivalent_potential_temperature(p, t) |
|
239
|
|
|
assert_almost_equal(ept, 315.9548 * units.kelvin, 3) |
|
240
|
|
|
|
|
241
|
|
|
|
|
242
|
|
|
def test_virtual_temperature(): |
|
243
|
|
|
"""Test virtual temperature calculation.""" |
|
244
|
|
|
t = 288. * units.kelvin |
|
245
|
|
|
qv = .0016 # kg/kg |
|
246
|
|
|
tv = virtual_temperature(t, qv) |
|
247
|
|
|
assert_almost_equal(tv, 288.2796 * units.kelvin, 3) |
|
248
|
|
|
|
|
249
|
|
|
|
|
250
|
|
|
def test_virtual_potential_temperature(): |
|
251
|
|
|
"""Test virtual potential temperature calculation.""" |
|
252
|
|
|
p = 999. * units.mbar |
|
253
|
|
|
t = 288. * units.kelvin |
|
254
|
|
|
qv = .0016 # kg/kg |
|
255
|
|
|
theta_v = virtual_potential_temperature(p, t, qv) |
|
256
|
|
|
assert_almost_equal(theta_v, 288.3620 * units.kelvin, 3) |
|
257
|
|
|
|
|
258
|
|
|
|
|
259
|
|
|
def test_density(): |
|
260
|
|
|
"""Test density calculation.""" |
|
261
|
|
|
p = 999. * units.mbar |
|
262
|
|
|
t = 288. * units.kelvin |
|
263
|
|
|
qv = .0016 # kg/kg |
|
264
|
|
|
rho = density(p, t, qv).to(units.kilogram / units.meter ** 3) |
|
265
|
|
|
assert_almost_equal(rho, 1.2072 * (units.kilogram / units.meter ** 3), 3) |
|
266
|
|
|
|
|
267
|
|
|
|
|
268
|
|
|
def test_el(): |
|
269
|
|
|
"""Test equilibrium layer calculation.""" |
|
270
|
|
|
levels = np.array([959., 779.2, 751.3, 724.3, 700., 269.]) * units.mbar |
|
271
|
|
|
temperatures = np.array([22.2, 14.6, 12., 9.4, 7., -38.]) * units.celsius |
|
272
|
|
|
dewpoints = np.array([19., -11.2, -10.8, -10.4, -10., -53.2]) * units.celsius |
|
273
|
|
|
el_pressure, el_temperature = el(levels, temperatures, dewpoints) |
|
274
|
|
|
assert_almost_equal(el_pressure, 520.8700 * units.mbar, 3) |
|
275
|
|
|
assert_almost_equal(el_temperature, -11.7027 * units.degC, 3) |
|
276
|
|
|
|
|
277
|
|
|
|
|
278
|
|
|
def test_no_el(): |
|
279
|
|
|
"""Test equilibrium layer calculation when there is no EL in the data.""" |
|
280
|
|
|
levels = np.array([959., 867.9, 779.2, 647.5, 472.5, 321.9, 251.]) * units.mbar |
|
281
|
|
|
temperatures = np.array([22.2, 17.4, 14.6, 1.4, -17.6, -39.4, -52.5]) * units.celsius |
|
282
|
|
|
dewpoints = np.array([19., 14.3, -11.2, -16.7, -21., -43.3, -56.7]) * units.celsius |
|
283
|
|
|
el_pressure, el_temperature = el(levels, temperatures, dewpoints) |
|
284
|
|
|
assert assert_nan(el_pressure, levels.units) |
|
285
|
|
|
assert assert_nan(el_temperature, temperatures.units) |
|
286
|
|
|
|
|
287
|
|
|
|
|
288
|
|
|
def test_no_el_multi_crossing(): |
|
289
|
|
|
"""Test el calculation with no el and severel parcel path-profile crossings.""" |
|
290
|
|
|
levels = np.array([918., 911., 880., 873.9, 850., 848., 843.5, 818., 813.8, 785., |
|
291
|
|
|
773., 763., 757.5, 730.5, 700., 679., 654.4, 645., |
|
292
|
|
|
643.9]) * units.mbar |
|
293
|
|
|
temperatures = np.array([24.2, 22.8, 19.6, 19.1, 17., 16.8, 16.5, 15., 14.9, 14.4, 16.4, |
|
294
|
|
|
16.2, 15.7, 13.4, 10.6, 8.4, 5.7, 4.6, 4.5]) * units.celsius |
|
295
|
|
|
dewpoints = np.array([19.5, 17.8, 16.7, 16.5, 15.8, 15.7, 15.3, 13.1, 12.9, 11.9, 6.4, |
|
296
|
|
|
3.2, 2.6, -0.6, -4.4, -6.6, -9.3, -10.4, -10.5]) * units.celsius |
|
297
|
|
|
el_pressure, el_temperature = el(levels, temperatures, dewpoints) |
|
298
|
|
|
assert assert_nan(el_pressure, levels.units) |
|
299
|
|
|
assert assert_nan(el_temperature, temperatures.units) |
|
300
|
|
|
|
|
301
|
|
|
|
|
302
|
|
|
def test_el_lfc_equals_lcl(): |
|
303
|
|
|
"""Test equilibrium layer calculation when the lfc equals the lcl.""" |
|
304
|
|
|
levels = np.array([912., 905.3, 874.4, 850., 815.1, 786.6, 759.1, 748., |
|
305
|
|
|
732.3, 700., 654.8, 606.8, 562.4, 501.8, 500., 482., |
|
306
|
|
|
400., 393.3, 317.1, 307., 300., 252.7, 250., 200., |
|
307
|
|
|
199.3, 197., 190., 172., 156.6, 150., 122.9, 112., |
|
308
|
|
|
106.2, 100.]) * units.mbar |
|
309
|
|
|
temperatures = np.array([29.4, 28.7, 25.2, 22.4, 19.4, 16.8, 14.3, |
|
310
|
|
|
13.2, 12.6, 11.4, 7.1, 2.2, -2.7, -10.1, |
|
311
|
|
|
-10.3, -12.4, -23.3, -24.4, -38., -40.1, -41.1, |
|
312
|
|
|
-49.8, -50.3, -59.1, -59.1, -59.3, -59.7, -56.3, |
|
313
|
|
|
-56.9, -57.1, -59.1, -60.1, -58.6, -56.9]) * units.celsius |
|
314
|
|
|
dewpoints = np.array([18.4, 18.1, 16.6, 15.4, 13.2, 11.4, 9.6, 8.8, 0., |
|
315
|
|
|
-18.6, -22.9, -27.8, -32.7, -40.1, -40.3, -42.4, -53.3, |
|
316
|
|
|
-54.4, -68., -70.1, -70., -70., -70., -70., -70., -70., |
|
317
|
|
|
-70., -70., -70., -70., -70., -70., -70., -70.]) * units.celsius |
|
318
|
|
|
el_pressure, el_temperature = el(levels, temperatures, dewpoints) |
|
319
|
|
|
assert_almost_equal(el_pressure, 175.8684 * units.mbar, 3) |
|
320
|
|
|
assert_almost_equal(el_temperature, -57.0307 * units.degC, 3) |
|
321
|
|
|
|
|
322
|
|
|
|
|
323
|
|
|
def test_wet_psychrometric_vapor_pressure(): |
|
324
|
|
|
"""Test calculation of vapor pressure from wet and dry bulb temperatures.""" |
|
325
|
|
|
p = 1013.25 * units.mbar |
|
326
|
|
|
dry_bulb_temperature = 20. * units.degC |
|
327
|
|
|
wet_bulb_temperature = 18. * units.degC |
|
328
|
|
|
psychrometric_vapor_pressure = psychrometric_vapor_pressure_wet(dry_bulb_temperature, |
|
329
|
|
|
wet_bulb_temperature, p) |
|
330
|
|
|
assert_almost_equal(psychrometric_vapor_pressure, 19.3673 * units.mbar, 3) |
|
331
|
|
|
|
|
332
|
|
|
|
|
333
|
|
|
def test_wet_psychrometric_rh(): |
|
334
|
|
|
"""Test calculation of relative humidity from wet and dry bulb temperatures.""" |
|
335
|
|
|
p = 1013.25 * units.mbar |
|
336
|
|
|
dry_bulb_temperature = 20. * units.degC |
|
337
|
|
|
wet_bulb_temperature = 18. * units.degC |
|
338
|
|
|
psychrometric_rh = relative_humidity_wet_psychrometric(dry_bulb_temperature, |
|
339
|
|
|
wet_bulb_temperature, p) |
|
340
|
|
|
assert_almost_equal(psychrometric_rh, 82.8747 * units.percent, 3) |
|
341
|
|
|
|
|
342
|
|
|
|
|
343
|
|
|
def test_wet_psychrometric_rh_kwargs(): |
|
344
|
|
|
"""Test calculation of relative humidity from wet and dry bulb temperatures.""" |
|
345
|
|
|
p = 1013.25 * units.mbar |
|
346
|
|
|
dry_bulb_temperature = 20. * units.degC |
|
347
|
|
|
wet_bulb_temperature = 18. * units.degC |
|
348
|
|
|
coeff = 6.1e-4 / units.kelvin |
|
349
|
|
|
psychrometric_rh = relative_humidity_wet_psychrometric(dry_bulb_temperature, |
|
350
|
|
|
wet_bulb_temperature, p, |
|
351
|
|
|
psychrometer_coefficient=coeff) |
|
352
|
|
|
assert_almost_equal(psychrometric_rh, 82.9701 * units.percent, 3) |
|
353
|
|
|
|
|
354
|
|
|
|
|
355
|
|
|
def test_rh_mixing_ratio(): |
|
356
|
|
|
"""Tests relative humidity from mixing ratio.""" |
|
357
|
|
|
p = 1013.25 * units.mbar |
|
358
|
|
|
temperature = 20. * units.degC |
|
359
|
|
|
w = 0.012 |
|
360
|
|
|
rh = relative_humidity_from_mixing_ratio(w, temperature, p) |
|
361
|
|
|
assert_almost_equal(rh, 81.7219 * units.percent, 3) |
|
362
|
|
|
|
|
363
|
|
|
|
|
364
|
|
View Code Duplication |
def test_mixing_ratio_from_specific_humidity(): |
|
|
|
|
|
|
365
|
|
|
"""Tests mixing ratio from specific humidity.""" |
|
366
|
|
|
q = 0.012 |
|
367
|
|
|
w = mixing_ratio_from_specific_humidity(q) |
|
368
|
|
|
assert_almost_equal(w, 0.01215, 3) |
|
369
|
|
|
|
|
370
|
|
|
|
|
371
|
|
|
def test_rh_specific_humidity(): |
|
372
|
|
|
"""Tests relative humidity from specific humidity.""" |
|
373
|
|
|
p = 1013.25 * units.mbar |
|
374
|
|
|
temperature = 20. * units.degC |
|
375
|
|
|
q = 0.012 |
|
376
|
|
|
rh = relative_humidity_from_specific_humidity(q, temperature, p) |
|
377
|
|
|
assert_almost_equal(rh, 82.7145 * units.percent, 3) |
|
378
|
|
|
|
|
379
|
|
|
|
|
380
|
|
|
def test_cape_cin(): |
|
381
|
|
|
"""Tests the basic CAPE and CIN calculation.""" |
|
382
|
|
|
p = np.array([959., 779.2, 751.3, 724.3, 700., 269.]) * units.mbar |
|
383
|
|
|
temperature = np.array([22.2, 14.6, 12., 9.4, 7., -38.]) * units.celsius |
|
384
|
|
|
dewpoint = np.array([19., -11.2, -10.8, -10.4, -10., -53.2]) * units.celsius |
|
385
|
|
|
parcel_prof = parcel_profile(p, temperature[0], dewpoint[0]) |
|
386
|
|
View Code Duplication |
cape, cin = cape_cin(p, temperature, dewpoint, parcel_prof) |
|
|
|
|
|
|
387
|
|
|
assert_almost_equal(cape, 58.0368212 * units('joule / kilogram'), 6) |
|
388
|
|
|
assert_almost_equal(cin, -89.8073512 * units('joule / kilogram'), 6) |
|
389
|
|
|
|
|
390
|
|
|
|
|
391
|
|
|
def test_cape_cin_no_el(): |
|
392
|
|
|
"""Tests that CAPE works with no EL.""" |
|
393
|
|
|
p = np.array([959., 779.2, 751.3, 724.3]) * units.mbar |
|
394
|
|
|
temperature = np.array([22.2, 14.6, 12., 9.4]) * units.celsius |
|
395
|
|
|
dewpoint = np.array([19., -11.2, -10.8, -10.4]) * units.celsius |
|
396
|
|
|
parcel_prof = parcel_profile(p, temperature[0], dewpoint[0]).to('degC') |
|
397
|
|
|
cape, cin = cape_cin(p, temperature, dewpoint, parcel_prof) |
|
398
|
|
|
assert_almost_equal(cape, 0.08750805 * units('joule / kilogram'), 6) |
|
399
|
|
|
assert_almost_equal(cin, -89.8073512 * units('joule / kilogram'), 6) |
|
400
|
|
|
|
|
401
|
|
|
|
|
402
|
|
|
def test_cape_cin_no_lfc(): |
|
403
|
|
|
"""Tests that CAPE is zero with no LFC.""" |
|
404
|
|
|
p = np.array([959., 779.2, 751.3, 724.3, 700., 269.]) * units.mbar |
|
405
|
|
|
temperature = np.array([22.2, 24.6, 22., 20.4, 18., -10.]) * units.celsius |
|
406
|
|
|
dewpoint = np.array([19., -11.2, -10.8, -10.4, -10., -53.2]) * units.celsius |
|
407
|
|
|
parcel_prof = parcel_profile(p, temperature[0], dewpoint[0]).to('degC') |
|
408
|
|
|
cape, cin = cape_cin(p, temperature, dewpoint, parcel_prof) |
|
409
|
|
|
assert_almost_equal(cape, 0.0 * units('joule / kilogram'), 6) |
|
410
|
|
View Code Duplication |
assert_almost_equal(cin, 0.0 * units('joule / kilogram'), 6) |
|
|
|
|
|
|
411
|
|
|
|
|
412
|
|
|
|
|
413
|
|
|
def test_find_append_zero_crossings(): |
|
414
|
|
|
"""Tests finding and appending zero crossings of an x, y series.""" |
|
415
|
|
|
x = np.arange(11) * units.hPa |
|
416
|
|
|
y = np.array([3, 2, 1, -1, 2, 2, 0, 1, 0, -1, 2]) * units.degC |
|
417
|
|
|
x2, y2 = _find_append_zero_crossings(x, y) |
|
418
|
|
|
|
|
419
|
|
|
x_truth = np.array([0., 1., 2., 2.5, 3., 3.33333333, 4., 5., |
|
420
|
|
|
6., 7., 8., 9., 9.33333333, 10.]) * units.hPa |
|
421
|
|
|
y_truth = np.array([3, 2, 1, 0, -1, 0, 2, 2, 0, 1, 0, -1, 0, 2]) * units.degC |
|
422
|
|
|
assert_array_almost_equal(x2, x_truth, 6) |
|
423
|
|
|
assert_almost_equal(y2, y_truth, 6) |
|
424
|
|
|
|
|
425
|
|
|
|
|
426
|
|
|
def test_most_unstable_parcel(): |
|
427
|
|
|
"""Tests calculating the most unstable parcel.""" |
|
428
|
|
|
levels = np.array([1000., 959., 867.9]) * units.mbar |
|
429
|
|
|
temperatures = np.array([18.2, 22.2, 17.4]) * units.celsius |
|
430
|
|
|
dewpoints = np.array([19., 19., 14.3]) * units.celsius |
|
431
|
|
|
ret = most_unstable_parcel(levels, temperatures, dewpoints, depth=100 * units.hPa) |
|
432
|
|
|
assert_almost_equal(ret[0], 959.0 * units.hPa, 6) |
|
433
|
|
|
assert_almost_equal(ret[1], 22.2 * units.degC, 6) |
|
434
|
|
|
assert_almost_equal(ret[2], 19.0 * units.degC, 6) |
|
435
|
|
|
|
|
436
|
|
|
|
|
437
|
|
View Code Duplication |
def test_isentropic_pressure(): |
|
|
|
|
|
|
438
|
|
|
"""Test calculation of isentropic pressure function.""" |
|
439
|
|
|
lev = [100000., 95000., 90000., 85000.] * units.Pa |
|
440
|
|
|
tmp = np.ones((4, 5, 5)) |
|
441
|
|
|
tmp[0, :] = 296. |
|
442
|
|
|
tmp[1, :] = 292. |
|
443
|
|
|
tmp[2, :] = 290 |
|
444
|
|
|
tmp[3, :] = 288. |
|
445
|
|
|
tmpk = tmp * units.kelvin |
|
446
|
|
|
isentlev = [296.] * units.kelvin |
|
447
|
|
|
isentprs = isentropic_interpolation(isentlev, lev, tmpk) |
|
448
|
|
|
trueprs = 1000. * units.hPa |
|
449
|
|
|
assert_almost_equal(isentprs[0].shape, (1, 5, 5), 3) |
|
450
|
|
|
assert_almost_equal(isentprs[0], trueprs, 3) |
|
451
|
|
|
|
|
452
|
|
|
|
|
453
|
|
View Code Duplication |
def test_isentropic_pressure_p_increase(): |
|
|
|
|
|
|
454
|
|
|
"""Test calculation of isentropic pressure function, p increasing order.""" |
|
455
|
|
|
lev = [85000, 90000., 95000., 100000.] * units.Pa |
|
456
|
|
|
tmp = np.ones((4, 5, 5)) |
|
457
|
|
|
tmp[0, :] = 288. |
|
458
|
|
|
tmp[1, :] = 290. |
|
459
|
|
|
tmp[2, :] = 292. |
|
460
|
|
|
tmp[3, :] = 296. |
|
461
|
|
|
tmpk = tmp * units.kelvin |
|
462
|
|
|
isentlev = [296.] * units.kelvin |
|
463
|
|
|
isentprs = isentropic_interpolation(isentlev, lev, tmpk) |
|
464
|
|
|
trueprs = 1000. * units.hPa |
|
465
|
|
|
assert_almost_equal(isentprs[0], trueprs, 3) |
|
466
|
|
|
|
|
467
|
|
|
|
|
468
|
|
View Code Duplication |
def test_isentropic_pressure_adition_args(): |
|
|
|
|
|
|
469
|
|
|
"""Test calculation of isentropic pressure function, additional args.""" |
|
470
|
|
|
lev = [100000., 95000., 90000., 85000.] * units.Pa |
|
471
|
|
|
tmp = np.ones((4, 5, 5)) |
|
472
|
|
|
tmp[0, :] = 296. |
|
473
|
|
|
tmp[1, :] = 292. |
|
474
|
|
|
tmp[2, :] = 290. |
|
475
|
|
|
tmp[3, :] = 288. |
|
476
|
|
|
rh = np.ones((4, 5, 5)) |
|
477
|
|
|
rh[0, :] = 100. |
|
478
|
|
|
rh[1, :] = 80. |
|
479
|
|
|
rh[2, :] = 40. |
|
480
|
|
|
rh[3, :] = 20. |
|
481
|
|
|
relh = rh * units.percent |
|
482
|
|
|
tmpk = tmp * units.kelvin |
|
483
|
|
|
isentlev = [296.] * units.kelvin |
|
484
|
|
|
isentprs = isentropic_interpolation(isentlev, lev, tmpk, relh) |
|
485
|
|
|
truerh = 100. * units.percent |
|
486
|
|
|
assert_almost_equal(isentprs[1], truerh, 3) |
|
487
|
|
|
|
|
488
|
|
|
|
|
489
|
|
View Code Duplication |
def test_isentropic_pressure_tmp_out(): |
|
|
|
|
|
|
490
|
|
|
"""Test calculation of isentropic pressure function, temperature output.""" |
|
491
|
|
|
lev = [100000., 95000., 90000., 85000.] * units.Pa |
|
492
|
|
|
tmp = np.ones((4, 5, 5)) |
|
493
|
|
|
tmp[0, :] = 296. |
|
494
|
|
|
tmp[1, :] = 292. |
|
495
|
|
|
tmp[2, :] = 290. |
|
496
|
|
|
tmp[3, :] = 288. |
|
497
|
|
|
tmpk = tmp * units.kelvin |
|
498
|
|
|
isentlev = [296.] * units.kelvin |
|
499
|
|
|
isentprs = isentropic_interpolation(isentlev, lev, tmpk, tmpk_out=True) |
|
500
|
|
|
truetmp = 296. * units.kelvin |
|
501
|
|
|
assert_almost_equal(isentprs[1], truetmp, 3) |
|
502
|
|
|
|
|
503
|
|
|
|
|
504
|
|
View Code Duplication |
def test_isentropic_pressure_p_increase_rh_out(): |
|
|
|
|
|
|
505
|
|
|
"""Test calculation of isentropic pressure function, p increasing order.""" |
|
506
|
|
|
lev = [85000., 90000., 95000., 100000.] * units.Pa |
|
507
|
|
|
tmp = np.ones((4, 5, 5)) |
|
508
|
|
|
tmp[0, :] = 288. |
|
509
|
|
|
tmp[1, :] = 290. |
|
510
|
|
|
tmp[2, :] = 292. |
|
511
|
|
|
tmp[3, :] = 296. |
|
512
|
|
|
tmpk = tmp * units.kelvin |
|
513
|
|
|
rh = np.ones((4, 5, 5)) |
|
514
|
|
|
rh[0, :] = 20. |
|
515
|
|
|
rh[1, :] = 40. |
|
516
|
|
|
rh[2, :] = 80. |
|
517
|
|
|
rh[3, :] = 100. |
|
518
|
|
|
relh = rh * units.percent |
|
519
|
|
|
isentlev = 296. * units.kelvin |
|
520
|
|
|
isentprs = isentropic_interpolation(isentlev, lev, tmpk, relh) |
|
521
|
|
|
truerh = 100. * units.percent |
|
522
|
|
|
assert_almost_equal(isentprs[1], truerh, 3) |
|
523
|
|
|
|
|
524
|
|
|
|
|
525
|
|
View Code Duplication |
def test_isentropic_pressure_interp(): |
|
|
|
|
|
|
526
|
|
|
"""Test calculation of isentropic pressure function.""" |
|
527
|
|
|
lev = [100000., 95000., 90000., 85000.] * units.Pa |
|
528
|
|
|
tmp = np.ones((4, 5, 5)) |
|
529
|
|
|
tmp[0, :] = 296. |
|
530
|
|
|
tmp[1, :] = 292. |
|
531
|
|
|
tmp[2, :] = 290 |
|
532
|
|
|
tmp[3, :] = 288. |
|
533
|
|
|
tmpk = tmp * units.kelvin |
|
534
|
|
|
isentlev = [296., 297] * units.kelvin |
|
535
|
|
|
isentprs = isentropic_interpolation(isentlev, lev, tmpk) |
|
536
|
|
|
trueprs = 936.18057 * units.hPa |
|
537
|
|
|
assert_almost_equal(isentprs[0][1], trueprs, 3) |
|
538
|
|
|
|
|
539
|
|
|
|
|
540
|
|
View Code Duplication |
def test_isentropic_pressure_adition_args_interp(): |
|
|
|
|
|
|
541
|
|
|
"""Test calculation of isentropic pressure function, additional args.""" |
|
542
|
|
|
lev = [100000., 95000., 90000., 85000.] * units.Pa |
|
543
|
|
|
tmp = np.ones((4, 5, 5)) |
|
544
|
|
|
tmp[0, :] = 296. |
|
545
|
|
|
tmp[1, :] = 292. |
|
546
|
|
|
tmp[2, :] = 290. |
|
547
|
|
|
tmp[3, :] = 288. |
|
548
|
|
|
rh = np.ones((4, 5, 5)) |
|
549
|
|
|
rh[0, :] = 100. |
|
550
|
|
|
rh[1, :] = 80. |
|
551
|
|
|
rh[2, :] = 40. |
|
552
|
|
|
rh[3, :] = 20. |
|
553
|
|
|
relh = rh * units.percent |
|
554
|
|
|
tmpk = tmp * units.kelvin |
|
555
|
|
|
isentlev = [296., 297.] * units.kelvin |
|
556
|
|
|
isentprs = isentropic_interpolation(isentlev, lev, tmpk, relh) |
|
557
|
|
|
truerh = 69.171 * units.percent |
|
558
|
|
|
assert_almost_equal(isentprs[1][1], truerh, 3) |
|
559
|
|
|
|
|
560
|
|
|
|
|
561
|
|
View Code Duplication |
def test_isentropic_pressure_tmp_out_interp(): |
|
|
|
|
|
|
562
|
|
|
"""Test calculation of isentropic pressure function, temperature output.""" |
|
563
|
|
|
lev = [100000., 95000., 90000., 85000.] * units.Pa |
|
564
|
|
|
tmp = np.ones((4, 5, 5)) |
|
565
|
|
|
tmp[0, :] = 296. |
|
566
|
|
|
tmp[1, :] = 292. |
|
567
|
|
|
tmp[2, :] = 290. |
|
568
|
|
|
tmp[3, :] = 288. |
|
569
|
|
|
tmpk = tmp * units.kelvin |
|
570
|
|
|
isentlev = [296., 297.] * units.kelvin |
|
571
|
|
|
isentprs = isentropic_interpolation(isentlev, lev, tmpk, tmpk_out=True) |
|
572
|
|
|
truetmp = 291.4579 * units.kelvin |
|
573
|
|
|
assert_almost_equal(isentprs[1][1], truetmp, 3) |
|
574
|
|
|
|
|
575
|
|
|
|
|
576
|
|
|
def test_isentropic_pressure_data_bounds_error(): |
|
577
|
|
|
"""Test calculation of isentropic pressure function, error for data out of bounds.""" |
|
578
|
|
|
lev = [100000., 95000., 90000., 85000.] * units.Pa |
|
579
|
|
|
tmp = np.ones((4, 5, 5)) |
|
580
|
|
|
tmp[0, :] = 296. |
|
581
|
|
|
tmp[1, :] = 292. |
|
582
|
|
|
tmp[2, :] = 290. |
|
583
|
|
|
tmp[3, :] = 288. |
|
584
|
|
|
tmpk = tmp * units.kelvin |
|
585
|
|
|
isentlev = [296., 350.] * units.kelvin |
|
586
|
|
|
with pytest.raises(ValueError): |
|
587
|
|
|
isentropic_interpolation(isentlev, lev, tmpk) |
|
588
|
|
|
|
|
589
|
|
|
|
|
590
|
|
|
def test_isentropic_pressure_4d(): |
|
591
|
|
|
"""Test calculation of isentropic pressure function.""" |
|
592
|
|
|
lev = [100000., 95000., 90000., 85000.] * units.Pa |
|
593
|
|
|
tmp = np.ones((3, 4, 5, 5)) |
|
594
|
|
|
tmp[:, 0, :] = 296. |
|
595
|
|
|
tmp[:, 1, :] = 292. |
|
596
|
|
|
tmp[:, 2, :] = 290 |
|
597
|
|
|
tmp[:, 3, :] = 288. |
|
598
|
|
|
tmpk = tmp * units.kelvin |
|
599
|
|
|
rh = np.ones((3, 4, 5, 5)) |
|
600
|
|
|
rh[:, 0, :] = 100. |
|
601
|
|
|
rh[:, 1, :] = 80. |
|
602
|
|
|
rh[:, 2, :] = 40. |
|
603
|
|
|
rh[:, 3, :] = 20. |
|
604
|
|
|
relh = rh * units.percent |
|
605
|
|
|
isentlev = [296., 297., 300.] * units.kelvin |
|
606
|
|
|
isentprs = isentropic_interpolation(isentlev, lev, tmpk, relh, axis=1) |
|
607
|
|
|
trueprs = 1000. * units.hPa |
|
608
|
|
|
trueprs2 = 936.18057 * units.hPa |
|
609
|
|
|
trueprs3 = 879.446 * units.hPa |
|
610
|
|
|
truerh = 69.171 * units.percent |
|
611
|
|
|
assert_almost_equal(isentprs[0].shape, (3, 3, 5, 5), 3) |
|
612
|
|
|
assert_almost_equal(isentprs[0][:, 0, :], trueprs, 3) |
|
613
|
|
|
assert_almost_equal(isentprs[0][:, 1, :], trueprs2, 3) |
|
614
|
|
|
assert_almost_equal(isentprs[0][:, 2, :], trueprs3, 3) |
|
615
|
|
|
assert_almost_equal(isentprs[1][:, 1, ], truerh, 3) |
|
616
|
|
|
|
Unidata /
MetPy
Loading history...
