def setUp(self):
"""Set up expected inputs."""
super().setUp()
# Set up cubes and associated data arrays for wind speed.
self.forecast_predictor_mean = self.historic_wind_speed_forecast_cube.collapsed(
"realization", iris.analysis.MEAN
)
self.forecast_predictor_realizations = (
self.historic_wind_speed_forecast_cube.copy()
)
self.forecast_variance = self.historic_wind_speed_forecast_cube.collapsed(
"realization", iris.analysis.VARIANCE
)
self.truth = self.historic_wind_speed_forecast_cube.collapsed(
"realization", iris.analysis.MAX
)
self.forecast_predictor_data = self.forecast_predictor_mean.data.flatten().astype(
np.float64
)
self.forecast_predictor_data_realizations = convert_cube_data_to_2d(
self.historic_wind_speed_forecast_cube.copy()
).astype(np.float64)
self.forecast_variance_data = self.forecast_variance.data.flatten().astype(
np.float64
)
self.truth_data = self.truth.data.flatten().astype(np.float64)
def setUp(self):
"""Set up expected inputs."""
super().setUp()
# Set up cubes and associated data arrays for temperature.
self.forecast_predictor_mean = CubeList(
[
self.historic_temperature_forecast_cube.collapsed(
"realization", iris.analysis.MEAN
)
]
)
self.forecast_predictor_realizations = CubeList(
[(self.historic_temperature_forecast_cube.copy())]
)
self.forecast_predictor_spot = CubeList(
[
self.historic_forecast_spot_cube.collapsed(
"realization", iris.analysis.MEAN
)
]
)
self.fp_additional_predictor_spot = CubeList(
[self.forecast_predictor_spot[0].copy()]
)
self.fp_additional_predictor_spot.extend([self.spot_altitude_cube])
self.forecast_variance = self.historic_temperature_forecast_cube.collapsed(
"realization", iris.analysis.VARIANCE
)
self.forecast_variance_spot = self.forecast_predictor_spot[0].copy()
self.forecast_variance_spot.data = self.forecast_variance_spot.data / 10.0
self.truth = self.historic_temperature_forecast_cube.collapsed(
"realization", iris.analysis.MAX
)
self.forecast_predictor_data = (
self.forecast_predictor_mean[0].data.flatten().astype(np.float64)
)
self.forecast_predictor_data_realizations = convert_cube_data_to_2d(
self.historic_temperature_forecast_cube.copy()
).astype(np.float64)
self.forecast_variance_data = self.forecast_variance.data.flatten().astype(
np.float64
)
self.truth_data = self.truth.data.flatten().astype(np.float64)
spatial_product = np.prod(self.truth.shape[-2:])
self.initial_guess_spot_mean = np.broadcast_to(
self.initial_guess_for_mean,
(spatial_product, len(self.initial_guess_for_mean),),
)
self.initial_guess_spot_realizations = np.broadcast_to(
self.initial_guess_for_realization,
(spatial_product, len(self.initial_guess_for_realization),),
)
self.ig_spot_mean_additional_predictor = np.broadcast_to(
self.initial_guess_mean_additional_predictor,
(spatial_product, len(self.initial_guess_mean_additional_predictor),),
)
def test_no_transpose(self):
"""
Test that the utility returns the expected data values
when the cube is not transposed after slicing.
"""
data = self.data.T
result = convert_cube_data_to_2d(self.cube, transpose=False)
self.assertArrayAlmostEqual(result, data)
def test_change_coordinate(self):
"""
Test that the utility returns the expected data values
when the cube is sliced along the longitude dimension.
"""
data = self.data.flatten().reshape(9, 3).T.reshape(9, 3)
result = convert_cube_data_to_2d(self.cube, coord="longitude")
self.assertArrayAlmostEqual(result, data)
def test_1d_cube(self):
"""
Test that the utility returns the expected data values
when a 1d cube is input.
"""
cube = self.cube[0, 0]
expected_data = np.array([cube.data.flatten()]).T
result = convert_cube_data_to_2d(cube)
self.assertArrayAlmostEqual(result, expected_data, decimal=5)
def test_2d_cube(self):
"""
Test that the utility returns the expected data values
when a 2d cube is input.
"""
cube = next(self.cube.slices_over("realization"))
expected_data = np.array([cube.data.flatten()]).T
result = convert_cube_data_to_2d(cube)
self.assertArrayAlmostEqual(result, expected_data, decimal=5)
def test_1d_cube(self):
"""
Test that the utility returns the expected data values
when a 1d cube is input.
"""
cube = set_up_temperature_cube()
cube = cube[0, 0, 0, :]
data = np.array([[226.15, 237.4, 248.65]]).T
result = convert_cube_data_to_2d(cube)
self.assertArrayAlmostEqual(result, data, decimal=5)
def setUp(self):
"""Set up expected inputs."""
super().setUp()
# Set up cubes and associated data arrays for wind speed.
self.forecast_predictor_mean = CubeList(
[
self.historic_wind_speed_forecast_cube.collapsed(
"realization", iris.analysis.MEAN
)
]
)
self.forecast_predictor_realizations = CubeList(
[(self.historic_wind_speed_forecast_cube.copy())]
)
cube = self.historic_wind_speed_forecast_cube.collapsed(
"realization", iris.analysis.MEAN
)
altitude_cube = cube[0].copy(data=np.reshape(np.arange(0, 45, 5), (3, 3)))
altitude_cube.rename("altitude")
altitude_cube.units = "m"
for coord in [
"forecast_period",
"forecast_reference_time",
"realization",
"time",
]:
altitude_cube.remove_coord(coord)
self.forecast_predictor_mean_additional_predictor = CubeList(
[
self.historic_wind_speed_forecast_cube.collapsed(
"realization", iris.analysis.MEAN
),
altitude_cube,
]
)
self.forecast_variance = self.historic_wind_speed_forecast_cube.collapsed(
"realization", iris.analysis.VARIANCE
)
self.truth = self.historic_wind_speed_forecast_cube.collapsed(
"realization", iris.analysis.MAX
)
self.forecast_predictor_data = (
self.forecast_predictor_mean[0].data.flatten().astype(np.float64)
)
self.forecast_predictor_data_realizations = convert_cube_data_to_2d(
self.historic_wind_speed_forecast_cube.copy()
).astype(np.float64)
self.forecast_variance_data = self.forecast_variance.data.flatten().astype(
np.float64
)
self.truth_data = self.truth.data.flatten().astype(np.float64)
def test_5d_cube(self):
"""
Test that the utility returns the expected data values
when a 5d cube is input.
"""
cube = add_coordinate(self.cube, [5, 10], "height", coord_units="m")
expected_data = np.array([
cube.data[:, 0, :, :].flatten(),
cube.data[:, 1, :, :].flatten(),
cube.data[:, 2, :, :].flatten(),
]).T
result = convert_cube_data_to_2d(cube)
self.assertArrayAlmostEqual(result, expected_data, decimal=5)
def test_5d_cube(self):
"""
Test that the utility returns the expected data values
when a 5d cube is input.
"""
cube1 = set_up_temperature_cube()
height_coord = iris.coords.AuxCoord([5], standard_name="height")
cube1.add_aux_coord(height_coord)
cube2 = set_up_temperature_cube()
height_coord = iris.coords.AuxCoord([10], standard_name="height")
cube2.add_aux_coord(height_coord)
cubes = iris.cube.CubeList([cube1, cube2])
cube = cubes.merge_cube()
data = np.array([
[226.15, 230.15, 232.15],
[237.4, 241.4, 243.4],
[248.65, 252.65, 254.65],
[259.9, 263.9, 265.9],
[271.15, 275.15, 277.15],
[282.4, 286.4, 288.4],
[293.65, 297.65, 299.65],
[304.9, 308.9, 310.9],
[316.15, 320.15, 322.15],
[226.15, 230.15, 232.15],
[237.4, 241.4, 243.4],
[248.65, 252.65, 254.65],
[259.9, 263.9, 265.9],
[271.15, 275.15, 277.15],
[282.4, 286.4, 288.4],
[293.65, 297.65, 299.65],
[304.9, 308.9, 310.9],
[316.15, 320.15, 322.15],
])
result = convert_cube_data_to_2d(cube)
self.assertArrayAlmostEqual(result, data, decimal=5)
def _calculate_location_parameter_from_realizations(
self, optimised_coeffs):
"""
Function to calculate the location parameter when the ensemble
realizations are the predictor.
Further information is available in the :mod:`module level docstring \
<improver.calibration.ensemble_calibration>`.
Args:
optimised_coeffs (dict):
A dictionary containing the calibration coefficient names as
keys with their corresponding values.
Returns:
numpy.ndarray:
Location parameter calculated using the ensemble realizations
as the predictor.
"""
forecast_predictor = self.current_forecast
# Calculate location parameter = a + b1*X1 .... + bn*Xn, where X is the
# ensemble realizations. The number of b and X terms depends upon the
# number of ensemble realizations. In this case, b = beta^2.
beta_values = np.array([], dtype=np.float32)
for key in optimised_coeffs.keys():
if key.startswith("beta"):
beta_values = np.append(beta_values, optimised_coeffs[key])
a_and_b = np.append(optimised_coeffs["alpha"], beta_values**2)
forecast_predictor_flat = (
convert_cube_data_to_2d(forecast_predictor))
xy_shape = next(forecast_predictor.slices_over("realization")).shape
col_of_ones = np.ones(np.prod(xy_shape), dtype=np.float32)
ones_and_predictor = (
np.column_stack((col_of_ones, forecast_predictor_flat)))
location_parameter = (
np.dot(ones_and_predictor, a_and_b).reshape(xy_shape).astype(
np.float32))
return location_parameter
def test_check_values(self):
"""Test that the utility returns the expected data values."""
result = convert_cube_data_to_2d(self.cube)
self.assertArrayAlmostEqual(result, self.data)
def test_basic(self):
"""Test that the utility returns an iris.cube.Cube."""
result = convert_cube_data_to_2d(self.cube)
self.assertIsInstance(result, np.ndarray)