class Test_process(IrisTest):
"""Class to test end-to-end alphas creation"""
def setUp(self):
"""Set up cube & plugin"""
self.plugin = OrographicAlphas()
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.53333333, 0.4, 0.26666667],
[1., 0.73333333, 0.46666667],
[0.53333333, 0.93333333, 0.66666667]])
expected_y = np.array([[0.4, 0.93333333, 0.8], [0.93333333, 0.8, 0.4],
[0.26666667, 0.66666667, 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_alphas(IrisTest):
"""Class to test the scale_alphas function"""
def setUp(self):
"""Set up cube & plugin"""
self.plugin = OrographicAlphas()
cube = set_up_cube()
self.cubelist = [cube, cube]
def test_basic(self):
"""
Test the basic function of scale_alphas, using the
standard max and min alphas.
"""
result = self.plugin.scale_alphas(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_alphas, using a max
and min value for alpha.
"""
result = self.plugin.scale_alphas(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 = OrographicAlphas(min_alpha=0.3, max_alpha=0.5)
self.cube = set_up_cube()
self.gradient_x, self.gradient_y = \
DifferenceBetweenAdjacentGridSquares(gradient=True).process(
self.cube)
def test_basic(self):
"""Test that the __repr__ returns the expected string."""
result = str(OrographicAlphas())
msg = ('<OrographicAlphas: min_alpha: {}; max_alpha: {}; '
'coefficient: {}; power: {}; '
'invert_alphas: {}>'.format(0.0, 1.0, 1, 1, True))
self.assertEqual(result, msg)
class Test_gradient_to_alpha(IrisTest):
"""Class to test alphas data and metadata output"""
def setUp(self):
"""Set up cube & plugin"""
self.plugin = OrographicAlphas(min_alpha=0.3, max_alpha=0.5)
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 alpha"""
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_alpha(self.gradient_x,
self.gradient_y)
self.assertEqual(result[0].name(), 'alphas')
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_alpha: float = 0.0,
max_alpha: float = 1.0,
coefficient: float = 1.0,
power: float = 1.0,
invert_alphas=True):
"""Generate alpha smoothing parameters for recursive filtering based on
orography gradients.
Args:
orography (iris.cube.Cube):
A 2D field of orography for the grid to generate alphas for.
min_alpha (float):
The minimum value of alpha.
max_alpha (float):
The maximum value of alpha.
coefficient (float):
The coefficient for the alpha calculation.
power (float):
The power for the alpha equation.
invert_alphas (bool):
If True then the max and min alpha values will be swapped.
Returns:
iris.cube.CubeList:
Processed CubeList containing alpha_x and alpha_y cubes.
"""
from improver.utilities.ancillary_creation import OrographicAlphas
return OrographicAlphas(min_alpha, max_alpha, coefficient, power,
invert_alphas).process(orography)
def test_basic(self):
"""Test default attribute initialisation"""
result = OrographicAlphas()
self.assertTrue(result.invert_alphas)
self.assertEqual(result.min_alpha, 0.)
self.assertEqual(result.max_alpha, 1.)
self.assertEqual(result.coefficient, 1.)
self.assertEqual(result.power, 1.)
class Test_unnormalised_alphas(IrisTest):
"""Class to test the basic alphas function"""
def setUp(self):
"""Set up cube & plugin"""
self.plugin = OrographicAlphas(coefficient=0.5, power=2.)
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.5, 2.],
[1.53125, 0.03125, 0.78125]])
gradient_x, _ = \
DifferenceBetweenAdjacentGridSquares(gradient=True).process(
self.cube)
alpha_x = self.plugin.unnormalised_alphas(gradient_x)
self.assertArrayAlmostEqual(alpha_x.data, expected)
def setUp(self):
"""Set up cube & plugin"""
self.plugin = OrographicAlphas()
cube = set_up_cube()
self.cubelist = [cube, cube]
def setUp(self):
"""Set up cube & plugin"""
self.plugin = OrographicAlphas(coefficient=0.5, power=2.)
self.cube = set_up_cube()