def test_cross_reference(self): # Test the creation process for a factory definition which uses # a cross-reference. param_cube = stock.realistic_4d_no_derived() orog_coord = param_cube.coord('surface_altitude') param_cube.remove_coord(orog_coord) orog_cube = param_cube[0, 0, :, :] orog_cube.data = orog_coord.points orog_cube.rename('surface_altitude') orog_cube.units = orog_coord.units orog_cube.attributes = orog_coord.attributes # We're going to test for the presence of the hybrid height # stuff later, so let's make sure it's not already there! assert len(param_cube.aux_factories) == 0 assert not param_cube.coords('surface_altitude') # The fake PPFields which will be supplied to our converter. press_field = Mock() press_field.data = param_cube.data orog_field = Mock() orog_field.data = orog_cube.data field_generator = lambda filename: [press_field, orog_field] # A fake rule set returning: # 1) A parameter cube needing an "orography" reference # 2) An "orography" cube def converter(field): if field is press_field: src = param_cube factories = [Factory(HybridHeightFactory, [Reference('orography')])] references = [] else: src = orog_cube factories = [] references = [ReferenceTarget('orography', None)] dim_coords_and_dims = [(coord, src.coord_dims(coord)[0]) for coord in src.dim_coords] aux_coords_and_dims = [(coord, src.coord_dims(coord)) for coord in src.aux_coords] return ConversionMetadata(factories, references, src.standard_name, src.long_name, src.units, src.attributes, src.cell_methods, dim_coords_and_dims, aux_coords_and_dims) # Finish by making a fake Loader fake_loader = Loader(field_generator, {}, converter, None) cubes = load_cubes(['fake_filename'], None, fake_loader) # Check the result is a generator containing two Cubes. self.assertIsInstance(cubes, types.GeneratorType) cubes = list(cubes) self.assertEqual(len(cubes), 2) # Check the "cube" has an "aux_factory" added, which itself # must have been created with the correct arguments. self.assertEqual(len(cubes[1].aux_factories), 1) self.assertEqual(len(cubes[1].coords('surface_altitude')), 1)
def test_transposed(self): cube = stock.realistic_4d_no_derived() other = cube.copy() other.transpose() res = self.cube_func(cube, other) self.assertCML(res, checksum=False) expected_data = self.data_op(cube.data, other.data.T) self.assertArrayEqual(res.data, expected_data)
def test_cross_reference(self): # Test the creation process for a factory definition which uses # a cross-reference. param_cube = stock.realistic_4d_no_derived() orog_coord = param_cube.coord('surface_altitude') param_cube.remove_coord(orog_coord) orog_cube = param_cube[0, 0, :, :] orog_cube.data = orog_coord.points orog_cube.rename('surface_altitude') orog_cube.units = orog_coord.units orog_cube.attributes = orog_coord.attributes # We're going to test for the presence of the hybrid height # stuff later, so let's make sure it's not already there! assert len(param_cube.aux_factories) == 0 assert not param_cube.coords('surface_altitude') # The fake PPFields which will be supplied to our converter. press_field = Mock() press_field.data = param_cube.data orog_field = Mock() orog_field.data = orog_cube.data field_generator = lambda filename: [press_field, orog_field] # A fake rule set returning: # 1) A parameter cube needing an "orography" reference # 2) An "orography" cube def converter(field): if field is press_field: src = param_cube factories = [Factory(HybridHeightFactory, [Reference('orography')])] references = [] else: src = orog_cube factories = [] references = [ReferenceTarget('orography', None)] dim_coords_and_dims = [(coord, src.coord_dims(coord)[0]) for coord in src.dim_coords] aux_coords_and_dims = [(coord, src.coord_dims(coord)) for coord in src.aux_coords] return (factories, references, src.standard_name, src.long_name, src.units, src.attributes, src.cell_methods, dim_coords_and_dims, aux_coords_and_dims) # Finish by making a fake Loader fake_loader = Loader(field_generator, {}, converter, None) cubes = load_cubes(['fake_filename'], None, fake_loader) # Check the result is a generator containing two Cubes. self.assertIsInstance(cubes, types.GeneratorType) cubes = list(cubes) self.assertEqual(len(cubes), 2) # Check the "cube" has an "aux_factory" added, which itself # must have been created with the correct arguments. self.assertEqual(len(cubes[1].aux_factories), 1) self.assertEqual(len(cubes[1].coords('surface_altitude')), 1)
def test_collapse_middle_dim(self): cube = stock.realistic_4d_no_derived() other = cube.collapsed(["model_level_number"], MEAN) res = self.cube_func(cube, other) self.assertCML(res, checksum=False) # Add the collapsed dimension back in via np.newaxis to enable # numpy broadcasting to function. expected_data = self.data_op(cube.data, other.data[:, np.newaxis, ...]) self.assertMaskedArrayEqual(res.data, expected_data)
def test_collapse_middle_dim(self): cube = stock.realistic_4d_no_derived() other = cube.collapsed(['model_level_number'], MEAN) res = self.cube_func(cube, other) self.assertCML(res, checksum=False) # Add the collapsed dimension back in via np.newaxis to enable # numpy broadcasting to function. expected_data = self.data_op(cube.data, other.data[:, np.newaxis, ...]) self.assertMaskedArrayEqual(res.data, expected_data)
def test_collapse_all_dims(self): cube = stock.realistic_4d_no_derived() other = cube.collapsed(cube.coords(dim_coords=True), MEAN) res = self.cube_func(cube, other) self.assertCML(res, checksum=False) # No modification to other.data is needed as numpy broadcasting # should be sufficient. expected_data = self.data_op(cube.data, other.data) # Use assertArrayEqual rather than assertMaskedArrayEqual as # collapsing all dims does not result in a masked array. self.assertArrayEqual(res.data, expected_data)
def test_collapse_last_dims(self): cube = stock.realistic_4d_no_derived() other = cube.collapsed(["grid_latitude", "grid_longitude"], MEAN) res = self.cube_func(cube, other) self.assertCML(res, checksum=False) # Transpose the dimensions in self.cube that have been collapsed in # other to lie at the front, thereby enabling numpy broadcasting to # function when applying data operator. Finish by transposing back # again to restore order. expected_data = self.data_op(cube.data.transpose((2, 3, 0, 1)), other.data).transpose(2, 3, 0, 1) self.assertMaskedArrayEqual(res.data, expected_data)
def test_collapse_zeroth_dim(self): cube = stock.realistic_4d_no_derived() other = cube.collapsed('time', MEAN) res = self.cube_func(cube, other) self.assertCML(res, checksum=False) # No modification to other.data is needed as numpy broadcasting # should be sufficient. expected_data = self.data_op(cube.data, other.data) # Use assertMaskedArrayEqual as collapsing with MEAN results # in a cube with a masked data array. self.assertMaskedArrayEqual(res.data, expected_data)
def test_collapse_last_dims(self): cube = stock.realistic_4d_no_derived() other = cube.collapsed(['grid_latitude', 'grid_longitude'], MEAN) res = self.cube_func(cube, other) self.assertCML(res, checksum=False) # Transpose the dimensions in self.cube that have been collapsed in # other to lie at the front, thereby enabling numpy broadcasting to # function when applying data operator. Finish by transposing back # again to restore order. expected_data = self.data_op(cube.data.transpose((2, 3, 0, 1)), other.data).transpose(2, 3, 0, 1) self.assertMaskedArrayEqual(res.data, expected_data)
def test_cross_reference(self): # Test the creation process for a factory definition which uses # a cross-reference. param_cube = stock.realistic_4d_no_derived() orog_coord = param_cube.coord('surface_altitude') param_cube.remove_coord(orog_coord) orog_cube = param_cube[0, 0, :, :] orog_cube.data = orog_coord.points orog_cube.rename('surface_altitude') orog_cube.units = orog_coord.units orog_cube.attributes = orog_coord.attributes # We're going to test for the presence of the hybrid height # stuff later, so let's make sure it's not already there! assert len(param_cube.aux_factories) == 0 assert not param_cube.coords('surface_altitude') press_field = Mock() orog_field = Mock() field_generator = lambda filename: [press_field, orog_field] # A fake rule set returning: # 1) A parameter cube needing an "orography" reference # 2) An "orography" cube factory = Factory(HybridHeightFactory, [Reference('orography')]) press_rule_result = RuleResult(param_cube, Mock(), [factory]) orog_rule_result= RuleResult(orog_cube, Mock(), []) rules = Mock() rules.result = lambda field: \ press_rule_result if field is press_field else orog_rule_result # A fake cross-reference rule set ref = ReferenceTarget('orography', None) orog_xref_rule = Mock() orog_xref_rule.run_actions = lambda cube, field: (ref,) xref_rules = Mock() xref_rules.matching_rules = lambda field: \ [orog_xref_rule] if field is orog_field else [] # Finish by making a fake Loader name = 'FAKE_PP' fake_loader = Loader(field_generator, {}, rules, xref_rules, name) cubes = load_cubes(['fake_filename'], None, fake_loader) # Check the result is a generator containing both of our cubes. self.assertIsInstance(cubes, types.GeneratorType) cubes = list(cubes) self.assertEqual(len(cubes), 2) self.assertIs(cubes[0], orog_cube) self.assertIs(cubes[1], param_cube) # Check the "cube" has an "aux_factory" added, which itself # must have been created with the correct arguments. self.assertEqual(len(param_cube.aux_factories), 1) self.assertEqual(len(param_cube.coords('surface_altitude')), 1)
def test_cross_reference(self): # Test the creation process for a factory definition which uses # a cross-reference. param_cube = stock.realistic_4d_no_derived() orog_coord = param_cube.coord('surface_altitude') param_cube.remove_coord(orog_coord) orog_cube = param_cube[0, 0, :, :] orog_cube.data = orog_coord.points orog_cube.rename('surface_altitude') orog_cube.units = orog_coord.units orog_cube.attributes = orog_coord.attributes # We're going to test for the presence of the hybrid height # stuff later, so let's make sure it's not already there! assert len(param_cube.aux_factories) == 0 assert not param_cube.coords('surface_altitude') press_field = Mock() orog_field = Mock() field_generator = lambda filename: [press_field, orog_field] # A fake rule set returning: # 1) A parameter cube needing an "orography" reference # 2) An "orography" cube factory = Factory(HybridHeightFactory, [Reference('orography')]) press_rule_result = RuleResult(param_cube, Mock(), [factory]) orog_rule_result = RuleResult(orog_cube, Mock(), []) rules = Mock() rules.result = lambda field: \ press_rule_result if field is press_field else orog_rule_result # A fake cross-reference rule set ref = ReferenceTarget('orography', None) orog_xref_rule = Mock() orog_xref_rule.run_actions = lambda cube, field: (ref, ) xref_rules = Mock() xref_rules.matching_rules = lambda field: \ [orog_xref_rule] if field is orog_field else [] # Finish by making a fake Loader name = 'FAKE_PP' fake_loader = Loader(field_generator, {}, rules, xref_rules, name) cubes = load_cubes(['fake_filename'], None, fake_loader) # Check the result is a generator containing both of our cubes. self.assertIsInstance(cubes, types.GeneratorType) cubes = list(cubes) self.assertEqual(len(cubes), 2) self.assertIs(cubes[0], orog_cube) self.assertIs(cubes[1], param_cube) # Check the "cube" has an "aux_factory" added, which itself # must have been created with the correct arguments. self.assertEqual(len(param_cube.aux_factories), 1) self.assertEqual(len(param_cube.coords('surface_altitude')), 1)
def setUp(self): # Modify stock cube so it is suitable to have a # hybrid pressure factory added to it. cube = stock.realistic_4d_no_derived() cube.coord('surface_altitude').rename('surface_air_pressure') cube.coord('surface_air_pressure').units = 'Pa' cube.coord('level_height').rename('level_pressure') cube.coord('level_pressure').units = 'Pa' # Construct and add hybrid pressure factory. factory = iris.aux_factory.HybridPressureFactory( cube.coord('level_pressure'), cube.coord('sigma'), cube.coord('surface_air_pressure')) cube.add_aux_factory(factory) self.cube = cube
def test_slice(self): cube = stock.realistic_4d_no_derived() for dim in range(cube.ndim): keys = [slice(None)] * cube.ndim keys[dim] = 3 other = cube[tuple(keys)] res = self.cube_func(cube, other) self.assertCML(res, checksum=False) # Add the collapsed dimension back in via np.newaxis to enable # numpy broadcasting to function. keys[dim] = np.newaxis expected_data = self.data_op(cube.data, other.data[tuple(keys)]) msg = "Problem broadcasting cubes when sliced on dimension {}." self.assertArrayEqual(res.data, expected_data, err_msg=msg.format(dim))
def setUp(self): # Modify stock cube so it is suitable to have a # hybrid pressure factory added to it. cube = stock.realistic_4d_no_derived() cube.coord("surface_altitude").rename("surface_air_pressure") cube.coord("surface_air_pressure").units = "Pa" cube.coord("level_height").rename("level_pressure") cube.coord("level_pressure").units = "Pa" # Construct and add hybrid pressure factory. factory = iris.aux_factory.HybridPressureFactory( cube.coord("level_pressure"), cube.coord("sigma"), cube.coord("surface_air_pressure") ) cube.add_aux_factory(factory) self.cube = cube
def test_slice(self): cube = stock.realistic_4d_no_derived() for dim in range(cube.ndim): keys = [slice(None)] * cube.ndim keys[dim] = 3 other = cube[tuple(keys)] res = self.cube_func(cube, other) self.assertCML(res, checksum=False) # Add the collapsed dimension back in via np.newaxis to enable # numpy broadcasting to function. keys[dim] = np.newaxis expected_data = self.data_op(cube.data, other.data[tuple(keys)]) msg = 'Problem broadcasting cubes when sliced on dimension {}.' self.assertArrayEqual(res.data, expected_data, err_msg=msg.format(dim))
def test_lbvc(self): cube = stock.realistic_4d_no_derived()[0, :4, ...] v_coord = iris.coords.DimCoord(standard_name="depth", units="m", points=[-5, -10, -15, -20]) cube.remove_coord("level_height") cube.remove_coord("sigma") cube.remove_coord("surface_altitude") cube.add_aux_coord(v_coord, 0) expected = ([2, 1, -5.0], [2, 2, -10.0], [2, 3, -15.0], [2, 4, -20.0]) for field, (lbvc, lblev, blev) in zip(fields_from_cube(cube), expected): self.assertEqual(field.lbvc, lbvc) self.assertEqual(field.lblev, lblev) self.assertEqual(field.blev, blev)
def setUp(self): # Modify stock cube so it is suitable to have a atmosphere sigma # factory added to it. cube = stock.realistic_4d_no_derived() cube.coord("surface_altitude").rename("surface_air_pressure") cube.coord("surface_air_pressure").units = "Pa" cube.coord("sigma").units = "1" ptop_coord = iris.coords.AuxCoord(1000.0, var_name="ptop", units="Pa") cube.add_aux_coord(ptop_coord, ()) cube.remove_coord("level_height") # Construct and add atmosphere sigma factory. factory = iris.aux_factory.AtmosphereSigmaFactory( cube.coord("ptop"), cube.coord("sigma"), cube.coord("surface_air_pressure"), ) cube.add_aux_factory(factory) self.cube = cube
def test_lbvc(self): cube = stock.realistic_4d_no_derived()[0, :4, ...] v_coord = iris.coords.DimCoord(standard_name='depth', units='m', points=[-5, -10, -15, -20]) cube.remove_coord('level_height') cube.remove_coord('sigma') cube.remove_coord('surface_altitude') cube.add_aux_coord(v_coord, 0) expected = ([2, 1, -5.0], [2, 2, -10.0], [2, 3, -15.0], [2, 4, -20.0]) for field, (lbvc, lblev, blev) in zip(fields_from_cube(cube), expected): self.assertEqual(field.lbvc, lbvc) self.assertEqual(field.lblev, lblev) self.assertEqual(field.blev, blev)