def test_different_units(self):
"""Test that values are correct from input cubes with
different units, and that inputs are unmodified"""
self.temperature_cube.convert_units("fahrenheit")
self.wind_speed_cube.convert_units("knots")
self.relative_humidity_cube.convert_units("%")
self.pressure_cube.convert_units("hPa")
data = np.array([
[257.05947876, 220.76792908, 231.12779236],
[244.45491028, 259.30001831, 275.13476562],
[264.70050049, 274.29473877, 286.60421753],
])
# convert to fahrenheit
expected_result = (data * (9.0 / 5.0) - 459.67).astype(np.float32)
result = calculate_feels_like_temperature(
self.temperature_cube[0],
self.wind_speed_cube[0],
self.relative_humidity_cube[0],
self.pressure_cube[0],
)
self.assertArrayAlmostEqual(result.data, expected_result, decimal=4)
# check inputs are unmodified
self.assertEqual(self.temperature_cube.units, "fahrenheit")
self.assertEqual(self.wind_speed_cube.units, "knots")
self.assertEqual(self.relative_humidity_cube.units, "%")
self.assertEqual(self.pressure_cube.units, "hPa")
def process(temperature, wind_speed, relative_humidity, pressure):
"""Calculates the feels like temperature using the data in the input cube.
Calculate the feels like temperature using a combination of the wind chill
index and Steadman's apparent temperature equation with the following
method:
If temperature < 10 degrees C: The feels like temperature is equal to the
wind chill.
If temperature > 20 degrees C: The feels like temperature is equal to the
apparent temperature.
If 10 <= temperature <= degrees C: A weighting (alpha) is calculated in
order to blend between the wind chill and the apparent temperature.
Args:
temperature (iris.cube.Cube):
Cube of air temperature.
wind_speed (iris.cube.Cube):
Cube of 10m wind speeds.
relative_humidity (iris.cube.Cube):
Cube of relative humidities
pressure (iris.cube.Cube):
Cube of air pressure.
Returns:
iris.cube.Cube:
Cube of feels like temperature. The units of feels like temperature
will be the same as the units of temperature cube when it is input
into the function.
"""
return calculate_feels_like_temperature(temperature, wind_speed,
relative_humidity, pressure)
def test_name_and_units(self):
"""Test correct outputs for name and units."""
expected_name = "feels_like_temperature"
expected_units = 'K'
result = calculate_feels_like_temperature(
self.temperature_cube, self.wind_speed_cube,
self.relative_humidity_cube, self.pressure_cube)
self.assertEqual(result.name(), expected_name)
self.assertEqual(result.units, expected_units)
def test_temperature_less_than_10(self):
"""Test values of feels like temperature when temperature < 10
degrees C."""
self.temperature_cube.data = np.full((3, 3, 3), 282.15,
dtype=np.float32)
expected_result = np.array(
[291.863495, 278.644562, 277.094147], dtype=np.float32)
result = calculate_feels_like_temperature(
self.temperature_cube, self.wind_speed_cube,
self.relative_humidity_cube, self.pressure_cube)
self.assertArrayAlmostEqual(result[0, 0].data, expected_result)
def test_temperature_greater_than_20(self):
"""Test values of feels like temperature when temperature > 20
degrees C."""
self.temperature_cube.data = np.full((3, 3, 3), 294.15)
expected_result = np.array(
[292.290009, 287.789673, 283.289398], dtype=np.float32)
result = calculate_feels_like_temperature(
self.temperature_cube, self.wind_speed_cube,
self.relative_humidity_cube, self.pressure_cube)
self.assertArrayAlmostEqual(result[0, 0].data, expected_result)
def test_temperature_between_10_and_20(self):
"""Test values of feels like temperature when temperature is between 10
and 20 degress C."""
self.temperature_cube.data = np.full((3, 3, 3), 287.15)
expected_result = np.array(
[290.986603, 283.217041, 280.669495], dtype=np.float32)
result = calculate_feels_like_temperature(
self.temperature_cube, self.wind_speed_cube,
self.relative_humidity_cube, self.pressure_cube)
self.assertArrayAlmostEqual(result[0, 0].data, expected_result)
def test_temperature_between_10_and_20(self):
"""Test values of feels like temperature when temperature is between 10
and 20 degress C."""
self.temperature_cube.data = np.full((3, 1, 3, 3), 287.15)
expected_result = ([[
290.98659999999995, 283.21703936566627, 280.66949456155015
]])
result = calculate_feels_like_temperature(self.temperature_cube,
self.wind_speed_cube,
self.relative_humidity_cube,
self.pressure_cube)
self.assertArrayAlmostEqual(result[0, :, 0].data, expected_result)
def test_temperature_less_than_10(self):
"""Test values of feels like temperature when temperature < 10
degrees C."""
self.temperature_cube.data = np.full((3, 1, 3, 3), 282.15)
expected_result = ([[
291.86349999999999, 278.64456962610683, 277.09415911417699
]])
result = calculate_feels_like_temperature(self.temperature_cube,
self.wind_speed_cube,
self.relative_humidity_cube,
self.pressure_cube)
self.assertArrayAlmostEqual(result[0, :, 0].data, expected_result)
def test_unit_conversion(self):
"""Test that input cubes have the same units at the end of the function
as they do at input"""
self.temperature_cube.convert_units('fahrenheit')
self.wind_speed_cube.convert_units('knots')
self.relative_humidity_cube.convert_units('%')
self.pressure_cube.convert_units('hPa')
calculate_feels_like_temperature(
self.temperature_cube, self.wind_speed_cube,
self.relative_humidity_cube, self.pressure_cube)
temp_units = self.temperature_cube.units
wind_speed_units = self.wind_speed_cube.units
relative_humidity_units = self.relative_humidity_cube.units
pressure_units = self.pressure_cube.units
self.assertEqual(temp_units, 'fahrenheit')
self.assertEqual(wind_speed_units, 'knots')
self.assertEqual(relative_humidity_units, '%')
self.assertEqual(pressure_units, 'hPa')
def process(
temperature: cli.inputcube,
wind_speed: cli.inputcube,
relative_humidity: cli.inputcube,
pressure: cli.inputcube,
*,
model_id_attr: str = None,
):
"""Calculates the feels like temperature using the data in the input cube.
Calculate the feels like temperature using a combination of the wind chill
index and Steadman's apparent temperature equation with the following
method:
If temperature < 10 degrees C: The feels like temperature is equal to the
wind chill.
If temperature > 20 degrees C: The feels like temperature is equal to the
apparent temperature.
If 10 <= temperature <= degrees C: A weighting (alpha) is calculated in
order to blend between the wind chill and the apparent temperature.
Args:
temperature (iris.cube.Cube):
Cube of air temperatures at screen level
wind_speed (iris.cube.Cube):
Cube of wind speed at 10m
relative_humidity (iris.cube.Cube):
Cube of relative humidity at screen level
pressure (iris.cube.Cube):
Cube of mean sea level pressure
model_id_attr (str):
Name of the attribute used to identify the source model for
blending.
Returns:
iris.cube.Cube:
Cube of feels like temperature. The units of feels like temperature
will be the same as the units of temperature cube when it is input
into the function.
"""
from improver.feels_like_temperature import calculate_feels_like_temperature
return calculate_feels_like_temperature(
temperature,
wind_speed,
relative_humidity,
pressure,
model_id_attr=model_id_attr,
)
def test_model_id_attr(self):
"""Test model id attribute can be selectively inherited"""
model_id_attr = "mosg__model_configuration"
attrs = ["title", "source", "institution", model_id_attr]
expected_attrs = {
attr: self.temperature_cube.attributes[attr]
for attr in attrs
}
result = calculate_feels_like_temperature(self.temperature_cube,
self.wind_speed_cube,
self.relative_humidity_cube,
self.pressure_cube,
model_id_attr=model_id_attr)
self.assertDictEqual(result.attributes, expected_attrs)
def test_temperature_range_and_bounds(self):
"""Test temperature values across the full range including boundary
temperatures 10 degrees Celcius and 20 degrees Celcius"""
self.temperature_cube = set_up_temperature_cube()[0]
data = np.linspace(-10, 30, 9).reshape(1, 3, 3)
data = data + 273.15
self.temperature_cube.data = data
expected_result = np.array(
[[[280.05499999999995, 260.53790629143003, 264.74498482704507],
[270.41447781935329, 276.82207516713441, 273.33273779977668],
[264.11408954000001, 265.66779343999997, 267.76949669999999]]])
result = calculate_feels_like_temperature(
self.temperature_cube, self.wind_speed_cube[0],
self.relative_humidity_cube[0], self.pressure_cube[0])
self.assertArrayAlmostEqual(result.data, expected_result)
def test_temperature_range_and_bounds(self):
"""Test temperature values across the full range including boundary
temperatures 10 degrees Celcius and 20 degrees Celcius"""
temperature_cube = self.temperature_cube[0]
data = np.linspace(-10, 30, 9).reshape(3, 3)
data = data + 273.15
temperature_cube.data = data
expected_result = np.array(
[[280.05499268, 260.53790283, 264.74499512],
[270.41448975, 276.82208252, 273.33273315],
[264.11410522, 265.66778564, 267.76950073]],
dtype=np.float32)
result = calculate_feels_like_temperature(
temperature_cube, self.wind_speed_cube[0],
self.relative_humidity_cube[0], self.pressure_cube[0])
self.assertArrayAlmostEqual(result.data, expected_result)
def test_different_units(self):
"""Test that values are correct from input cubes with
different units"""
self.temperature_cube.convert_units('fahrenheit')
self.wind_speed_cube.convert_units('knots')
self.relative_humidity_cube.convert_units('%')
self.pressure_cube.convert_units('hPa')
data = np.array(
[[[257.05949999999996, 220.76791360990785, 231.12778815651939],
[244.45492051555226, 259.30003784711084, 275.1347693144458],
[264.70048734, 274.29471727999999, 286.60422231999996]]])
# convert to fahrenheit
expected_result = data * (9.0 / 5.0) - 459.67
result = calculate_feels_like_temperature(
self.temperature_cube[0], self.wind_speed_cube[0],
self.relative_humidity_cube[0], self.pressure_cube[0])
self.assertArrayAlmostEqual(result.data, expected_result)
def main(argv=None):
""" Load in the arguments for feels like temperature and ensure they are
set correctly. Then calculate the feels like temperature using the data
in the input cubes."""
parser = ArgParser(
description="This calculates the feels like temperature using a "
"combination of the wind chill index and Steadman's "
"apparent temperature equation.")
parser.add_argument("temperature",
metavar="TEMPERATURE",
help="Path to a NetCDF file of air temperatures at "
"screen level.")
parser.add_argument("wind_speed",
metavar="WIND_SPEED",
help="Path to the NetCDF file of wind speed at 10m.")
parser.add_argument("relative_humidity",
metavar="RELATIVE_HUMIDITY",
help="Path to the NetCDF file of relative humidity "
"at screen level.")
parser.add_argument("pressure",
metavar="PRESSURE",
help="Path to a NetCDF file of mean sea level "
"pressure.")
parser.add_argument("output_filepath",
metavar="OUTPUT_FILE",
help="The output path for the processed NetCDF")
args = parser.parse_args(args=argv)
temperature = load_cube(args.temperature)
wind_speed = load_cube(args.wind_speed)
relative_humidity = load_cube(args.relative_humidity)
pressure = load_cube(args.pressure)
result = calculate_feels_like_temperature(temperature, wind_speed,
relative_humidity, pressure)
save_netcdf(result, args.output_filepath)
