def test_src_km(self):
ok, bad = self.ok_bad()
regridder = Regridder(bad, ok, 'linear', 'mask')
with self.assertRaises(ValueError):
regridder(bad)
def test_grid_one_cs(self):
ok, bad = self.ok_bad(None, GeogCS(6371000))
with self.assertRaises(ValueError):
Regridder(ok, bad, *self.args)
def test_grid_inconsistent_cs(self):
ok, bad = self.ok_bad(GeogCS(6370000), GeogCS(6371000))
with self.assertRaises(ValueError):
Regridder(ok, bad, *self.args)
def test_grid_shares_dim(self):
ok, bad = self.ok_bad()
with self.assertRaises(ValueError):
Regridder(ok, bad, *self.args)
def test_grid_no_cs(self):
ok, bad = self.ok_bad(None, None)
regridder = Regridder(ok, bad, *self.args)
with self.assertRaises(ValueError):
regridder(ok)
def test_multidim(self):
# Testing with >2D data to demonstrate correct operation over
# additional non-XY dimensions (including data masking), which is
# handled by the PointInCell wrapper class.
# Define a simple target grid first, in plain latlon coordinates.
plain_latlon_cs = GeogCS(EARTH_RADIUS)
grid_x_coord = DimCoord(points=[15.0, 25.0, 35.0],
bounds=[[10.0, 20.0], [20.0, 30.0],
[30.0, 40.0]],
standard_name='longitude',
units='degrees',
coord_system=plain_latlon_cs)
grid_y_coord = DimCoord(points=[-30.0, -50.0],
bounds=[[-20.0, -40.0], [-40.0, -60.0]],
standard_name='latitude',
units='degrees',
coord_system=plain_latlon_cs)
grid_cube = Cube(np.zeros((2, 3)))
grid_cube.add_dim_coord(grid_y_coord, 0)
grid_cube.add_dim_coord(grid_x_coord, 1)
# Define some key points in true-lat/lon thta have known positions
# First 3x2 points in the centre of each output cell.
x_centres, y_centres = np.meshgrid(grid_x_coord.points,
grid_y_coord.points)
# An extra point also falling in cell 1, 1
x_in11, y_in11 = 26.3, -48.2
# An extra point completely outside the target grid
x_out, y_out = 70.0, -40.0
# Define a rotated coord system for the source data
pole_lon, pole_lat = -125.3, 53.4
src_cs = RotatedGeogCS(grid_north_pole_latitude=pole_lat,
grid_north_pole_longitude=pole_lon,
ellipsoid=plain_latlon_cs)
# Concatenate all the testpoints in a flat array, and find the rotated
# equivalents.
xx = list(x_centres.flat[:]) + [x_in11, x_out]
yy = list(y_centres.flat[:]) + [y_in11, y_out]
xx, yy = rotate_pole(lons=np.array(xx),
lats=np.array(yy),
pole_lon=pole_lon,
pole_lat=pole_lat)
# Define handy index numbers for all these.
i00, i01, i02, i10, i11, i12, i_in, i_out = range(8)
# Build test data in the shape Z,YX = (3, 8)
data = [[1, 2, 3, 11, 12, 13, 7, 99], [1, 2, 3, 11, 12, 13, 7, 99],
[7, 6, 5, 51, 52, 53, 12, 1]]
mask = [[0, 0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 1, 0],
[0, 0, 0, 0, 0, 0, 0, 0]]
src_data = np.ma.array(data, mask=mask, dtype=float)
# Make the source cube.
src_cube = Cube(src_data)
src_x = AuxCoord(xx,
standard_name='grid_longitude',
units='degrees',
coord_system=src_cs)
src_y = AuxCoord(yy,
standard_name='grid_latitude',
units='degrees',
coord_system=src_cs)
src_z = DimCoord(np.arange(3), long_name='z')
src_cube.add_dim_coord(src_z, 0)
src_cube.add_aux_coord(src_x, 1)
src_cube.add_aux_coord(src_y, 1)
# Add in some extra metadata, to ensure it gets copied over.
src_cube.add_aux_coord(DimCoord([0], long_name='extra_scalar_coord'))
src_cube.attributes['extra_attr'] = 12.3
# Define what the expected answers should be, shaped (3, 2, 3).
expected_result = [
[[1.0, 2.0, 3.0], [11.0, 0.5 * (12 + 7), 13.0]],
[[1.0, -999, 3.0], [11.0, 12.0, 13.0]],
[[7.0, 6.0, 5.0], [51.0, 0.5 * (52 + 12), 53.0]],
]
expected_result = np.ma.masked_less(expected_result, 0)
# Perform the calculation with the regridder.
regridder = Regridder(src_cube, grid_cube)
# Check all is as expected.
result = regridder(src_cube)
self.assertEqual(result.coord('z'), src_cube.coord('z'))
self.assertEqual(result.coord('extra_scalar_coord'),
src_cube.coord('extra_scalar_coord'))
self.assertEqual(result.coord('longitude'),
grid_cube.coord('longitude'))
self.assertEqual(result.coord('latitude'), grid_cube.coord('latitude'))
self.assertMaskedArrayAlmostEqual(result.data, expected_result)
def _regrid(self, method):
regridder = Regridder(self.src, self.grid, method, 'mask')
result = regridder(self.src)
qplt.pcolormesh(result)
qplt.plt.gca().coastlines()
def test_src_as_int(self):
with self.assertRaises(TypeError):
Regridder(42, self.cube, *self.args)
with self.assertRaises(TypeError):
self.regridder(42)
def test_grid_as_int(self):
with self.assertRaises(TypeError):
Regridder(self.cube, 42, *self.args)
def test_src_as_array(self):
arr = np.zeros((3, 4))
with self.assertRaises(TypeError):
Regridder(arr, self.cube, *self.args)
with self.assertRaises(TypeError):
self.regridder(arr)
def test_grid_as_array(self):
with self.assertRaises(TypeError):
Regridder(self.cube, np.zeros((3, 4)), *self.args)
def setUp(self):
self.cube = lat_lon_cube()
# Regridder method and extrapolation-mode.
self.args = ('linear', 'mask')
self.regridder = Regridder(self.cube, self.cube, *self.args)
def test_nop__nearest(self):
regridder = Regridder(self.src, self.grid, 'nearest', 'mask')
result = regridder(self.src)
self.assertEqual(result, self.src)
def _regrid(self, method):
regridder = Regridder(self.src, self.grid, method, "mask")
result = regridder(self.src)
return result
def test_grid_km(self):
ok, bad = self.ok_bad()
with self.assertRaises(ValueError):
Regridder(ok, bad, 'linear', 'mask')
def test_grid_missing_lat_lon(self):
ok, bad = self.ok_bad(['latitude', 'longitude'])
with self.assertRaises(ValueError):
Regridder(ok, bad, *self.args)
def test_reversed(self):
src = self.src
grid = self._grid_subset()
for method in self.methods:
cml = RESULT_DIR + ('{}_subset.cml'.format(method), )
regridder = Regridder(src, grid[::-1], method, self.mode)
result = regridder(src)
self.assertCMLApproxData(result[:, :, ::-1], cml)
sample = src[:, :, ::-1]
regridder = Regridder(sample, grid[::-1], method, self.mode)
result = regridder(sample)
self.assertCMLApproxData(result[:, :, ::-1], cml)
sample = src[:, :, :, ::-1]
regridder = Regridder(sample, grid[::-1], method, self.mode)
result = regridder(sample)
self.assertCMLApproxData(result[:, :, ::-1], cml)
sample = src[:, :, ::-1, ::-1]
regridder = Regridder(sample, grid[::-1], method, self.mode)
result = regridder(sample)
self.assertCMLApproxData(result[:, :, ::-1], cml)
regridder = Regridder(src, grid[:, ::-1], method, self.mode)
result = regridder(src)
self.assertCMLApproxData(result[:, :, :, ::-1], cml)
sample = src[:, :, ::-1]
regridder = Regridder(sample, grid[:, ::-1], method, self.mode)
result = regridder(sample)
self.assertCMLApproxData(result[:, :, :, ::-1], cml)
sample = src[:, :, :, ::-1]
regridder = Regridder(sample, grid[:, ::-1], method, self.mode)
result = regridder(sample)
self.assertCMLApproxData(result[:, :, :, ::-1], cml)
sample = src[:, :, ::-1, ::-1]
regridder = Regridder(sample, grid[:, ::-1], method, self.mode)
result = regridder(sample)
self.assertCMLApproxData(result[:, :, :, ::-1], cml)
regridder = Regridder(src, grid[::-1, ::-1], method, self.mode)
result = regridder(src)
self.assertCMLApproxData(result[:, :, ::-1, ::-1], cml)
sample = src[:, :, ::-1]
regridder = Regridder(sample, grid[::-1, ::-1], method, self.mode)
result = regridder(sample)
self.assertCMLApproxData(result[:, :, ::-1, ::-1], cml)
sample = src[:, :, :, ::-1]
regridder = Regridder(sample, grid[::-1, ::-1], method, self.mode)
result = regridder(sample)
self.assertCMLApproxData(result[:, :, ::-1, ::-1], cml)
sample = src[:, :, ::-1, ::-1]
regridder = Regridder(sample, grid[::-1, ::-1], method, self.mode)
result = regridder(sample)
self.assertCMLApproxData(result[:, :, ::-1, ::-1], cml)
def test_grid_with_aux_lon(self):
ok, bad = self.ok_bad('longitude')
with self.assertRaises(ValueError):
Regridder(ok, bad, *self.args)
def test_bad_src_type(self):
with self.assertRaisesRegexp(TypeError, "'src_grid_cube'"):
Regridder(self.bad, self.src_grid, self.weights)
def _regrid(self, method):
regridder = Regridder(self.src, self.grid, method, 'mask')
result = regridder(self.src)
qplt.pcolor(result, antialiased=False)
qplt.plt.gca().coastlines()
