def test_virtual_potential_temperature():
"""Test virtual potential temperature calculation."""
p = 999. * units.mbar
t = 288. * units.kelvin
qv = .0016 * units.dimensionless # kg/kg
theta_v = virtual_potential_temperature(p, t, qv)
assert_almost_equal(theta_v, 288.3620 * units.kelvin, 3)
def test_density():
"""Test density calculation."""
p = 999. * units.mbar
t = 288. * units.kelvin
qv = .0016 * units.dimensionless # kg/kg
rho = density(p, t, qv).to(units.kilogram / units.meter ** 3)
assert_almost_equal(rho, 1.2072 * (units.kilogram / units.meter ** 3), 3)
def test_equivalent_potential_temperature():
"""Test equivalent potential temperature calculation."""
p = 1000 * units.mbar
t = 293. * units.kelvin
td = 280. * units.kelvin
ept = equivalent_potential_temperature(p, t, td)
assert_almost_equal(ept, 311.18586467284007 * units.kelvin, 3)
def test_coriolis_force():
"""Test basic coriolis force calculation."""
lat = np.array([-90., -30., 0., 30., 90.]) * units.degrees
cor = coriolis_parameter(lat)
values = np.array([-1.4584232E-4, -.72921159E-4, 0, .72921159E-4,
1.4584232E-4]) * units('s^-1')
assert_almost_equal(cor, values, 7)
def test_dewpoint_specific_humidity():
"""Test relative humidity from specific humidity."""
p = 1013.25 * units.mbar
temperature = 20. * units.degC
q = 0.012 * units.dimensionless
td = dewpoint_from_specific_humidity(q, temperature, p)
assert_almost_equal(td, 16.973 * units.degC, 3)
def test_vertical_velocity_pressure_moist_air():
"""Test conversion of w to omega assuming moist air."""
w = -1 * units('cm/s')
omega_truth = 1.032100858 * units('microbar/second')
omega_test = vertical_velocity_pressure(w, 850. * units.mbar, 280. * units.K,
8 * units('g/kg'))
assert_almost_equal(omega_test, omega_truth, 6)
def test_rh_specific_humidity():
"""Test relative humidity from specific humidity."""
p = 1013.25 * units.mbar
temperature = 20. * units.degC
q = 0.012 * units.dimensionless
rh = relative_humidity_from_specific_humidity(q, temperature, p)
assert_almost_equal(rh, 82.7145 * units.percent, 3)
def test_thickness_hydrostatic_isothermal_subset():
"""Test the thickness calculation for a dry isothermal layer subset at 0 degC."""
pressure = np.arange(1000, 500 - 1e-10, -10) * units.hPa
temperature = np.zeros_like(pressure) * units.degC
thickness = thickness_hydrostatic(pressure, temperature, bottom=850 * units.hPa,
depth=350 * units.hPa)
assert_almost_equal(thickness, 4242.68 * units.m, 2)
def test_thickness_hydrostatic():
"""Test the thickness calculation for a moist layer."""
pressure = np.array([959., 779.2, 751.3, 724.3, 700., 269.]) * units.hPa
temperature = np.array([22.2, 14.6, 12., 9.4, 7., -38.]) * units.degC
mixing = np.array([0.01458, 0.00209, 0.00224, 0.00240, 0.00256, 0.00010])
thickness = thickness_hydrostatic(pressure, temperature, mixing=mixing)
assert_almost_equal(thickness, 9892.07 * units.m, 2)
def test_heat_index_kelvin():
"""Test heat_index when given Kelvin temperatures."""
temp = 308.15 * units.degK
rh = 0.7
hi = heat_index(temp, rh)
# NB rounded up test value here vs the above two tests
assert_almost_equal(hi.to('degC'), 50.3406 * units.degC, 4)
def test_rh_mixing_ratio():
"""Test relative humidity from mixing ratio."""
p = 1013.25 * units.mbar
temperature = 20. * units.degC
w = 0.012 * units.dimensionless
rh = relative_humidity_from_mixing_ratio(w, temperature, p)
assert_almost_equal(rh, 81.7219 * units.percent, 3)
def test_mixing_ratio_from_relative_humidity():
"""Test relative humidity from mixing ratio."""
p = 1013.25 * units.mbar
temperature = 20. * units.degC
rh = 81.7219 * units.percent
w = mixing_ratio_from_relative_humidity(rh, temperature, p)
assert_almost_equal(w, 0.012 * units.dimensionless, 3)
def test_dewpoint_weird_units():
"""Test dewpoint using non-standard units.
Revealed from odd dimensionless units and ending up using numpy.ma math
functions instead of numpy ones.
"""
assert_almost_equal(dewpoint(15825.6 * units('g * mbar / kg')),
13.8564 * units.degC, 4)
def test_brunt_vaisala_period():
"""Test Brunt-Vaisala period function."""
truth = [[540.24223556, 441.10593821, 360.16149037, 483.20734521],
[542.10193894, 443.38165033, 627.03634320, 625.96540075],
[543.95528431, 771.88106656, np.nan, 543.02940230],
[545.80233643, np.nan, np.nan, 385.94053328]] * units('s')
bv_period = brunt_vaisala_period(bv_data()[0], bv_data()[1])
assert_almost_equal(bv_period, truth, 6)
def test_brunt_vaisala_frequency_squared():
"""Test Brunt-Vaisala frequency squared function."""
truth = [[1.35264138e-04, 2.02896207e-04, 3.04344310e-04, 1.69080172e-04],
[1.34337671e-04, 2.00818771e-04, 1.00409386e-04, 1.00753253e-04],
[1.33423810e-04, 6.62611486e-05, 0, 1.33879181e-04],
[1.32522297e-04, -1.99457288e-04, 0., 2.65044595e-04]] * units('s^-2')
bv_freq_sqr = brunt_vaisala_frequency_squared(bv_data()[0], bv_data()[1])
assert_almost_equal(bv_freq_sqr, truth, 6)
def test_thickness_hydrostatic_from_relative_humidity():
"""Test the thickness calculation for a moist layer using RH data."""
pressure = np.array([959., 779.2, 751.3, 724.3, 700., 269.]) * units.hPa
temperature = np.array([22.2, 14.6, 12., 9.4, 7., -38.]) * units.degC
relative_humidity = np.array([81.69, 15.43, 18.95, 23.32, 28.36, 18.55]) * units.percent
thickness = thickness_hydrostatic_from_relative_humidity(pressure, temperature,
relative_humidity)
assert_almost_equal(thickness, 9892.07 * units.m, 2)
def test_wet_psychrometric_rh():
"""Test calculation of relative humidity from wet and dry bulb temperatures."""
p = 1013.25 * units.mbar
dry_bulb_temperature = 20. * units.degC
wet_bulb_temperature = 18. * units.degC
psychrometric_rh = relative_humidity_wet_psychrometric(dry_bulb_temperature,
wet_bulb_temperature, p)
assert_almost_equal(psychrometric_rh, 82.8747 * units.percent, 3)
def test_most_unstable_cape_cin():
"""Test the most unstable CAPE/CIN calculation."""
pressure = np.array([1000., 959., 867.9, 850., 825., 800.]) * units.mbar
temperature = np.array([18.2, 22.2, 17.4, 10., 0., 15]) * units.celsius
dewpoint = np.array([19., 19., 14.3, 0., -10., 0.]) * units.celsius
mucape, mucin = most_unstable_cape_cin(pressure, temperature, dewpoint)
assert_almost_equal(mucape, 157.07111 * units('joule / kilogram'), 4)
assert_almost_equal(mucin, -15.74772 * units('joule / kilogram'), 4)
def test_surface_based_cape_cin():
"""Test the surface-based CAPE and CIN calculation."""
p = np.array([959., 779.2, 751.3, 724.3, 700., 269.]) * units.mbar
temperature = np.array([22.2, 14.6, 12., 9.4, 7., -38.]) * units.celsius
dewpoint = np.array([19., -11.2, -10.8, -10.4, -10., -53.2]) * units.celsius
cape, cin = surface_based_cape_cin(p, temperature, dewpoint)
assert_almost_equal(cape, 58.0368212 * units('joule / kilogram'), 6)
assert_almost_equal(cin, -89.8073512 * units('joule / kilogram'), 6)
def test_lfc_basic():
"""Test LFC calculation."""
levels = np.array([959., 779.2, 751.3, 724.3, 700., 269.]) * units.mbar
temperatures = np.array([22.2, 14.6, 12., 9.4, 7., -49.]) * units.celsius
dewpoints = np.array([19., -11.2, -10.8, -10.4, -10., -53.2]) * units.celsius
l = lfc(levels, temperatures, dewpoints)
assert_almost_equal(l[0], 727.468 * units.mbar, 2)
assert_almost_equal(l[1], 9.705 * units.celsius, 2)
def test_thickness_hydrostatic_subset():
"""Test the thickness calculation with a subset of the moist layer."""
pressure = np.array([959., 779.2, 751.3, 724.3, 700., 269.]) * units.hPa
temperature = np.array([22.2, 14.6, 12., 9.4, 7., -38.]) * units.degC
mixing = np.array([0.01458, 0.00209, 0.00224, 0.00240, 0.00256, 0.00010])
thickness = thickness_hydrostatic(pressure, temperature, mixing=mixing,
bottom=850 * units.hPa, depth=150 * units.hPa)
assert_almost_equal(thickness, 1630.81 * units.m, 2)
def test_most_unstable_cape_cin_surface():
"""Test the most unstable CAPE/CIN calculation when surface is most unstable."""
pressure = np.array([959., 779.2, 751.3, 724.3, 700., 269.]) * units.mbar
temperature = np.array([22.2, 14.6, 12., 9.4, 7., -38.]) * units.celsius
dewpoint = np.array([19., -11.2, -10.8, -10.4, -10., -53.2]) * units.celsius
mucape, mucin = most_unstable_cape_cin(pressure, temperature, dewpoint)
assert_almost_equal(mucape, 58.0368212 * units('joule / kilogram'), 6)
assert_almost_equal(mucin, -89.8073512 * units('joule / kilogram'), 6)
def test_wet_psychrometric_vapor_pressure():
"""Test calculation of vapor pressure from wet and dry bulb temperatures."""
p = 1013.25 * units.mbar
dry_bulb_temperature = 20. * units.degC
wet_bulb_temperature = 18. * units.degC
psychrometric_vapor_pressure = psychrometric_vapor_pressure_wet(dry_bulb_temperature,
wet_bulb_temperature, p)
assert_almost_equal(psychrometric_vapor_pressure, 19.3673 * units.mbar, 3)
def test_bulk_shear_no_depth():
"""Test bulk shear with observed sounding and no depth given. Issue #568."""
data = get_upper_air_data(datetime(2016, 5, 22, 0), 'DDC')
u, v = bulk_shear(data['pressure'], data['u_wind'],
data['v_wind'], heights=data['height'])
truth = [20.225018939, 22.602359692] * units('knots')
assert_almost_equal(u.to('knots'), truth[0], 8)
assert_almost_equal(v.to('knots'), truth[1], 8)
def test_brunt_vaisala_frequency():
"""Test Brunt-Vaisala frequency function."""
truth = [[0.01163031, 0.01424416, 0.01744547, 0.01300308],
[0.01159041, 0.01417105, 0.01002045, 0.01003759],
[0.01155092, 0.00814010, 0., 0.01157062],
[0.01151183, np.nan, 0., 0.01628019]] * units('s^-1')
bv_freq = brunt_vaisala_frequency(bv_data()[0], bv_data()[1])
assert_almost_equal(bv_freq, truth, 6)
def test_supercell_composite_scalar():
"""Test supercell composite function with a single value."""
mucape = 2000. * units('J/kg')
esrh = 400. * units('m^2/s^2')
ebwd = 30. * units('m/s')
truth = 16.
supercell_comp = supercell_composite(mucape, esrh, ebwd)
assert_almost_equal(supercell_comp, truth, 6)
def test_critical_angle():
"""Test critical angle with observed sounding."""
data = get_upper_air_data(datetime(2016, 5, 22, 0), 'DDC')
ca = critical_angle(data['pressure'], data['u_wind'],
data['v_wind'], data['height'],
stormu=0 * units('m/s'), stormv=0 * units('m/s'))
truth = [140.0626637513269] * units('degrees')
assert_almost_equal(ca, truth, 8)
def test_apparent_temperature_windchill():
"""Test that apparent temperature works when a windchill is calculated."""
temperature = -5. * units.degC
rel_humidity = 50. * units.percent
wind = 35. * units('m/s')
truth = -18.9357 * units.degC
res = apparent_temperature(temperature, rel_humidity, wind)
assert_almost_equal(res, truth, 0)
def test_apparent_temperature_scalar_no_modification():
"""Test the apparent temperature calculation with a scalar that is NOOP."""
temperature = 70 * units.degF
rel_humidity = 60 * units.percent
wind = 5 * units.mph
truth = 70 * units.degF
res = apparent_temperature(temperature, rel_humidity, wind)
assert_almost_equal(res, truth, 6)
def test_apparent_temperature_scalar():
"""Test the apparent temperature calculation with a scalar."""
temperature = 90 * units.degF
rel_humidity = 60 * units.percent
wind = 5 * units.mph
truth = 99.6777178 * units.degF
res = apparent_temperature(temperature, rel_humidity, wind)
assert_almost_equal(res, truth, 6)
def test_absolute_vorticity_asym():
"""Test absolute vorticity calculation with a complicated field."""
u = np.array([[2, 4, 8], [0, 2, 2], [4, 6, 8]]) * units('m/s')
v = np.array([[6, 4, 8], [2, 6, 0], [2, 2, 6]]) * units('m/s')
lats = np.array([[30, 30, 30], [20, 20, 20], [10, 10, 10]]) * units.degrees
vort = absolute_vorticity(u,
v,
1 * units.meters,
2 * units.meters,
lats,
dim_order='yx')
true_vort = np.array([[-2.499927, 3.500073, 13.00007],
[8.500050, -1.499950, -10.99995],
[-5.499975, -1.499975, 2.532525e-5]]) / units.sec
assert_almost_equal(vort, true_vort, 5)
# Now try for xy ordered
vort = absolute_vorticity(u.T,
v.T,
1 * units.meters,
2 * units.meters,
lats.T,
dim_order='xy')
assert_almost_equal(vort, true_vort.T, 5)
def test_mixed_parcel():
"""Test the mixed parcel calculation."""
pressure = np.array([959., 779.2, 751.3, 724.3, 700., 269.]) * units.hPa
temperature = np.array([22.2, 14.6, 12., 9.4, 7., -38.]) * units.degC
dewpoint = np.array([19., -11.2, -10.8, -10.4, -10., -53.2]) * units.degC
parcel_pressure, parcel_temperature, parcel_dewpoint = mixed_parcel(
pressure, temperature, dewpoint, depth=250 * units.hPa)
assert_almost_equal(parcel_pressure, 959. * units.hPa, 6)
assert_almost_equal(parcel_temperature, 28.7363771 * units.degC, 6)
assert_almost_equal(parcel_dewpoint, 7.1534658 * units.degC, 6)
def test_most_unstable_parcel():
"""Tests calculating the most unstable parcel."""
levels = np.array([1000., 959., 867.9]) * units.mbar
temperatures = np.array([18.2, 22.2, 17.4]) * units.celsius
dewpoints = np.array([19., 19., 14.3]) * units.celsius
ret = most_unstable_parcel(levels,
temperatures,
dewpoints,
depth=100 * units.hPa)
assert_almost_equal(ret[0], 959.0 * units.hPa, 6)
assert_almost_equal(ret[1], 22.2 * units.degC, 6)
assert_almost_equal(ret[2], 19.0 * units.degC, 6)
def test_storm_relative_helicity_no_storm_motion():
"""Test storm relative helicity with no storm motion and differing input units."""
u = np.array([0, 20, 10, 0]) * units('m/s')
v = np.array([20, 0, 0, 10]) * units('m/s')
u = u.to('knots')
heights = np.array([0, 250, 500, 750]) * units.m
positive_srh, negative_srh, total_srh = storm_relative_helicity(u, v, heights,
depth=750 * units.meters)
assert_almost_equal(positive_srh, 400. * units('meter ** 2 / second ** 2 '), 6)
assert_almost_equal(negative_srh, -100. * units('meter ** 2 / second ** 2 '), 6)
assert_almost_equal(total_srh, 300. * units('meter ** 2 / second ** 2 '), 6)
def test_storm_relative_helicity_with_interpolation():
"""Test storm relative helicity with interpolation."""
u = np.array([-5, 15, 25, 15, -5]) * units('m/s')
v = np.array([40, 20, 10, 10, 30]) * units('m/s')
u = u.to('knots')
heights = np.array([0, 100, 200, 300, 400]) * units.m
pos_srh, neg_srh, total_srh = storm_relative_helicity(u, v, heights,
bottom=50 * units.meters,
depth=300 * units.meters,
storm_u=5 * units('m/s'),
storm_v=10 * units('m/s'))
assert_almost_equal(pos_srh, 400. * units('meter ** 2 / second ** 2 '), 6)
assert_almost_equal(neg_srh, -100. * units('meter ** 2 / second ** 2 '), 6)
assert_almost_equal(total_srh, 300. * units('meter ** 2 / second ** 2 '), 6)
def test_sensitive_sounding():
"""Test quantities for a sensitive sounding (#902)."""
# This sounding has a very small positive area in the low level. It's only captured
# properly if the parcel profile includes the LCL, otherwise it breaks LFC and CAPE
p = units.Quantity([
1004., 1000., 943., 928., 925., 850., 839., 749., 700., 699., 603.,
500., 404., 400., 363., 306., 300., 250., 213., 200., 176., 150.
], 'hectopascal')
t = units.Quantity([
24.2, 24., 20.2, 21.6, 21.4, 20.4, 20.2, 14.4, 13.2, 13., 6.8, -3.3,
-13.1, -13.7, -17.9, -25.5, -26.9, -37.9, -46.7, -48.7, -52.1, -58.9
], 'degC')
td = units.Quantity([
21.9, 22.1, 19.2, 20.5, 20.4, 18.4, 17.4, 8.4, -2.8, -3.0, -15.2,
-20.3, -29.1, -27.7, -24.9, -39.5, -41.9, -51.9, -60.7, -62.7, -65.1,
-71.9
], 'degC')
lfc_pressure, lfc_temp = lfc(p, t, td)
assert_almost_equal(lfc_pressure, 947.476 * units.mbar, 2)
assert_almost_equal(lfc_temp, 20.498 * units.degC, 2)
pos, neg = surface_based_cape_cin(p, t, td)
assert_almost_equal(pos, 0.112 * units('J/kg'), 3)
assert_almost_equal(neg, -6.075 * units('J/kg'), 3)
def test_helicity():
"""Test function for SRH calculations on an eigth-circle hodograph."""
pres_test = np.asarray([
1013.25, 954.57955706, 898.690770743, 845.481604002, 794.85264282
]) * units('hPa')
hgt_test = hgt_test = np.asarray([0, 500, 1000, 1500, 2000])
# Create larger arrays for everything except pressure to make a smoother graph
hgt_int = np.arange(0, 2050, 50)
hgt_int = hgt_int * units('meter')
dir_int = np.arange(180, 272.25, 2.25)
spd_int = np.zeros((hgt_int.shape[0]))
spd_int[:] = 2.
u_int, v_int = get_wind_components(spd_int * units('m/s'),
dir_int * units.degree)
# Interpolate pressure to that graph
pres_int = np.interp(hgt_int, hgt_test, np.log(pres_test.magnitude))
pres_int = np.exp(pres_int) * units('hPa')
# Put in the correct value of SRH for a eighth-circle, 2 m/s hodograph
# (SRH = 2 * area under hodo, in this case...)
srh_true_p = (.25 * np.pi * (2**2)) * units('m^2/s^2')
# Since there's only positive SRH in this case, total SRH will be equal to positive SRH and
# negative SRH will be zero.
srh_true_t = srh_true_p
srh_true_n = 0 * units('m^2/s^2')
p_srh, n_srh, T_srh = storm_relative_helicity(u_int,
v_int,
pres_int,
hgt_int,
1000 * units('meter'),
bottom=0 * units('meter'),
storm_u=0 * units.knot,
storm_v=0 * units.knot)
assert_almost_equal(p_srh, srh_true_p, 2)
assert_almost_equal(n_srh, srh_true_n, 2)
assert_almost_equal(T_srh, srh_true_t, 2)
def test_parcel_profile_lcl():
"""Test parcel profile with lcl calculation."""
p = np.array([
1004., 1000., 943., 928., 925., 850., 839., 749., 700., 699.
]) * units.hPa
t = np.array([24.2, 24., 20.2, 21.6, 21.4, 20.4, 20.2, 14.4, 13.2, 13.
]) * units.degC
td = np.array([21.9, 22.1, 19.2, 20.5, 20.4, 18.4, 17.4, 8.4, -2.8, -3.0
]) * units.degC
true_prof = np.array([
297.35, 297.01, 294.5, 293.48, 292.92, 292.81, 289.79, 289.32, 285.15,
282.59, 282.53
]) * units.kelvin
true_p = np.insert(p.m, 2, 970.699) * units.mbar
true_t = np.insert(t.m, 2, 22.047) * units.degC
true_td = np.insert(td.m, 2, 20.609) * units.degC
pressure, temp, dewp, prof = parcel_profile_with_lcl(p, t, td)
assert_almost_equal(pressure, true_p, 3)
assert_almost_equal(temp, true_t, 3)
assert_almost_equal(dewp, true_td, 3)
assert_array_almost_equal(prof, true_prof, 2)
def test_heat_index_scalar():
"""Test heat index using scalars."""
hi = heat_index(96 * units.degF, 65 * units.percent)
assert_almost_equal(hi, 121 * units.degF, 0)
def test_windchill_kelvin():
"""Test wind chill when given Kelvin temperatures."""
wc = windchill(268.15 * units.kelvin, 35 * units('m/s'))
assert_almost_equal(wc, -18.9357 * units.degC, 0)
def test_windchill_scalar():
"""Test wind chill with scalars."""
wc = windchill(-5 * units.degC, 35 * units('m/s'))
assert_almost_equal(wc, -18.9357 * units.degC, 0)
def test_fahrenheit():
"""Test that potential_temperature handles temperature values in Fahrenheit."""
assert_almost_equal(potential_temperature(800. * units.mbar, 68. * units.degF),
(312.444 * units.kelvin).to(units.degF), 2)
def test_streamfunc():
"""Test of Montgomery Streamfunction calculation."""
t = 287. * units.kelvin
hgt = 5000. * units.meter
msf = montgomery_streamfunction(hgt, t)
assert_almost_equal(msf, 337468.2500 * units('m^2 s^-2'), 4)
def test_add_pressure_to_height():
"""Test the height at pressure above height calculation."""
height = add_pressure_to_height(110.8286757 * units.m, 100 * units.hPa)
assert_almost_equal(height, 988.0028867 * units.meter, 5)
def test_pressure_to_heights_units():
"""Test that passing non-mbar units works."""
assert_almost_equal(pressure_to_height_std(29 * units.inHg),
262.859 * units.meter, 3)
def test_scalar_speed():
"""Test wind speed with scalars."""
s = wind_speed(-3. * units('m/s'), -4. * units('m/s'))
assert_almost_equal(s, 5. * units('m/s'), 3)
def test_scalar_dir():
'Test wind direction with scalars'
d = get_wind_dir(-3. * units('m/s'), -4. * units('m/s'))
assert_almost_equal(d, 216.870 * units.deg, 3)
def test_scalar_speed():
'Test wind speed with scalars'
s = get_wind_speed(-3. * units('m/s'), -4. * units('m/s'))
assert_almost_equal(s, 5. * units('m/s'), 3)
def test_wind_comps_scalar():
'Test scalar wind components'
u, v = get_wind_components(8 * units('m/s'), 150 * units.deg)
assert_almost_equal(u, -4 * units('m/s'), 3)
assert_almost_equal(v, 6.9282 * units('m/s'), 3)
def test_mixed_layer():
"""Tests the mixed layer calculation."""
pressure = np.array([959., 779.2, 751.3, 724.3, 700., 269.]) * units.hPa
temperature = np.array([22.2, 14.6, 12., 9.4, 7., -38.]) * units.degC
mixed_layer_temperature = mixed_layer(pressure, temperature, depth=250 * units.hPa)[0]
assert_almost_equal(mixed_layer_temperature, 16.4024930 * units.degC, 6)
def test_pot_temp_inhg():
"""Test that potential_temperature can handle pressure not in mb (issue #165)."""
assert_almost_equal(potential_temperature(29.92 * units.inHg, 29 * units.degC),
301.019735 * units.kelvin, 4)
def test_pressure_to_heights_basic():
"""Test basic pressure to height calculation for standard atmosphere."""
pressures = np.array([975.2, 987.5, 956., 943.]) * units.mbar
heights = pressure_to_height_std(pressures)
values = np.array([321.5, 216.5, 487.6, 601.7]) * units.meter
assert_almost_equal(heights, values, 1)
def test_heights_to_pressure_basic():
"""Test basic height to pressure calculation for standard atmosphere."""
heights = np.array([321.5, 216.5, 487.6, 601.7]) * units.meter
pressures = height_to_pressure_std(heights)
values = np.array([975.2, 987.5, 956., 943.]) * units.mbar
assert_almost_equal(pressures, values, 1)
def test_scalar_direction():
"""Test wind direction with scalars."""
d = wind_direction(3. * units('m/s'), 4. * units('m/s'))
assert_almost_equal(d, 216.870 * units.deg, 3)
def test_add_height_to_pressure():
"""Test the pressure at height above pressure calculation."""
pressure = add_height_to_pressure(1000 * units.hPa,
877.17421094 * units.meter)
assert_almost_equal(pressure, 900 * units.hPa, 5)
def test_get_wind_components():
"""Test that get_wind_components wrapper works (deprecated in 0.9)."""
with pytest.warns(MetpyDeprecationWarning):
u, v = get_wind_components(8 * units('m/s'), 150 * units.deg)
assert_almost_equal(u, -4 * units('m/s'), 3)
assert_almost_equal(v, 6.9282 * units('m/s'), 3)
def test_wind_comps_scalar():
"""Test wind components calculation with scalars."""
u, v = wind_components(8 * units('m/s'), 150 * units.deg)
assert_almost_equal(u, -4 * units('m/s'), 3)
assert_almost_equal(v, 6.9282 * units('m/s'), 3)
def test_get_wind_speed():
"""Test that get_wind_speed wrapper works (deprecated in 0.9)."""
with pytest.warns(MetpyDeprecationWarning):
s = get_wind_speed(-3. * units('m/s'), -4. * units('m/s'))
assert_almost_equal(s, 5. * units('m/s'), 3)
def test_get_wind_dir():
"""Test that get_wind_dir wrapper works (deprecated in 0.9)."""
with pytest.warns(MetpyDeprecationWarning):
d = get_wind_dir(3. * units('m/s'), 4. * units('m/s'))
assert_almost_equal(d, 216.870 * units.deg, 3)
def test_mixing_ratio_from_specific_humidity():
"""Tests mixing ratio from specific humidity."""
q = 0.012
w = mixing_ratio_from_specific_humidity(q)
assert_almost_equal(w, 0.01215, 3)