class Test_process(IrisTest): """Class to test end-to-end smoothing_coefficients creation""" def setUp(self): """Set up cube & plugin""" self.plugin = OrographicSmoothingCoefficients( min_smoothing_coefficient=1.0, max_smoothing_coefficient=0.0 ) self.cube = set_up_cube() def test_basic(self): """Tests that the final processing step gets the right values.""" result = self.plugin.process(self.cube) expected_x = np.array([[0.4, 0.2], [1.0, 0.6], [0.8, 1.0],]) expected_y = np.array([[0.8, 1.0, 0.6], [0.6, 0.8, 0.0],]) self.assertArrayAlmostEqual(result[0].data, expected_x) self.assertArrayAlmostEqual(result[1].data, expected_y) def test_list_error(self): """Test that a list of orography input cubes raises a value error""" with self.assertRaises(ValueError): self.plugin.process([self.cube, self.cube])
class Test_scale_smoothing_coefficients(IrisTest): """Class to test the scale_smoothing_coefficients function""" def setUp(self): """Set up cube & plugin""" self.plugin = OrographicSmoothingCoefficients() cube = set_up_cube() self.cubelist = [cube, cube] def test_basic(self): """ Test the basic function of scale_smoothing_coefficients, using the standard max and min smoothing_coefficients. """ result = self.plugin.scale_smoothing_coefficients(self.cubelist) expected = np.array([[0.1, 0.5, 1.0], [0.3, 0.4, 0.7], [0.0, 0.2, 0.1]]) self.assertArrayAlmostEqual(result[0].data, expected) self.assertArrayAlmostEqual(result[1].data, expected) def test_maxmin(self): """ Tests the function of scale_smoothing_coefficients, using a max and min value for smoothing_coefficient. """ result = self.plugin.scale_smoothing_coefficients(self.cubelist, 0.3, 0.5) expected = np.array( [[0.32, 0.40, 0.50], [0.36, 0.38, 0.44], [0.30, 0.34, 0.32]] ) self.assertArrayAlmostEqual(result[0].data, expected) self.assertArrayAlmostEqual(result[1].data, expected)
def setUp(self): """Set up cube & plugin""" self.plugin = OrographicSmoothingCoefficients( min_smoothing_coefficient=0.5, max_smoothing_coefficient=0.3) self.cube = set_up_cube() self.gradient_x, self.gradient_y = DifferenceBetweenAdjacentGridSquares( gradient=True).process(self.cube)
def test_basic(self): """Test default attribute initialisation""" result = OrographicSmoothingCoefficients() self.assertEqual(result.min_smoothing_coefficient, 0.0) self.assertEqual(result.max_smoothing_coefficient, 1.0) self.assertEqual(result.coefficient, 1.0) self.assertEqual(result.power, 1.0)
def test_basic(self): """Test that the __repr__ returns the expected string.""" result = str(OrographicSmoothingCoefficients()) msg = ("<OrographicSmoothingCoefficients: min_smoothing_coefficient: " "{}; max_smoothing_coefficient: {}; coefficient: {}; power: {}" ">".format(0.0, 1.0, 1, 1)) self.assertEqual(result, msg)
class Test_gradient_to_smoothing_coefficient(IrisTest): """Class to test smoothing_coefficients data and metadata output""" def setUp(self): """Set up cube & plugin""" self.plugin = OrographicSmoothingCoefficients( min_smoothing_coefficient=0.5, max_smoothing_coefficient=0.3) self.cube = set_up_cube() self.gradient_x, self.gradient_y = DifferenceBetweenAdjacentGridSquares( gradient=True).process(self.cube) def test_basic(self): """Test basic version of gradient to smoothing_coefficient""" expected = np.array([ [0.40666667, 0.38, 0.35333333], [0.5, 0.44666667, 0.39333333], [0.40666667, 0.48666667, 0.43333333], ]) result = self.plugin.gradient_to_smoothing_coefficient( self.gradient_x, self.gradient_y) self.assertEqual(result[0].name(), "smoothing_coefficient_x") self.assertArrayAlmostEqual(result[0].data, expected) self.assertNotIn("forecast_period", [coord.name() for coord in result[0].coords()]) self.assertNotIn("forecast_time", [coord.name() for coord in result[0].coords()])
def process( orography: cli.inputcube, *, min_smoothing_coefficient: float = 0.0, max_smoothing_coefficient: float = 1.0, coefficient: float = 1.0, power: float = 1.0, ): """Generate smoothing coefficients for recursive filtering based on orography gradients. A smoothing coefficient determines how much "value" of a cell undergoing filtering is comprised of the current value at that cell and how much comes from the adjacent cell preceding it in the direction in which filtering is being applied. A larger smoothing_coefficient results in a more significant proportion of a cell's new value coming from its neighbouring cell. The smoothing coefficients are calculated from the orography gradient using a simple equation and the user defined values for coefficient and power: smoothing_coefficient = coefficient * gradient**power The resulting values are scaled between min_smoothing_coefficient and max_smoothing_coefficient to give the desired range of smoothing_coefficients. These can be provided in reverse (i.e. min > max) to invert the smoothing coefficients in relation to the orographic gradient, providing smoothing coefficients that are largest where the orography gradient is shallowest. Args: orography (iris.cube.Cube): A 2D field of orography on the grid for which smoothing_coefficients are to be generated. min_smoothing_coefficient (float): The minimum value of smoothing_coefficient. max_smoothing_coefficient (float): The maximum value of smoothing_coefficient. coefficient (float): The coefficient for the smoothing_coefficient equation. power (float): The power for the smoothing_coefficient equation. Returns: iris.cube.CubeList: Processed CubeList containing smoothing_coefficients_x and smoothing_coefficients_y cubes. """ from improver.utilities.ancillary_creation import OrographicSmoothingCoefficients plugin = OrographicSmoothingCoefficients( min_smoothing_coefficient, max_smoothing_coefficient, coefficient, power ) return plugin(orography)
class Test_unnormalised_smoothing_coefficients(IrisTest): """Class to test the basic smoothing_coefficients function""" def setUp(self): """Set up cube & plugin""" self.plugin = OrographicSmoothingCoefficients(coefficient=0.5, power=2.0) self.cube = set_up_cube() def test_basic(self): """Test data are as expected""" expected = np.array([[1.53125, 2.53125, 3.78125], [0.0, 0.5, 2.0], [1.53125, 0.03125, 0.78125]]) gradient_x, _ = DifferenceBetweenAdjacentGridSquares( gradient=True).process(self.cube) smoothing_coefficient_x = self.plugin.unnormalised_smoothing_coefficients( gradient_x) self.assertArrayAlmostEqual(smoothing_coefficient_x.data, expected)
def setUp(self): """Set up cube & plugin""" self.plugin = OrographicSmoothingCoefficients() cube = set_up_cube() self.cubelist = [cube, cube]
def setUp(self): """Set up cube & plugin""" self.plugin = OrographicSmoothingCoefficients( min_smoothing_coefficient=1.0, max_smoothing_coefficient=0.0 ) self.cube = set_up_cube()
def setUp(self): """Set up cube & plugin""" self.plugin = OrographicSmoothingCoefficients(coefficient=0.5, power=2.0) self.cube = set_up_cube()