def test_advection_1d():
"""Test advection calculation with varying wind and field."""
u = np.array([1, 2, 3]) * units('m/s')
s = np.array([1, 2, 3]) * units('Pa')
a = advection(s, u, (1 * units.meter, ), dim_order='xy')
truth = np.array([-1, -2, -3]) * units('Pa/sec')
assert_array_equal(a, truth)
def test_advection_uniform():
"""Test advection calculation for a uniform 1D field."""
u = np.ones((3, )) * units('m/s')
s = np.ones_like(u) * units.kelvin
a = advection(s, u, (1 * units.meter, ), dim_order='xy')
truth = np.zeros_like(u) * units('K/sec')
assert_array_equal(a, truth)
def test_advection_1d_uniform_wind():
"""Test advection for simple 1D case with uniform wind."""
u = np.ones((3, )) * units('m/s')
s = np.array([1, 2, 3]) * units('kg')
a = advection(s, u, (1 * units.meter, ), dim_order='xy')
truth = -np.ones_like(u) * units('kg/sec')
assert_array_equal(a, truth)
def test_convergence():
"""Test convergence for simple case."""
a = np.arange(3)
u = np.c_[a, a, a] * units('m/s')
c = h_convergence(u, u, 1 * units.meter, 1 * units.meter, dim_order='xy')
true_c = np.ones_like(u) / units.sec
assert_array_equal(c, true_c)
def test_zero_convergence():
"""Test convergence calculation when zeros should be returned."""
a = np.arange(3)
u = np.c_[a, a, a] * units('m/s')
c = h_convergence(u, u.T, 1 * units.meter, 1 * units.meter, dim_order='xy')
true_c = 2. * np.ones_like(u) / units.sec
assert_array_equal(c, true_c)
def test_vorticity():
"""Test vorticity for simple case."""
a = np.arange(3)
u = np.c_[a, a, a] * units('m/s')
v = v_vorticity(u, u, 1 * units.meter, 1 * units.meter, dim_order='xy')
true_v = np.ones_like(u) / units.sec
assert_array_equal(v, true_v)
def test_zero_vorticity():
"""Test vorticity calculation when zeros should be returned."""
a = np.arange(3)
u = np.c_[a, a, a] * units('m/s')
v = v_vorticity(u, u.T, 1 * units.meter, 1 * units.meter, dim_order='xy')
true_v = np.zeros_like(u) / units.sec
assert_array_equal(v, true_v)
def test_advection_uniform():
"""Test advection calculation for a uniform 1D field."""
u = np.ones((3,)) * units('m/s')
s = np.ones_like(u) * units.kelvin
a = advection(s, u, (1 * units.meter,))
truth = np.zeros_like(u) * units('K/sec')
assert_array_equal(a, truth)
def test_resample_nn():
"""Test 1d nearest neighbor functionality."""
a = np.arange(5.)
b = np.array([2, 3.8])
truth = np.array([2, 4])
assert_array_equal(truth, resample_nn_1d(a, b))
def test_zero_convergence():
"""Test convergence calculation when zeros should be returned."""
a = np.arange(3)
u = np.c_[a, a, a] * units('m/s')
c = h_convergence(u, u.T, 1 * units.meter, 1 * units.meter)
true_c = 2. * np.ones_like(u) / units.sec
assert_array_equal(c, true_c)
def test_basic2(self):
'Basic test of advection'
u = np.ones((3,)) * units('m/s')
s = np.array([1, 2, 3]) * units('kg')
a = advection(s, u, (1 * units.meter,))
truth = -np.ones_like(u) * units('kg/sec')
assert_array_equal(a, truth)
def test_basic3(self):
'Basic test of advection'
u = np.array([1, 2, 3]) * units('m/s')
s = np.array([1, 2, 3]) * units('Pa')
a = advection(s, u, (1 * units.meter,))
truth = np.array([-1, -2, -3]) * units('Pa/sec')
assert_array_equal(a, truth)
def test_basic3(self):
'Basic test of vorticity and divergence calculation'
a = np.arange(3)
u = np.c_[a, a, a] * units('m/s')
c = h_convergence(u, u, 1 * units.meter, 1 * units.meter)
true_c = np.ones_like(u) / units.sec
assert_array_equal(c, true_c)
def test_basic(self):
'Basic braindead test of advection'
u = np.ones((3,)) * units('m/s')
s = np.ones_like(u) * units.kelvin
a = advection(s, u, (1 * units.meter,))
truth = np.zeros_like(u) * units('K/sec')
assert_array_equal(a, truth)
def test_basic(self):
'Simple test of only vorticity'
a = np.arange(3)
u = np.c_[a, a, a] * units('m/s')
v = v_vorticity(u, u.T, 1 * units.meter, 1 * units.meter)
true_v = np.zeros_like(u) / units.sec
assert_array_equal(v, true_v)
def test_basic(self):
'Simple test of only vorticity'
a = np.arange(3)
u = np.c_[a, a, a] * units('m/s')
c = h_convergence(u, u.T, 1 * units.meter, 1 * units.meter)
true_c = 2. * np.ones_like(u) / units.sec
assert_array_equal(c, true_c)
def test_basic(self):
'Basic braindead test of vorticity and divergence calculation'
u = np.ones((3, 3)) * units('m/s')
c, v = convergence_vorticity(u, u, 1 * units.meter, 1 * units.meter)
truth = np.zeros_like(u) / units.sec
assert_array_equal(c, truth)
assert_array_equal(v, truth)
def test_resample_nn():
"""Test 1d nearest neighbor functionality."""
a = np.arange(5.)
b = np.array([2, 3.8])
truth = np.array([2, 4])
assert_array_equal(truth, resample_nn_1d(a, b))
def test_vorticity():
"""Test vorticity for simple case."""
a = np.arange(3)
u = np.c_[a, a, a] * units('m/s')
v = v_vorticity(u, u, 1 * units.meter, 1 * units.meter)
true_v = np.ones_like(u) / units.sec
assert_array_equal(v, true_v)
def test_precipitable_water():
"""Test precipitable water with observed sounding."""
data = get_upper_air_data(datetime(2016, 5, 22, 0), 'DDC')
pw = precipitable_water(data['dewpoint'], data['pressure'],
top=400 * units.hPa)
truth = (0.8899441949243486 * units('inches')).to('millimeters')
assert_array_equal(pw, truth)
def test_advection_1d():
"""Test advection calculation with varying wind and field."""
u = np.array([1, 2, 3]) * units('m/s')
s = np.array([1, 2, 3]) * units('Pa')
a = advection(s, u, (1 * units.meter,))
truth = np.array([-1, -2, -3]) * units('Pa/sec')
assert_array_equal(a, truth)
def test_convergence():
"""Test convergence for simple case."""
a = np.arange(3)
u = np.c_[a, a, a] * units('m/s')
c = h_convergence(u, u, 1 * units.meter, 1 * units.meter)
true_c = np.ones_like(u) / units.sec
assert_array_equal(c, true_c)
def test_less_or_close():
"""Test floating point less or close to."""
x = np.array([0.0, 1.0, 1.49999, 1.5, 1.5000, 1.7])
comparison_value = 1.5
truth = np.array([True, True, True, True, True, False])
res = _less_or_close(x, comparison_value)
assert_array_equal(res, truth)
def test_advection_1d_uniform_wind():
"""Test advection for simple 1D case with uniform wind."""
u = np.ones((3,)) * units('m/s')
s = np.array([1, 2, 3]) * units('kg')
a = advection(s, u, (1 * units.meter,))
truth = -np.ones_like(u) * units('kg/sec')
assert_array_equal(a, truth)
def test_zero_vorticity():
"""Test vorticity calculation when zeros should be returned."""
a = np.arange(3)
u = np.c_[a, a, a] * units('m/s')
v = v_vorticity(u, u.T, 1 * units.meter, 1 * units.meter)
true_v = np.zeros_like(u) / units.sec
assert_array_equal(v, true_v)
def test_zero_gradient():
"""Test convergence_vorticity when there is no gradient in the field."""
u = np.ones((3, 3)) * units('m/s')
c, v = convergence_vorticity(u, u, 1 * units.meter, 1 * units.meter)
truth = np.zeros_like(u) / units.sec
assert_array_equal(c, truth)
assert_array_equal(v, truth)
def test_advection_2d_uniform():
"""Test advection for uniform 2D field."""
u = np.ones((3, 3)) * units('m/s')
s = np.ones_like(u) * units.kelvin
a = advection(s, [u, u], (1 * units.meter, 1 * units.meter))
truth = np.zeros_like(u) * units('K/sec')
assert_array_equal(a, truth)
def test_less_or_close():
"""Test floating point less or close to."""
x = np.array([0.0, 1.0, 1.49999, 1.5, 1.5000, 1.7])
comparison_value = 1.5
truth = np.array([True, True, True, True, True, False])
res = _less_or_close(x, comparison_value)
assert_array_equal(res, truth)
def test_advection_2d():
"""Test advection in varying 2D field."""
u = np.ones((3, 3)) * units('m/s')
v = 2 * np.ones((3, 3)) * units('m/s')
s = np.array([[1, 2, 1], [2, 4, 2], [1, 2, 1]]) * units.kelvin
a = advection(s, [u, v], (1 * units.meter, 1 * units.meter), dim_order='xy')
truth = np.array([[-6, -4, 2], [-8, 0, 8], [-2, 4, 6]]) * units('K/sec')
assert_array_equal(a, truth)
def test_windchill_invalid():
"""Test windchill for values that should be masked."""
temp = np.array([10, 51, 49, 60, 80, 81]) * units.degF
speed = np.array([4, 4, 3, 1, 10, 39]) * units.mph
wc = windchill(temp, speed)
mask = np.array([False, True, True, True, True, True])
assert_array_equal(wc.mask, mask)
def test_delete_masked_points():
"""Test deleting masked points."""
a = ma.masked_array(np.arange(5), mask=[False, True, False, False, False])
b = ma.masked_array(np.arange(5), mask=[False, False, False, True, False])
expected = np.array([0, 2, 4])
a, b = _delete_masked_points(a, b)
assert_array_equal(a, expected)
assert_array_equal(b, expected)
def test_2dbasic2(self):
'Basic 2D test of advection'
u = np.ones((3, 3)) * units('m/s')
v = 2 * np.ones((3, 3)) * units('m/s')
s = np.array([[1, 2, 1], [2, 4, 2], [1, 2, 1]]) * units.kelvin
a = advection(s, [u, v], (1 * units.meter, 1 * units.meter))
truth = np.array([[-3, -2, 1], [-4, 0, 4], [-1, 2, 3]]) * units('K/sec')
assert_array_equal(a, truth)
def test_2dbasic2(self):
'Basic 2D test of advection'
u = np.ones((3, 3)) * units('m/s')
v = 2 * np.ones((3, 3)) * units('m/s')
s = np.array([[1, 2, 1], [2, 4, 2], [1, 2, 1]]) * units.kelvin
a = advection(s, [u, v], (1 * units.meter, 1 * units.meter))
truth = np.array([[-3, -2, 1], [-4, 0, 4], [-1, 2, 3]]) * units('K/sec')
assert_array_equal(a, truth)
def test_advection_2d():
"""Test advection in varying 2D field."""
u = np.ones((3, 3)) * units('m/s')
v = 2 * np.ones((3, 3)) * units('m/s')
s = np.array([[1, 2, 1], [2, 4, 2], [1, 2, 1]]) * units.kelvin
a = advection(s, [u, v], (1 * units.meter, 1 * units.meter))
truth = np.array([[-3, -2, 1], [-4, 0, 4], [-1, 2, 3]]) * units('K/sec')
assert_array_equal(a, truth)
def test_nearest_intersection_idx():
"""Test nearest index to intersection functionality."""
x = np.linspace(5, 30, 17)
y1 = 3 * x**2
y2 = 100 * x - 650
truth = np.array([2, 12])
assert_array_equal(truth, nearest_intersection_idx(y1, y2))
def test_geopotential(self):
'Test of geostrophic wind calculation with geopotential'
z = np.array([[48, 49, 48], [49, 50, 49], [48, 49, 48]]) * 100. * units('m^2/s^2')
ug, vg = geostrophic_wind(z, 1 / units.sec, 100. * units.meter, 100. * units.meter)
true_u = np.array([[-1, 0, 1]] * 3) * units('m/s')
true_v = -true_u.T
assert_array_equal(ug, true_u)
assert_array_equal(vg, true_v)
def test_geopotential(self):
'Test of geostrophic wind calculation with geopotential'
z = np.array([[48, 49, 48], [49, 50, 49], [48, 49, 48]]) * 100. * units('m^2/s^2')
ug, vg = geostrophic_wind(z, 1 / units.sec, 100. * units.meter, 100. * units.meter)
true_u = np.array([[-1, 0, 1]] * 3) * units('m/s')
true_v = -true_u.T
assert_array_equal(ug, true_u)
assert_array_equal(vg, true_v)
def test_heat_index_undefined_flag():
"""Test whether masking values can be disabled for heat index."""
temp = units.Quantity(np.ma.array([80, 88, 92, 79, 30, 81]), units.degF)
rh = np.ma.array([40, 39, 2, 70, 50, 39]) * units.percent
hi = heat_index(temp, rh, mask_undefined=False)
mask = np.array([False] * 6)
assert_array_equal(hi.mask, mask)
def test_v_vorticity():
"""Test that v_vorticity wrapper works (deprecated in 0.7)."""
a = np.arange(3)
u = np.c_[a, a, a] * units('m/s')
with pytest.warns(MetpyDeprecationWarning):
v = v_vorticity(u, u, 1 * units.meter, 1 * units.meter, dim_order='xy')
true_v = np.ones_like(u) / units.sec
assert_array_equal(v, true_v)
def test_windchill_undefined_flag():
"""Test whether masking values for windchill can be disabled."""
temp = units.Quantity(np.ma.array([49, 50, 49, 60, 80, 81]), units.degF)
speed = units.Quantity(([4, 4, 3, 1, 10, 39]), units.mph)
wc = windchill(temp, speed, mask_undefined=False)
mask = np.array([False] * 6)
assert_array_equal(wc.mask, mask)
def test_heat_index_invalid():
"""Test heat index for values that should be masked."""
temp = np.array([80, 88, 92, 79, 30, 81]) * units.degF
rh = np.array([40, 39, 2, 70, 50, 39]) * units.percent
hi = heat_index(temp, rh)
mask = np.array([False, True, True, True, True, True])
assert_array_equal(hi.mask, mask)
def test_angle_to_direction_level_2():
"""Test array of angles in degree."""
expected_dirs = [
'N', 'N', 'NE', 'NE', 'E', 'E', 'SE', 'SE',
'S', 'S', 'SW', 'SW', 'W', 'W', 'NW', 'NW'
]
output_dirs = angle_to_direction(FULL_CIRCLE_DEGREES, level=2)
assert_array_equal(output_dirs, expected_dirs)
def test_shst_zero_gradient():
"""Test shear_stretching_deformation when there is zero gradient."""
u = np.ones((3, 3)) * units('m/s')
sh, st = shearing_stretching_deformation(u, u, 1 * units.meter, 1 * units.meter,
dim_order='xy')
truth = np.zeros_like(u) / units.sec
assert_array_equal(sh, truth)
assert_array_equal(st, truth)
def test_supercell_composite():
"""Test supercell composite function."""
mucape = [2000., 1000., 500., 2000.] * units('J/kg')
esrh = [400., 150., 45., 45.] * units('m^2/s^2')
ebwd = [30., 15., 5., 5.] * units('m/s')
truth = [16., 2.25, 0., 0.]
supercell_comp = supercell_composite(mucape, esrh, ebwd)
assert_array_equal(supercell_comp, truth)
def test_convergence():
"""Test that convergence wrapper works (deprecated in 0.7)."""
a = np.arange(3)
u = np.c_[a, a, a] * units('m/s')
with pytest.warns(MetpyDeprecationWarning):
c = h_convergence(u, u, 1 * units.meter, 1 * units.meter, dim_order='xy')
true_c = np.ones_like(u) / units.sec
assert_array_equal(c, true_c)
def test_advection_2d_uniform():
"""Test advection for uniform 2D field."""
u = np.ones((3, 3)) * units('m/s')
s = np.ones_like(u) * units.kelvin
a = advection(s, [u, u], (1 * units.meter, 1 * units.meter),
dim_order='xy')
truth = np.zeros_like(u) * units('K/sec')
assert_array_equal(a, truth)
def test_zero_gradient():
"""Test divergence_vorticity when there is no gradient in the field."""
u = np.ones((3, 3)) * units('m/s')
with pytest.warns(MetpyDeprecationWarning):
c, v = convergence_vorticity(u, u, 1 * units.meter, 1 * units.meter, dim_order='xy')
truth = np.zeros_like(u) / units.sec
assert_array_equal(c, truth)
assert_array_equal(v, truth)
def test_heat_index_invalid():
"""Test heat index for values that should be masked."""
temp = np.array([80, 88, 92, 79, 30, 81]) * units.degF
rh = np.array([40, 39, 2, 70, 50, 39]) * units.percent
hi = heat_index(temp, rh)
mask = np.array([False, True, True, True, True, True])
assert_array_equal(hi.mask, mask)
def test_heat_index_undefined_flag():
"""Test whether masking values can be disabled for heat index."""
temp = units.Quantity(np.ma.array([80, 88, 92, 79, 30, 81]), units.degF)
rh = np.ma.array([40, 39, 2, 70, 50, 39]) * units.percent
hi = heat_index(temp, rh, mask_undefined=False)
mask = np.array([False] * 6)
assert_array_equal(hi.mask, mask)
def test_find_intersections_no_intersections():
"""Test finding the intersection of two curves with no intersections."""
x = np.linspace(5, 30, 17)
y1 = 3 * x + 0
y2 = 5 * x + 5
# Note: Truth is what we will get with this sampling, not the mathematical intersection
truth = np.array([[], []])
assert_array_equal(truth, find_intersections(x, y1, y2))
def test_windchill_undefined_flag():
"""Test whether masking values for windchill can be disabled."""
temp = units.Quantity(np.ma.array([49, 50, 49, 60, 80, 81]), units.degF)
speed = units.Quantity(([4, 4, 3, 1, 10, 39]), units.mph)
wc = windchill(temp, speed, mask_undefined=False)
mask = np.array([False] * 6)
assert_array_equal(wc.mask, mask)
def test_delete_masked_points():
"""Test deleting masked points."""
a = ma.masked_array(np.arange(5), mask=[False, True, False, False, False])
b = ma.masked_array(np.arange(5), mask=[False, False, False, True, False])
expected = np.array([0, 2, 4])
a, b = delete_masked_points(a, b)
assert_array_equal(a, expected)
assert_array_equal(b, expected)
def test_nearest_intersection_idx():
"""Test nearest index to intersection functionality."""
x = np.linspace(5, 30, 17)
y1 = 3 * x**2
y2 = 100 * x - 650
truth = np.array([2, 12])
assert_array_equal(truth, nearest_intersection_idx(y1, y2))
def test_precipitable_water():
"""Test precipitable water with observed sounding."""
data = get_upper_air_data(datetime(2016, 5, 22, 0), 'DDC')
pw = precipitable_water(data['pressure'],
data['dewpoint'],
top=400 * units.hPa)
truth = (0.8899441949243486 * units('inches')).to('millimeters')
assert_array_equal(pw, truth)
def test_supercell_composite():
"""Test supercell composite function."""
mucape = [2000., 1000., 500., 2000.] * units('J/kg')
esrh = [400., 150., 45., 45.] * units('m^2/s^2')
ebwd = [30., 15., 5., 5.] * units('m/s')
truth = [16., 2.25, 0., 0.]
supercell_comp = supercell_composite(mucape, esrh, ebwd)
assert_array_equal(supercell_comp, truth)
def test_precipitable_water_no_bounds():
"""Test precipitable water with observed sounding and no bounds given."""
data = get_upper_air_data(datetime(2016, 5, 22, 0), 'DDC')
dewpoint = data['dewpoint']
pressure = data['pressure']
inds = pressure >= 400 * units.hPa
pw = precipitable_water(pressure[inds], dewpoint[inds])
truth = (0.8899441949243486 * units('inches')).to('millimeters')
assert_array_equal(pw, truth)
def test_pandas_units_on_dataframe_not_all_united():
"""Unit attachment with units attribute with a column with no units."""
df = pd.DataFrame(data=[[1, 4], [2, 5], [3, 6]], columns=['cola', 'colb'])
df.units = {'cola': 'kilometers'}
res = pandas_dataframe_to_unit_arrays(df)
cola_truth = np.array([1, 2, 3]) * units.km
colb_truth = np.array([4, 5, 6])
assert_array_equal(res['cola'], cola_truth)
assert_array_equal(res['colb'], colb_truth)
def test_pandas_units_on_dataframe():
"""Unit attachment based on a units attribute to a dataframe."""
df = pd.DataFrame(data=[[1, 4], [2, 5], [3, 6]], columns=['cola', 'colb'])
df.units = {'cola': 'kilometers', 'colb': 'degC'}
res = pandas_dataframe_to_unit_arrays(df)
cola_truth = np.array([1, 2, 3]) * units.km
colb_truth = np.array([4, 5, 6]) * units.degC
assert_array_equal(res['cola'], cola_truth)
assert_array_equal(res['colb'], colb_truth)
