def test_exception(self): """Test an exception is raised if the chosen coordinate is non-uniform.""" coord_points = np.arange(10., 60., 10.) coord_points[0] = -200. self.cube.coord("projection_x_coordinate").points = coord_points coord = self.cube.coord("projection_x_coordinate") width = 1 method = "add" msg = "Non-uniform increments between grid points" with self.assertRaisesRegexp(ValueError, msg): SquareNeighbourhood.pad_coord(coord, width, method)
def test_use_mask_cube_occurrences_not_masked(self): """Test that the plugin returns an iris.cube.Cube with the correct data array if a mask cube is used and the mask cube does not mask out the occurrences.""" expected = np.array( [[1., 1., 1., 1., 1.], [1., 0.88888889, 0.88888889, 0.88888889, 1.], [1., 0.88888889, 0.88888889, 0.88888889, 1.], [1., 0.88888889, 0.88888889, 0.88888889, 1.], [1., 1., 1., 1., 1.]]) cube = set_up_cube( zero_point_indices=((0, 0, 2, 2),), num_grid_points=5, num_time_points=1) cube = iris.util.squeeze(cube) mask_cube = cube.copy() mask_cube.data = np.array( [[1., 1., 1., 1., 1.], [1., 1., 1., 1., 1.], [1., 1., 1., 1., 1.], [1., 1., 1., 1., 1.], [1., 1., 1., 1., 1.]]) radius = 2000 neighbourhood_method = SquareNeighbourhood() result = NBHood(neighbourhood_method, radius).process( cube, mask_cube) self.assertArrayAlmostEqual(result.data, expected)
def test_for_multiple_times(self): """ Test that the y-dimension and x-dimension accumulation produces the intended result when the input cube has multiple times. The input cube has an extra time dimension to ensure that a 3d cube is correctly handled. """ data = np.array([[[1., 2., 3., 4., 5.], [2., 4., 6., 8., 10.], [3., 6., 8., 11., 14.], [4., 8., 11., 15., 19.], [5., 10., 14., 19., 24.]], [[1., 2., 3., 4., 5.], [2., 4., 6., 8., 10.], [3., 6., 9., 12., 15.], [4., 8., 12., 15., 19.], [5., 10., 15., 19., 24.]], [[0., 1., 2., 3., 4.], [1., 3., 5., 7., 9.], [2., 5., 8., 11., 14.], [3., 7., 11., 15., 19.], [4., 9., 14., 19., 24.]]]) cube = set_up_cube(zero_point_indices=((0, 0, 2, 2), (0, 1, 3, 3), (0, 2, 0, 0)), num_time_points=3, num_grid_points=5) nan_mask = np.zeros(cube[0, 0, :, :].data.shape, dtype=int).flatten() result = SquareNeighbourhood().cumulate_array(cube) self.assertIsInstance(result[0], Cube) self.assertArrayAlmostEqual(result[0].data, data) self.assertArrayAlmostEqual(result[1][0].data, nan_mask)
def test_multiple_times_with_mask(self): """Test that the run method produces a cube with correct data when a cube containing masked data at multiple time steps is passed in.""" cube = set_up_cube(zero_point_indices=((0, 0, 2, 2), ), num_time_points=2, num_grid_points=5) data = np.array([[[[1, 1, 0, 1, 1], [1, 1, 1, 0, 0], [1, 0, 1, 0, 0], [0, 0, 1, 1, 0], [0, 1, 1, 0, 1]], [[1, 1, 0, 1, 1], [1, 1, 1, 0, 0], [1, 0, 1, 0, 0], [0, 0, 1, 0, 0], [0, 1, 1, 0, 1]]]]) mask = np.array([[[[0, 0, 1, 1, 0], [0, 1, 1, 1, 0], [0, 0, 1, 1, 1], [0, 0, 1, 1, 0], [0, 0, 1, 1, 0]], [[0, 0, 1, 1, 0], [0, 1, 1, 1, 0], [0, 1, 1, 1, 1], [0, 0, 0, 1, 0], [0, 0, 1, 1, 0]]]]) masked_data = np.ma.masked_where(mask == 0, data) cube.data = masked_data expected_array = np.array( [[[np.nan, np.nan, 0.57142857, 0.5, np.nan], [np.nan, 0.75, 0.57142857, 0.42857143, np.nan], [np.nan, np.nan, 0.71428571, 0.57142857, 0.2], [np.nan, np.nan, 0.66666667, 0.57142857, np.nan], [np.nan, np.nan, 0.66666667, 0.66666667, np.nan]], [[np.nan, np.nan, 0.57142857, 0.5, np.nan], [np.nan, 0.6, 0.5, 0.42857143, np.nan], [np.nan, 0.75, 0.42857143, 0.33333333, 0.], [np.nan, np.nan, np.nan, 0.33333333, np.nan], [np.nan, np.nan, 0.4, 0.4, np.nan]]]) result = SquareNeighbourhood().run(cube, self.RADIUS) self.assertArrayAlmostEqual(result.data.filled(), expected_array)
def test_use_mask_cube_occurrences_masked_irregular(self): """Test that the plugin returns an iris.cube.Cube with the correct data array if a mask cube is used and the mask cube does mask out the occurrences. In this case, an irregular mask is applied.""" expected = np.array([ [1.000000, 1.000000, 1.000000, 1.000000, 1.000000], [1.000000, 0.000000, 0.833333, 0.000000, 1.000000], [1.000000, 0.000000, 0.833333, 0.875000, 1.000000], [1.000000, 0.857143, 0.833333, 0.857143, 1.000000], [1.000000, 0.000000, 1.000000, 0.000000, 0.000000], ]) cube = set_up_cube(zero_point_indices=((0, 0, 2, 2), ), num_grid_points=5, num_time_points=1) cube = iris.util.squeeze(cube) mask_cube = cube.copy() mask_cube.data = np.array([ [1.0, 1.0, 1.0, 1.0, 1.0], [1.0, 0.0, 1.0, 0.0, 1.0], [1.0, 0.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0, 1.0], [1.0, 0.0, 1.0, 0.0, 0.0], ]) radius = 2000 neighbourhood_method = SquareNeighbourhood() result = NBHood(neighbourhood_method, radius)(cube, mask_cube) self.assertArrayAlmostEqual(result.data, expected)
def test_different_widths(self): """Test that padding the data in a cube with different widths has worked as intended.""" for sliced_cube in self.cube.slices( ["projection_y_coordinate", "projection_x_coordinate"]): break expected = np.array([[1., 1., 1., 1., 1., 1., 1., 1., 1.], [1., 1., 1., 1., 1., 1., 1., 1., 1.], [1., 1., 1., 1., 1., 1., 1., 1., 1.], [1., 1., 1., 1., 1., 1., 1., 1., 1.], [1., 1., 1., 1., 1., 1., 1., 1., 1.], [1., 1., 1., 1., 1., 1., 1., 1., 1.], [1., 1., 1., 1., 0., 1., 1., 1., 1.], [1., 1., 1., 1., 1., 1., 1., 1., 1.], [1., 1., 1., 1., 1., 1., 1., 1., 1.], [1., 1., 1., 1., 1., 1., 1., 1., 1.], [1., 1., 1., 1., 1., 1., 1., 1., 1.], [1., 1., 1., 1., 1., 1., 1., 1., 1.], [1., 1., 1., 1., 1., 1., 1., 1., 1.]]) width_x = 1 width_y = 2 padded_cube = SquareNeighbourhood().pad_cube_with_halo( sliced_cube, width_x, width_y) self.assertIsInstance(padded_cube, Cube) self.assertArrayAlmostEqual(padded_cube.data, expected)
def test_no_y_dimension_coordinate(self): """Test that a cube is created with the expected y and x coordinates within the output cube, if the input cube only has a projection_y_coordinate dimension coordinate.""" for sliced_cube in self.cube.slices(["projection_x_coordinate"]): break data = sliced_cube.data coord_x = sliced_cube.coord("projection_x_coordinate") coord_y = sliced_cube.coord("projection_y_coordinate") new_cube = SquareNeighbourhood()._create_cube_with_new_data( sliced_cube, data, coord_x, coord_y) self.assertIsInstance(new_cube, Cube) self.assertArrayAlmostEqual(new_cube.data, data) self.assertEqual(new_cube.coord_dims("projection_x_coordinate")[0], 0) self.assertTrue( new_cube.coords("projection_y_coordinate", dim_coords=False))
def test_with_masked_data(self): """Test that removing a halo of points from the data on a cube has worked as intended when the input data is masked.""" expected = np.array([[1., np.nan, 1.], [1., np.nan, 1.], [1., 1., 1.]]) grid_cells_x = grid_cells_y = 1 padded_cube = self.padded_cube # Set up padded cube and associated mask. mask_cube = padded_cube.copy() masked_array = np.ones(mask_cube.data.shape) masked_array[0, 0, 3, 3] = 0 masked_array[0, 0, 2, 3] = 0 mask_cube.rename('mask_data') mask_cube.data = masked_array.astype(bool) padded_cubes = CubeList([padded_cube, mask_cube]) # Set up cube without padding and associated mask. cube = self.cube mask_cube = cube.copy() masked_array = np.ones(mask_cube.data.shape) masked_array[0, 0, 1, 1] = 0 masked_array[0, 0, 0, 1] = 0 mask_cube.rename('mask_data') mask_cube.data = masked_array.astype(bool) cubes = CubeList([cube, mask_cube]) nbcube = (SquareNeighbourhood()._remove_padding_and_mask( padded_cubes, cubes, padded_cube.name(), grid_cells_x, grid_cells_y)) self.assertIsInstance(nbcube, Cube) self.assertArrayAlmostEqual(nbcube.data.filled(), expected)
def test_use_mask_cube_occurrences_masked_irregular(self): """Test that the plugin returns an iris.cube.Cube with the correct data array if a mask cube is used and the mask cube does mask out the occurrences. In this case, an irregular mask is applied.""" expected = np.array([ [1.000000, 1.000000, 1.000000, 1.000000, 1.000000], [1.000000, 0.000000, 0.833333, 0.000000, 1.000000], [1.000000, 0.000000, 0.833333, 0.875000, 1.000000], [1.000000, 0.857143, 0.833333, 0.857143, 1.000000], [1.000000, 0.000000, 1.000000, 0.000000, 0.000000], ]) data = np.ones((5, 5), dtype=np.float32) data[2, 2] = 0 cube = set_up_variable_cube( data, spatial_grid="equalarea", ) mask_cube = cube.copy() mask_cube.data = np.array([ [1.0, 1.0, 1.0, 1.0, 1.0], [1.0, 0.0, 1.0, 0.0, 1.0], [1.0, 0.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0, 1.0], [1.0, 0.0, 1.0, 0.0, 0.0], ]) radius = 2000 neighbourhood_method = SquareNeighbourhood() result = NBHood(neighbourhood_method, radius)(cube, mask_cube) self.assertArrayAlmostEqual(result.data, expected)
def test_basic(self): """Test cube with correct data is produced when mean over neighbourhood is calculated.""" nan_masks = [np.zeros(self.cube.data.shape, dtype=int)] result = SquareNeighbourhood().mean_over_neighbourhood( self.cube, self.width, self.width, nan_masks) self.assertIsInstance(result, Cube) self.assertArrayAlmostEqual(result.data, self.result)
def test_xy_order(self): """Test that a cube is created with the expected order for the y and x coordinates within the output cube, if the input cube has dimensions of projection_x_coordinate and projection_y_coordinate.""" for sliced_cube in self.cube.slices( ["projection_x_coordinate", "projection_y_coordinate"]): break data = sliced_cube.data coord_x = sliced_cube.coord("projection_x_coordinate") coord_y = sliced_cube.coord("projection_y_coordinate") new_cube = SquareNeighbourhood()._create_cube_with_new_data( sliced_cube, data, coord_x, coord_y) self.assertIsInstance(new_cube, Cube) self.assertArrayAlmostEqual(new_cube.data, data) self.assertEqual(new_cube.coord_dims("projection_y_coordinate")[0], 1) self.assertEqual(new_cube.coord_dims("projection_x_coordinate")[0], 0)
def test_without_masked_data(self): """Test setting up cubes to be neighbourhooded when the input cube does not contain masked arrays.""" cubes = (SquareNeighbourhood._set_up_cubes_to_be_neighbourhooded( self.cube)) self.assertIsInstance(cubes, CubeList) self.assertEqual(len(cubes), 1) self.assertEqual(cubes[0], self.cube)
def test_basic(self): """Test that removing a halo of points from the data on a cube has worked as intended.""" for sliced_cube in self.cube.slices( ["projection_y_coordinate", "projection_x_coordinate"]): break expected = np.array([[0.]]) width_x = width_y = 1 padded_cube = SquareNeighbourhood().remove_halo_from_cube( sliced_cube, width_x, width_y) self.assertIsInstance(padded_cube, Cube) self.assertArrayAlmostEqual(padded_cube.data, expected)
def test_forecast_period(self): """Test that a cube is created with the expected order for coordinates within the output cube, if the input cube has dimensions of projection_y_coordinate and projection_x_coordinate, and where the input cube also has a forecast_period coordinate.""" for sliced_cube in self.cube.slices( ["projection_y_coordinate", "projection_x_coordinate"]): break fp_coord = DimCoord(np.array([10]), standard_name="forecast_period") sliced_cube.add_aux_coord(fp_coord) data = sliced_cube.data coord_x = sliced_cube.coord("projection_x_coordinate") coord_y = sliced_cube.coord("projection_y_coordinate") new_cube = SquareNeighbourhood()._create_cube_with_new_data( sliced_cube, data, coord_x, coord_y) self.assertIsInstance(new_cube, Cube) self.assertArrayAlmostEqual(new_cube.data, data) self.assertEqual(new_cube.coord("forecast_period").points, 10) self.assertEqual(new_cube.coord_dims("projection_y_coordinate")[0], 0) self.assertEqual(new_cube.coord_dims("projection_x_coordinate")[0], 1)
def test_metadata(self): """Test that a cube with correct metadata is produced by the run method.""" cube = set_up_cube(zero_point_indices=((0, 0, 2, 2), ), num_time_points=1, num_grid_points=5) cube.attributes = {"Conventions": "CF-1.5"} cube.add_cell_method(CellMethod("mean", coords="time")) result = SquareNeighbourhood().run(cube, self.RADIUS) self.assertIsInstance(cube, Cube) self.assertTupleEqual(result.cell_methods, cube.cell_methods) self.assertDictEqual(result.attributes, cube.attributes)
def test_without_masked_data(self): """Test that removing a halo of points from the data on a cube has worked as intended when the input data is not masked.""" expected = np.array([[1., 1., 1.], [1., 0., 1.], [1., 1., 1.]]) grid_cells_x = grid_cells_y = 1 padded_cubes = CubeList([self.padded_cube]) cubes = CubeList([self.cube]) nbcube = (SquareNeighbourhood()._remove_padding_and_mask( padded_cubes, cubes, self.padded_cube.name(), grid_cells_x, grid_cells_y)) self.assertIsInstance(nbcube, Cube) self.assertArrayAlmostEqual(nbcube.data, expected)
def test_basic(self): """Test that a cube with correct data is produced by the run method.""" data = np.array([[1., 1., 1., 1., 1.], [1., 0.88888889, 0.88888889, 0.88888889, 1.], [1., 0.88888889, 0.88888889, 0.88888889, 1.], [1., 0.88888889, 0.88888889, 0.88888889, 1.], [1., 1., 1., 1., 1.]]) cube = set_up_cube(zero_point_indices=((0, 0, 2, 2), ), num_time_points=1, num_grid_points=5) result = SquareNeighbourhood().run(cube, self.RADIUS) self.assertIsInstance(cube, Cube) self.assertArrayAlmostEqual(result.data, data)
def test_remove(self): """Test the functionality to remove padding from the chosen coordinate. Includes a test that the coordinate bounds array is modified to reflect the new values.""" expected = np.array([30.]) expected_bounds = np.array([expected - 5, expected + 5]).T coord = self.cube.coord("projection_x_coordinate") width = 1 method = "remove" new_coord = SquareNeighbourhood.pad_coord(coord, width, method) self.assertIsInstance(new_coord, DimCoord) self.assertArrayAlmostEqual(new_coord.points, expected) self.assertArrayEqual(new_coord.bounds, expected_bounds)
def test_nan_mask(self): """Test the correct result is returned when a nan must be substituted into the final array. Note: this type of data should also be masked, so the expected_data array looks strange because there is further processing to be done on it.""" cube = self.padded_cube nan_masks = [np.zeros([9, 9]).astype(bool)] nan_masks[0][2, 2] = True expected_data = self.padded_result expected_data[0, 0] = np.nan result = SquareNeighbourhood().mean_over_neighbourhood( cube, self.width, self.width, nan_masks) self.assertArrayAlmostEqual(result.data[2:-2, 2:-2], expected_data)
def test_add(self): """Test the functionality to add padding to the chosen coordinate. Includes a test that the coordinate bounds array is modified to reflect the new values.""" expected = np.array([-10., 0., 10., 20., 30., 40., 50., 60., 70.]) coord = self.cube.coord("projection_x_coordinate") expected_bounds = np.array([expected - 5, expected + 5]).T width = 1 method = "add" new_coord = SquareNeighbourhood.pad_coord(coord, width, method) self.assertIsInstance(new_coord, DimCoord) self.assertArrayAlmostEqual(new_coord.points, expected) self.assertArrayEqual(new_coord.bounds, expected_bounds)
def test_nan_array(self): """Test that the an array containing nans is handled correctly.""" data = np.array([[np.nan, 0.777778, 1., 1., 1.], [0.777778, 0.77777778, 0.88888889, 0.88888889, 1.], [1., 0.88888889, 0.88888889, 0.88888889, 1.], [1., 0.88888889, 0.88888889, 0.88888889, 1.], [1., 1., 1., 1., 1.]]) cube = set_up_cube(zero_point_indices=((0, 0, 2, 2), ), num_time_points=1, num_grid_points=5) cube.data[0, 0, 0, 0] = np.nan result = SquareNeighbourhood().run(cube, self.RADIUS) self.assertIsInstance(cube, Cube) self.assertArrayAlmostEqual(result.data, data)
def test_multiple_times(self): """Test mean over neighbourhood with more than two dimensions.""" data = np.array([self.padded_data, self.padded_data]) cube = Cube(data, long_name='two times test') cube.add_dim_coord(self.padded_x_coord, 1) cube.add_dim_coord(self.padded_y_coord, 2) t_coord = DimCoord([0, 1], standard_name='time') cube.add_dim_coord(t_coord, 0) nan_masks = [np.zeros(cube.data[0].shape, dtype=int)] * 2 result = SquareNeighbourhood().mean_over_neighbourhood( cube, self.width, self.width, nan_masks) self.assertArrayAlmostEqual(result.data[0, 2:-2, 2:-2], self.padded_result) self.assertArrayAlmostEqual(result.data[1, 2:-2, 2:-2], self.padded_result)
def test_basic(self): """ Test that the y-dimension and x-dimension accumulation produces the intended result. A 2d cube is passed in. """ data = np.array([[1., 2., 3., 4., 5.], [2., 4., 6., 8., 10.], [3., 6., 8., 11., 14.], [4., 8., 11., 15., 19.], [5., 10., 14., 19., 24.]]) cube = set_up_cube(zero_point_indices=((0, 0, 2, 2), ), num_time_points=1, num_grid_points=5) nan_mask = np.zeros(cube.data.shape, dtype=int).flatten() result = SquareNeighbourhood().cumulate_array(cube) self.assertIsInstance(result[0], Cube) self.assertArrayAlmostEqual(result[0].data, data) self.assertArrayAlmostEqual(result[1][0].data, nan_mask)
def test_with_masked_data(self): """Test setting up cubes to be neighbourhooded when the input cube contains masked arrays.""" cube = self.cube data = cube.data cube.data[0, 0, 1, 3] = 0.5 cube.data[0, 0, 3, 3] = 0.5 cube.data = np.ma.masked_equal(data, 0.5) mask = np.logical_not(cube.data.mask.astype(int)) data = cube.data.data * mask cubes = (SquareNeighbourhood._set_up_cubes_to_be_neighbourhooded( cube.copy())) self.assertIsInstance(cubes, CubeList) self.assertEqual(len(cubes), 2) self.assertArrayAlmostEqual(cubes[0].data, data) self.assertArrayAlmostEqual(cubes[1].data, mask)
def test_nan_array(self): """Test correct nanmask is returned when array containing nan data is input.""" data = np.array([[0., 1., 2., 3., 4.], [1., 3., 5., 7., 9.], [2., 5., 7., 10., 13.], [3., 7., 10., 14., 18.], [4., 9., 13., 18., 23.]]) nanmask = np.zeros([5, 5]).astype(bool) nanmask[0, 0] = True cube = set_up_cube(zero_point_indices=((0, 0, 2, 2), ), num_time_points=1, num_grid_points=5) cube.data[0, 0, 0, 0] = np.nan result, nan_masks = SquareNeighbourhood().cumulate_array(cube) self.assertIsInstance(result, Cube) self.assertArrayAlmostEqual(result.data, data) self.assertArrayAlmostEqual(nan_masks[0], nanmask)
def test_use_mask_cube_occurrences_masked(self): """Test that the plugin returns an iris.cube.Cube with the correct data array if a mask cube is used and the mask cube does mask out the occurrences.""" data = np.ones((5, 5), dtype=np.float32) data[2, 2] = 0 cube = set_up_variable_cube(data, spatial_grid="equalarea",) expected_data = data mask_cube = cube.copy() radius = 2000 neighbourhood_method = SquareNeighbourhood() result = NBHood(neighbourhood_method, radius)(cube, mask_cube) self.assertArrayAlmostEqual(result.data, expected_data)
def test_zero_width(self): """Test that removing a halo of points from the data on a cube has worked as intended, if a width of zero is specified.""" self.cube = set_up_cube(zero_point_indices=((0, 0, 5, 5), ), num_time_points=1, num_grid_points=10) for sliced_cube in self.cube.slices( ["projection_y_coordinate", "projection_x_coordinate"]): break expected = np.array([[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.], [1., 1., 1., 1., 1., 0., 1., 1., 1., 1.]]) width_x = 0 width_y = 2 padded_cube = SquareNeighbourhood().remove_halo_from_cube( sliced_cube, width_x, width_y) self.assertIsInstance(padded_cube, Cube) self.assertArrayAlmostEqual(padded_cube.data, expected)
def test_multiple_times(self): """Test that a cube with correct data is produced by the run method when multiple times are supplied.""" expected_1 = np.array([[1., 1., 1., 1., 1.], [1., 0.88888889, 0.88888889, 0.88888889, 1.], [1., 0.88888889, 0.88888889, 0.88888889, 1.], [1., 0.88888889, 0.88888889, 0.88888889, 1.], [1., 1., 1., 1., 1.]]) expected_2 = np.array([[1., 0.88888889, 0.88888889, 0.88888889, 1.], [1., 0.88888889, 0.88888889, 0.88888889, 1.], [1., 0.88888889, 0.88888889, 0.88888889, 1.], [1., 1., 1., 1., 1.], [1., 1., 1., 1., 1.]]) cube = set_up_cube(zero_point_indices=((0, 0, 2, 2), (0, 1, 1, 2)), num_time_points=2, num_grid_points=5) result = SquareNeighbourhood().run(cube, self.RADIUS) self.assertIsInstance(cube, Cube) self.assertArrayAlmostEqual(result.data[0], expected_1) self.assertArrayAlmostEqual(result.data[1], expected_2)
def test_multiple_times_nan(self): """Test that a cube with correct data is produced by the run method for multiple times and for when nans are present.""" expected_1 = np.array( [[np.nan, 0.666667, 0.88888889, 0.88888889, 1.], [0.777778, 0.66666667, 0.77777778, 0.77777778, 1.], [1., 0.77777778, 0.77777778, 0.77777778, 1.], [1., 0.88888889, 0.88888889, 0.88888889, 1.], [1., 1., 1., 1., 1.]]) expected_2 = np.array([[0.88888889, 0.88888889, 0.88888889, 1., 1.], [0.88888889, np.nan, 0.88888889, 1., 1.], [0.88888889, 0.88888889, 0.88888889, 1., 1.], [1., 1., 1., 1., 1.], [1., 1., 1., 1., 1.]]) cube = set_up_cube(zero_point_indices=((0, 0, 2, 2), (0, 0, 1, 2)), num_time_points=2, num_grid_points=5) cube.data[0, 0, 0, 0] = np.nan cube.data[0, 1, 1, 1] = np.nan result = SquareNeighbourhood().run(cube, self.RADIUS) self.assertIsInstance(cube, Cube) self.assertArrayAlmostEqual(result.data[0], expected_1) self.assertArrayAlmostEqual(result.data[1], expected_2)
def test_without_masked_data(self): """Test setting up cubes to be padded and then passed into neighbourhood processing when the input cubes do not contain masked arrays.""" expected = np.array( [[ 1.66666667, 1.66666667, -1.22222222, -1.22222222, -1.22222222, -1.33333333, 1.66666667 ], [ 1.66666667, 1.66666667, -1.22222222, -1.22222222, -1.22222222, -1.33333333, 2.44444444 ], [ 3.22222222, 4., 0.88888889, 0.88888889, 0.88888889, 1., -1.22222222 ], [ -1.22222222, -1.22222222, 0.88888889, 0.88888889, 0.88888889, 1., -1.22222222 ], [ -1.22222222, -1.22222222, 0.88888889, 0.88888889, 0.88888889, 1., -1.22222222 ], [-1.22222222, -1.22222222, 1., 1., 1., 1., -2.11111111], [ -2.88888889, -3.66666667, -1.22222222, -1.22222222, -1.22222222, -1.33333333, 1.66666667 ]]) grid_cells_x = grid_cells_y = 1 cubes = CubeList([self.cube]) nbcubes = (SquareNeighbourhood()._pad_and_calculate_neighbourhood( cubes, grid_cells_x, grid_cells_y)) self.assertIsInstance(nbcubes, CubeList) self.assertEqual(len(nbcubes), 1) self.assertArrayAlmostEqual(nbcubes[0].data, expected)