def test_extrapolation(self):
""" Check that extrapolation filter works """
N = 5
y = np.linspace(0, 1000, N)
x = np.zeros(N)
grid = gridpp.Points(y, x, x, x, gridpp.Cartesian)
points = gridpp.Points([0, 100, 900, 1000], [0, 0, 0, 0], [0, 0, 0, 0],
[0, 0, 0, 0], gridpp.Cartesian)
Y = points.size()
pratios = 0.1 * np.ones(Y)
structure = gridpp.BarnesStructure(500)
pobs = [0, 1, 1, 0]
background = np.zeros(grid.size())
pbackground = np.zeros(Y)
max_points = 10
output0 = gridpp.optimal_interpolation(grid, background, points, pobs,
pratios, pbackground, structure,
max_points, False)
output1 = gridpp.optimal_interpolation(grid, background, points, pobs,
pratios, pbackground, structure,
max_points, True)
# Turning off extrapolation should mean we don't get increments greater than 1
self.assertTrue(np.max(output0) == 1)
self.assertTrue(np.max(output1) > 1)
I = np.where(output1 < 1)[0]
np.testing.assert_array_almost_equal(output0[I], output1[I])
def test_points_to_points(self):
"""Check that point to point interpolation works"""
ipoints = gridpp.Points([0, 5, 10], [0, 5, 10])
points = gridpp.Points([-1, 6], [-1, 6])
values = [0, 1, 2]
output = gridpp.nearest(ipoints, points, values)
np.testing.assert_array_equal(output, [0, 1])
def test_invalid_arguments(self):
""" Check that exception is thrown on invalid input values """
# Set up struct with valid input arguments
ok_args = collections.OrderedDict({
'grid':
gridpp.Grid([[0, 0, 0]], [[0, 2500, 10000]], [[0, 0, 0]],
[[0, 0, 0]], gridpp.Cartesian),
'background':
np.zeros([1, 3]),
'points':
gridpp.Points([0], [2500], [0], [0], gridpp.Cartesian),
'pobs': [1],
'pratios': [0.1],
'pbackground': [0],
'structure':
gridpp.BarnesStructure(2500),
'max_points':
10
})
# Set up struct with invalid input arguments that will be substituted into ok_args one at a
# time in order to look for an exception being raised. Use an array of different invalid
# arguments for each key.
x = np.zeros([3, 2])
invalid_args = {
# Grid size mismatch, and coordinate-type mismatch
'grid': [
gridpp.Grid(x, x, x, x, gridpp.Cartesian),
gridpp.Grid([[0, 0, 0]], [[0, 2500, 10000]])
],
# Points size mismatch, and coordinate-type mismatch
'points': [
gridpp.Points([0, 1], [0, 2500], [0, 0], [0, 0],
gridpp.Cartesian),
gridpp.Points([0], [2500])
],
'pratios': [np.zeros(11)],
'pobs': [np.zeros([11])],
'background': [np.zeros([2, 11])],
'pbackground': [np.zeros(21)],
'max_points': [-1]
}
for key in invalid_args.keys():
for arg in invalid_args[key]:
args0 = ok_args.copy()
args0[key] = arg
q = [args0[f] for f in args0]
with self.subTest(key=key, arg=arg):
with self.assertRaises(ValueError) as e:
output = gridpp.optimal_interpolation(*q)
def test_no_point_elev(self):
"""Check that output is missing when points do not have elevation defined"""
points0 = gridpp.Points([-1, 0.9], [-1, 0.9])
values = np.reshape(np.arange(9), [3, 3])
for gradient in [0, 1]:
output = gridpp.simple_gradient(grid, points0, values, gradient)
np.testing.assert_array_almost_equal(output, [np.nan, np.nan])
def test_point_to_grid_cartesian(self):
lons, lats = np.meshgrid([0, 1000, 2000], [0, 1000])
grid = gridpp.Grid(lats, lons, 0 * lats, 0 * lats, gridpp.Cartesian)
points = gridpp.Points([0, 0], [0, 600], [0, 0], [0, 0],
gridpp.Cartesian)
np.testing.assert_array_almost_equal(
gridpp.distance(points, grid, 1),
[[0, 400, 1400],
[1000,
np.sqrt(1000**2 + 400**2),
np.sqrt(1000**2 + 1400**2)]], 4)
np.testing.assert_array_almost_equal(gridpp.distance(points, grid, 2),
[[600, 1000, 2000],
[
np.sqrt(1000**2 + 600**2),
np.sqrt(2) * 1000,
np.sqrt(1000**2 + 2000**2)
]], 4)
np.testing.assert_array_almost_equal(gridpp.distance(points, grid, 10),
[[600, 1000, 2000],
[
np.sqrt(1000**2 + 600**2),
np.sqrt(2) * 1000,
np.sqrt(1000**2 + 2000**2)
]], 4)
def __init__(self, operator, geo, dataset, grid_values, max_distance=5000):
grid_lons = np.asarray(geo.lons)
grid_lats = np.asarray(geo.lats)
grid = gridpp.Grid(grid_lats, grid_lons)
lons = dataset.lons
lats = dataset.lats
points = gridpp.Points(lats, lons)
if operator == "nearest":
obs_values = gridpp.nearest(grid, points, grid_values)
elif operator == "bilinear":
obs_values = gridpp.bilinear(grid, points, grid_values)
else:
raise NotImplementedError(operator)
inside_grid = []
# Check if they are in grid
for i in range(0, len(obs_values)):
lon = lons[i]
lat = lats[i]
nn = grid.get_num_neighbours(lat, lon, max_distance)
# print(i, lons[i], lats[i], obs_values[i], nn)
if nn == 0:
inside_grid.append(False)
else:
inside_grid.append(True)
self.inside_grid = inside_grid
self.obs_values = obs_values
def test_attributes(self):
"""Test that lat, lons, etc are set"""
points = gridpp.Points([0, 1], [2, 3], [4, 5], [0.1, 0.2])
np.testing.assert_array_almost_equal(points.get_lats(), [0, 1])
np.testing.assert_array_almost_equal(points.get_lons(), [2, 3])
np.testing.assert_array_almost_equal(points.get_elevs(), [4, 5])
np.testing.assert_array_almost_equal(points.get_lafs(), [0.1, 0.2])
def test_get_nearest_neighbour(self):
points = gridpp.Points([0, 1000, 2000], [0, 1000, 2000], [0, 0, 0],
[0, 0, 0], gridpp.Cartesian)
self.assertEqual(points.get_nearest_neighbour(-100, -100), 0)
self.assertEqual(points.get_nearest_neighbour(0, 0), 0)
self.assertEqual(points.get_nearest_neighbour(900, 900), 1)
self.assertEqual(points.get_nearest_neighbour(2100, 2100), 2)
def test_get_neighbours_with_distance(self):
points = gridpp.Points([0, 1000, 2000], [0, 1000, 2000], [0, 0, 0],
[0, 0, 0], gridpp.Cartesian)
indices, distances = points.get_neighbours_with_distance(0, 0, 1500)
self.assertEqual(len(indices), 2)
np.testing.assert_array_almost_equal(distances,
[0, np.sqrt(2) * 1000], 4)
def test_grid_to_points_3d(self):
"""Check that grid to point interpolation for 3D fields works"""
lons, lats = np.meshgrid([0, 10, 20], [0, 10, 20])
grid = gridpp.Grid(lats, lons)
points = gridpp.Points([-1, 6], [-1, 6])
values = np.reshape(range(18), [2, lons.shape[0], lons.shape[1]])
output = gridpp.nearest(grid, points, values)
np.testing.assert_array_equal(output, [[0, 4], [9, 13]])
def test_get_nearest_neighbour_no_match(self):
"""Check that an exact match is removed"""
points = gridpp.Points([0, 1, 2, 2, 4], [0] * 5)
self.assertAlmostEqual(points.get_nearest_neighbour(0, 0, False), 1)
self.assertAlmostEqual(points.get_nearest_neighbour(0, 0, True), 0)
# Check that multiple of identical matches are removed
self.assertEqual(points.get_nearest_neighbour(2, 0, False), 1)
self.assertTrue(points.get_nearest_neighbour(2, 0, True) in [2, 3])
def test_one_row(self):
gridpp.set_omp_threads(1)
lons, lats = np.meshgrid([0], [30, 40, 50])
grid = gridpp.Grid(lats, lons)
values = np.zeros(lons.shape)
values[:] = np.reshape(range(3), lons.shape)
points = gridpp.Points([25, 40, 55, 25, 40, 55, 25, 40, 55, 25, 40, 55, 25, 40, 55], [-1, -1, -1, 0, 0, 0, 10, 10, 10, 20, 20, 20, 21, 21, 21])
output = gridpp.nearest(grid, points, values)
np.testing.assert_array_equal(output, (0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2))
def make_points_from_grb(grb_data, valid_points):
latlats, lonlons = np.meshgrid(
grb_data.latitude.data, grb_data.longitude.data
)
grid_object = gridpp.Points(latlats[valid_points], lonlons[valid_points])
return grid_object
def test_get_neighbours(self):
points = gridpp.Points([0, 1000, 2000], [0, 1000, 2000], [0, 0, 0],
[0, 0, 0], gridpp.Cartesian)
np.testing.assert_array_almost_equal(
np.sort(points.get_neighbours(0, 0, 1500)), [0, 1])
np.testing.assert_array_almost_equal(
np.sort(points.get_neighbours(900, 900, 1600)), [0, 1, 2])
np.testing.assert_array_almost_equal(
np.sort(points.get_neighbours(-100, -100, 100)), [])
def get_points(coordinate_type):
lats = np.array([0, 1, 2])
lons = np.array([0, 0, 0])
if coordinate_type == gridpp.Geodetic:
factor = 1
else:
factor = 111000
return gridpp.Points(lats * factor, lons * factor, lons * 0, lons * 0,
coordinate_type)
def test_grid_to_point_geodetic(self):
lons, lats = np.meshgrid([0, 1, 2], [0, 1])
grid = gridpp.Grid(lats, lons)
points = gridpp.Points([0, 0], [0, 0.6])
np.testing.assert_array_almost_equal(gridpp.distance(grid, points, 1),
[0, 44528], 0)
np.testing.assert_array_almost_equal(gridpp.distance(grid, points, 2),
[111319.49, 66791.7], 0)
np.testing.assert_array_almost_equal(gridpp.distance(grid, points, 10),
[248907.83, 191514.84], 0)
def test_missing_values(self):
"""Check that missing values are not used in OI"""
obs = np.array([1, np.nan, 2, 3, np.nan, np.nan, 4, np.nan])
N = len(obs)
y = np.arange(0, N * 1000, 1000)
background = np.zeros(N)
points = gridpp.Points(y, np.zeros(N), np.zeros(N), np.zeros(N),
gridpp.Cartesian)
ratios = np.ones(N)
structure = gridpp.BarnesStructure(1000, 0)
analysis = gridpp.optimal_interpolation(points, background, points,
obs, ratios, background,
structure, 100)
I = np.where(np.isnan(y) == 0)[0]
points1 = gridpp.Points(y[I], np.zeros(len(I)), np.zeros(len(I)),
np.zeros(len(I)), gridpp.Cartesian)
analysis1 = gridpp.optimal_interpolation(points, background, points1,
obs[I], ratios[I],
background[I], structure, 100)
np.testing.assert_array_almost_equal(analysis, analysis1)
def test_cross_validation(self):
y = np.array([0, 1000, 2000, 3000])
N = len(y)
obs = np.array([0, 1, 2, 3])
background = np.zeros(N)
points = gridpp.Points(y, np.zeros(N), np.zeros(N), np.zeros(N),
gridpp.Cartesian)
ratios = np.ones(N)
Icv = [0, 2, 3]
points_cv = gridpp.Points(y[Icv], np.zeros(N - 1), np.zeros(N - 1),
np.zeros(N - 1), gridpp.Cartesian)
structure = gridpp.BarnesStructure(1000, 0)
structure_cv = gridpp.CrossValidation(structure, 750)
analysis = gridpp.optimal_interpolation(points, background, points_cv,
obs[Icv], ratios[Icv],
background[Icv], structure,
100)
analysis_cv = gridpp.optimal_interpolation(points, background, points,
obs, ratios, background,
structure_cv, 100)
def test_empty(self):
points = gridpp.Points()
self.assertEqual(points.get_nearest_neighbour(0, 0), -1)
np.testing.assert_array_equal(points.get_closest_neighbours(0, 0, 5),
[])
np.testing.assert_array_equal(points.get_neighbours(0, 0, 1000), [])
self.assertEqual(points.get_num_neighbours(0, 0, 1000), 0)
np.testing.assert_array_equal(points.get_lats(), [])
np.testing.assert_array_equal(points.get_lons(), [])
np.testing.assert_array_equal(points.get_elevs(), [])
np.testing.assert_array_equal(points.get_lafs(), [])
self.assertEqual(points.size(), 0)
def test_copy_constructor(self):
lats = [0, 1, 2]
lons = [3, 4, 5]
elevs = [6, 7, 8]
lafs = [0.1, 0.2, 0.3]
points = gridpp.Points(lats, lons, elevs, lafs)
points2 = points
for p in [points, points2]:
np.testing.assert_array_almost_equal(p.get_lats(), lats)
np.testing.assert_array_almost_equal(p.get_lons(), lons)
np.testing.assert_array_almost_equal(p.get_elevs(), elevs)
np.testing.assert_array_almost_equal(p.get_lafs(), lafs)
def test_cross_validation_grid(self):
""" Check that the CV structure function works """
np.random.seed(1000)
y, x = np.meshgrid(np.arange(0, 3500, 500), np.arange(0, 3500, 500))
Y = y.shape[0]
X = y.shape[1]
grid = gridpp.Grid(y, x, np.zeros(x.shape), np.zeros(x.shape),
gridpp.Cartesian)
background = np.random.rand(Y, X) * 0
obs = np.array([10, 20, 30])
x_o = np.array([1000, 2000, 3000])
y_o = np.array([1000, 2000, 3000])
N = len(obs)
points = gridpp.Points(y_o, x_o, np.zeros(N), np.zeros(N),
gridpp.Cartesian)
background_o = gridpp.nearest(grid, points, background)
ratios = np.ones(N)
k = 0
ii = np.arange(N).astype('int') != k
points_cv = gridpp.Points(y_o[ii], x_o[ii], np.zeros(N - 1),
np.zeros(N - 1), gridpp.Cartesian)
structure = gridpp.BarnesStructure(1000, 0)
structure_cv = gridpp.CrossValidation(structure, 750)
analysis = gridpp.optimal_interpolation(grid, background, points_cv,
obs[ii], ratios[ii],
background_o[ii], structure,
100)
analysis_cv = gridpp.optimal_interpolation(points, background_o,
points, obs, ratios,
background_o, structure_cv,
100)
self.assertAlmostEqual(
gridpp.nearest(grid, points, analysis)[k], analysis_cv[k])
def test_1(self):
lons, lats = np.meshgrid([0, 1, 2, 3, 4], [0, 1, 2, 3, 4])
grid = gridpp.Grid(lats * 1000, lons * 1000, np.zeros([5, 5]), np.zeros([5, 5]), gridpp.Cartesian)
points = gridpp.Points([0, 0, 3000], [0, 3000, 3000], [0, 0, 0], [0, 0, 0], gridpp.Cartesian)
values = np.zeros([5, 5])
radii = [1010, 10, 2010]
value = 1
outside = False
output = gridpp.fill(grid, values, points, radii, value, outside)
np.testing.assert_array_almost_equal(output, [[1, 1, 0, 1, 0], [1, 0, 0, 1, 0],[0, 0, 1, 1, 1], [0, 1, 1, 1, 1], [0, 0, 1, 1, 1]])
outside = True
output = gridpp.fill(grid, values, points, radii, value, outside)
np.testing.assert_array_almost_equal(output, [[0, 0, 1, 0, 1], [0, 1, 1, 0, 1],[1, 1, 0, 0, 0], [1, 0, 0, 0, 0], [1, 1, 0, 0, 0]])
def test_radius_match(self):
"""Check that points right on the radius edge count as a match"""
points = gridpp.Points([0, 1000, 2000], [0, 0, 0], [0, 0, 0],
[0, 0, 0], gridpp.Cartesian)
I = points.get_neighbours(900, 0, 501)
np.testing.assert_array_equal(I, [1])
I = points.get_neighbours(900, 0, 99.99)
np.testing.assert_array_equal(I, [])
I = points.get_neighbours(0, 0, 1000)
np.testing.assert_array_equal(I, [0])
I = points.get_neighbours(0, 0, 1001)
np.testing.assert_array_equal(I, [0, 1])
I = points.get_neighbours(0, 0, 1001, False)
np.testing.assert_array_equal(I, [1])
def test_neighbourhood(self):
"""Simple check
2 X
1 X
0 X
0 1
"""
for num_treads in [1, 2]:
gridpp.set_omp_threads(num_treads)
lons, lats = np.meshgrid([0, 1], [0, 1, 2])
grid = gridpp.Grid(lats, lons)
points = gridpp.Points([0, 1, 2], [0, 0, 0])
radius = 120000
output = gridpp.count(points, grid, radius)
np.testing.assert_array_equal(output, ((2,1), (3,1), (2,1)))
def test_neighbourhood(self):
"""Simple check
50 6 7 8
40 3 4 5
30 0 1 2
0 10 20
"""
lons, lats = np.meshgrid([0, 10, 20], [30, 40, 50])
grid = gridpp.Grid(lats, lons)
values = np.zeros(lons.shape)
values[:] = np.reshape(range(9), lons.shape)
points = gridpp.Points([25, 40, 55, 25, 40, 55, 25, 40, 55, 25, 40, 55, 25, 40, 55], [-1, -1, -1, 0, 0, 0, 10, 10, 10, 20, 20, 20, 21, 21, 21])
output = gridpp.nearest(grid, points, values)
np.testing.assert_array_equal(output, (0, 3, 6, 0, 3, 6, 1, 4, 7, 2, 5, 8, 2, 5, 8))
output = gridpp.bilinear(grid, points, values)
np.testing.assert_array_equal(output, (0, 3, 6, 0, 3, 6, 1, 4, 7, 2, 5, 8, 2, 5, 8))
def test_dimension_mismatch(self):
lons, lats = np.meshgrid([0, 10, 20], [30, 40, 50])
grid = gridpp.Grid(lats, lons)
points = gridpp.Points([0, 1], [0, 1])
values = np.zeros([3, 2])
with self.assertRaises(Exception) as e:
gridpp.nearest(grid, grid, values)
with self.assertRaises(Exception) as e:
gridpp.nearest(grid, points, values)
values3 = np.zeros([3, 2, 3])
with self.assertRaises(Exception) as e:
gridpp.nearest(grid, grid, values3)
with self.assertRaises(Exception) as e:
gridpp.nearest(grid, points, values3)
def test_get_in_domain_indices(self):
lons, lats = np.meshgrid([0, 1, 2], [0, 1, 2])
grid = gridpp.Grid(lats, lons)
# 4 corners, 4 edges, inside, outside each edge
lats = np.array([0, 0, 2, 2, 0, 1, 1, 2, 1, -1, 1, 1, 3])
lons = np.array([0, 2, 0, 2, 1, 0, 2, 1, 1, 1, -1, 3, 1])
N = len(lats)
points = gridpp.Points(lats, lons)
indices = points.get_in_domain_indices(grid)
Iinside = [0, 1, 2, 3, 4, 5, 6, 7, 8]
np.testing.assert_array_equal(indices, Iinside)
points1 = points.get_in_domain(grid)
np.testing.assert_array_equal(np.sort(points1.get_lats()),
np.sort(lats[Iinside]))
np.testing.assert_array_equal(np.sort(points1.get_lons()),
np.sort(lons[Iinside]))
def test_simple_1d(self):
N = 3
y = [[0, 0, 0]]
x = [[0, 2500, 10000]]
grid = gridpp.Grid(y, x, y, y, gridpp.Cartesian)
points = gridpp.Points([0], [2500], [0], [0], gridpp.Cartesian)
pratios = [0.1]
structure = gridpp.BarnesStructure(2500)
pobs = [1]
background = np.zeros([1, N])
pbackground = [0]
max_points = 10
output = gridpp.optimal_interpolation(grid, background, points, pobs,
pratios, pbackground, structure,
max_points)
np.testing.assert_array_almost_equal(
output,
np.array([[np.exp(-0.5) / 1.1, 1 / 1.1,
np.exp(-0.5 * 9) / 1.1]]))
def test_simple_1d_full(self):
N = 3
y = [[0, 0, 0]]
x = [[0, 2500, 10000]]
grid = gridpp.Grid(y, x, y, y, gridpp.Cartesian)
points = gridpp.Points([0], [2500], [0], [0], gridpp.Cartesian)
bvariance = np.ones([1, N])
obs_variance = [0.1]
bvariance_at_points = [1]
structure = gridpp.BarnesStructure(2500)
pobs = [1]
background = np.zeros([1, N])
background_at_points = [0]
max_points = 10
output, sigma = gridpp.optimal_interpolation_full(
grid, background, bvariance, points, pobs, obs_variance,
background_at_points, bvariance_at_points, structure, max_points)
# np.testing.assert_array_almost_equal(output, np.array([[np.exp(-0.5)/1.1, 1/1.1, np.exp(-0.5*9)/1.1]]))
# np.testing.assert_array_almost_equal(sigma, np.array([[0, np.sqrt(0.1/1.1), 1]]))
self.assertAlmostEqual(sigma[0, 1], 0.1 / 1.1)
def test_grid_to_point(self):
"""Check that grid to point interpolation works
50 6 7 8
40 3 4 5
30 0 1 2
0 10 20
"""
for num_treads in [1, 2]:
gridpp.set_omp_threads(num_treads)
lons, lats = np.meshgrid([0, 10, 20], [30, 40, 50])
grid = gridpp.Grid(lats, lons)
values = np.reshape(range(9), lons.shape)
points = gridpp.Points(
[25, 40, 55, 25, 40, 55, 25, 40, 55, 25, 40, 55, 25, 40, 55],
[-1, -1, -1, 0, 0, 0, 10, 10, 10, 20, 20, 20, 21, 21, 21])
output = gridpp.nearest(grid, points, values)
np.testing.assert_array_equal(
output, (0, 3, 6, 0, 3, 6, 1, 4, 7, 2, 5, 8, 2, 5, 8))
output = gridpp.bilinear(grid, points, values)
np.testing.assert_array_equal(
output, (0, 3, 6, 0, 3, 6, 1, 4, 7, 2, 5, 8, 2, 5, 8))
