Example #1
0
    def test_shared(self):
        # Check that saving cubes with matching ancillaries maps to a shared
        # file variable.
        testcube_1 = stock.realistic_3d()
        ancil = iris.coords.AncillaryVariable(np.zeros(testcube_1[0].shape),
                                              long_name="latlon_refs",
                                              units="s")
        testcube_1.add_ancillary_variable(ancil, (1, 2))

        testcube_2 = testcube_1.copy()
        testcube_2.units = "m"
        testcube_2.rename("alternate_data")
        with self.temp_filename(suffix=".nc") as filename:
            iris.save([testcube_1, testcube_2], filename)
            self.assertCDL(filename)

            # Also check that only one, shared ancillary variable was written.
            ds = nc.Dataset(filename)
            self.assertIn("air_potential_temperature", ds.variables)
            self.assertIn("alternate_data", ds.variables)
            self.assertEqual(
                ds.variables["air_potential_temperature"].ancillary_variables,
                "latlon_refs",
            )
            self.assertEqual(
                ds.variables["alternate_data"].ancillary_variables,
                "latlon_refs",
            )
Example #2
0
 def setUp(self):
     cube = realistic_3d()
     axes = tests.mock.sentinel.axes
     self.draw = tests.mock.sentinel.draw
     self.patcher = self.patch('cube_browser.Plot2D.draw',
                               return_value=self.draw)
     self.plot = Plot2D(cube, axes)
Example #3
0
 def setUp(self):
     self.cube = realistic_3d()
     self.axes = mock.sentinel.axes
     self.patch('IPython.display.display')
     self.patch('ipywidgets.SelectionSlider')
     self.patch('ipywidgets.VBox')
     self.patch('cube_browser.Browser.on_change')
 def setUp(self):
     super(TestCubeLoader, self).setUp()
     abs_path = os.path.dirname(os.path.abspath(__file__))
     self.tmp_dir_time = abs_path + '/' + 'tmp_dir_time/'
     self.tmp_dir = abs_path + '/' + 'tmp_dir/'
     if not os.path.exists(self.tmp_dir_time):
         os.mkdir(self.tmp_dir_time)
     if not os.path.exists(self.tmp_dir):
         os.mkdir(self.tmp_dir)
     base_cube = stock.realistic_3d()
     cube_1 = base_cube[0:2]
     cube_2 = base_cube[2:4]
     cube_3 = base_cube[4:]
     self.temp_1 = 'temp_1.nc'
     self.temp_2 = 'temp_2.nc'
     self.temp_3 = 'temp_3.nc'
     iris.save(cube_1, self.tmp_dir + self.temp_1)
     iris.save(cube_2, self.tmp_dir + self.temp_2)
     iris.save(cube_3, self.tmp_dir + self.temp_3)
     cube_1 = base_cube[0:2]
     cube_2 = base_cube[2:4]
     cube_3 = base_cube[4:]
     new_time = cf_units.Unit('hours since 1980-01-01 00:00:00',
                              'gregorian')
     cube_2.dim_coords[0].convert_units(new_time)
     new_time = cf_units.Unit('hours since 1990-01-01 00:00:00',
                              'gregorian')
     cube_3.dim_coords[0].convert_units(new_time)
     self.temp_1_time = 'temp_1_time.nc'
     self.temp_2_time = 'temp_2_time.nc'
     self.temp_3_time = 'temp_3_time.nc'
     iris.save(cube_1, self.tmp_dir_time + self.temp_1_time)
     iris.save(cube_2, self.tmp_dir_time + self.temp_2_time)
     iris.save(cube_3, self.tmp_dir_time + self.temp_3_time)
Example #5
0
 def setUp(self):
     self.cube = realistic_3d()
     self.axes = mock.sentinel.axes
     self.patch('IPython.display.display')
     self.patch('ipywidgets.SelectionSlider')
     self.patch('ipywidgets.VBox')
     self.patch('cube_browser.Browser.on_change')
Example #6
0
 def test(self):
     cube = realistic_3d()
     axes = tests.mock.sentinel.axes
     plot = Plot2D(cube, axes)
     emsg = 'requires a draw method for rendering'
     with self.assertRaisesRegexp(NotImplementedError, emsg):
         plot(time=0)
Example #7
0
 def setUp(self):
     cube = realistic_3d()
     axes = tests.mock.sentinel.axes
     self.draw = tests.mock.sentinel.draw
     self.patcher = self.patch('cube_browser.Plot2D.draw',
                               return_value=self.draw)
     self.plot = Plot2D(cube, axes)
Example #8
0
 def test(self):
     cube = realistic_3d()
     axes = tests.mock.sentinel.axes
     plot = Plot2D(cube, axes)
     emsg = 'requires a draw method for rendering'
     with self.assertRaisesRegexp(NotImplementedError, emsg):
         plot(time=0)
Example #9
0
 def setUp(self):
     self.cube = realistic_3d()
     self.axes = mock.sentinel.axes
     self.patch('IPython.display.display')
     self.value = mock.sentinel.value
     mockers = [mock.Mock(value=self.value) for i in range(20)]
     self.patch('ipywidgets.SelectionSlider', side_effect=mockers)
     self.patch('ipywidgets.VBox')
Example #10
0
 def setUp(self):
     self.cube = realistic_3d()
     self.axes = mock.sentinel.axes
     self.patch('IPython.display.display')
     self.value = mock.sentinel.value
     mockers = [mock.Mock(value=self.value) for i in range(20)]
     self.patch('ipywidgets.SelectionSlider', side_effect=mockers)
     self.patch('ipywidgets.VBox')
     self.patch('matplotlib.pyplot.colorbar')
Example #11
0
 def test_is_fix_needed_fails_latitude(self):
     cube = realistic_3d()
     cube.attributes['mip_era'] = 'CMIP6'
     cube.attributes['institution_id'] = 'FIO-QLNM'
     cube.attributes['source_id'] = 'FIO-ESM-2-0'
     for coord_name in ['latitude', 'longitude']:
         coord = cube.coord('grid_' + coord_name)
         coord.standard_name = coord_name
     fix = ch.fix_known.FixCmip6FioqlnmFioesm20Latitude(cube)
     self.assertFalse(fix.is_fix_needed())
Example #12
0
 def setUp(self):
     self.cube = realistic_3d()
     self.axes = mock.sentinel.axes
     self.patch('IPython.display.display')
     self.value = mock.sentinel.value
     mockers = [mock.Mock(value=self.value) for i in range(20)]
     self.patch('ipywidgets.SelectionSlider', side_effect=mockers)
     self.patch('ipywidgets.VBox')
     self.patch('ipywidgets.HBox')
     self.patch('ipywidgets.Label')
     self.patch('matplotlib.pyplot.colorbar')
     self.patch('cube_browser.Plot2D.legend')
Example #13
0
 def test_partialdims(self):
     # Test saving ancillary data which maps only dims 0 and 2.
     testcube = stock.realistic_3d()
     ancil = iris.coords.AncillaryVariable(
         np.zeros(testcube[:, 0, :].shape),
         long_name="time_lon_values",
         units="m",
     )
     testcube.add_ancillary_variable(ancil, (0, 2))
     with self.temp_filename(suffix=".nc") as filename:
         iris.save(testcube, filename)
         self.assertCDL(filename)
Example #14
0
 def test_separate_cache(self):
     c1 = Contour(self.cube, self.axes)
     other_cube = realistic_3d()
     c2 = Contour(other_cube, self.axes)
     browser = Browser([c1, c2])
     lookup = browser._cache_by_cube_id
     cube_id = id(self.cube)
     other_id = id(other_cube)
     expected = set([cube_id, other_id])
     self.assertEqual(set(lookup.keys()), expected)
     self.assertNotEqual(id(c1.cache), id(c2.cache))
     self.assertEqual(id(lookup[cube_id]), id(c1.cache))
     self.assertEqual(id(lookup[other_id]), id(c2.cache))
Example #15
0
 def test_separate_cache(self):
     c1 = Contour(self.cube, self.axes)
     other_cube = realistic_3d()
     c2 = Contour(other_cube, self.axes)
     browser = Browser([c1, c2])
     lookup = browser._cache_by_cube_id
     cube_id = id(self.cube)
     other_id = id(other_cube)
     expected = set([cube_id, other_id])
     self.assertEqual(set(lookup.keys()), expected)
     self.assertNotEqual(id(c1.cache), id(c2.cache))
     self.assertEqual(id(lookup[cube_id]), id(c1.cache))
     self.assertEqual(id(lookup[other_id]), id(c2.cache))
Example #16
0
    def setUp(self):
        self.cube = realistic_3d()
        self.cube.attributes['institution_id'] = 'ABCD'

        self.expected = {
            'var_name': None,
            'units': 'K',
            'long_name': None,
            'standard_name': 'air_potential_temperature',
            'time_units': 'hours since 1970-01-01 00:00:00',
            'calendar': 'gregorian',
            'activity_id': 'HighResMIP',
            'institute': 'ABCD'
        }
Example #17
0
def _get_single_time_cube(set_time_mean=False):
    cube = stock.realistic_3d()[0:1, :, :]
    cube.remove_coord('time')
    cube.remove_coord('forecast_period')
    tc = DimCoord(
        points=[15, ],
        standard_name='time',
        units=cf_units.Unit('days since epoch', calendar='360_day'),
        bounds=[[0, 30], ],
    )
    cube.add_dim_coord(tc, 0)
    if set_time_mean:
        cube.cell_methods = (CellMethod("mean", coords='time'), )
    return cube
Example #18
0
def _get_single_time_cube(set_time_mean=False):
    cube = stock.realistic_3d()[0:1, :, :]
    cube.remove_coord("time")
    cube.remove_coord("forecast_period")
    tc = DimCoord(
        points=[15],
        standard_name="time",
        units=cf_units.Unit("days since epoch", calendar="360_day"),
        bounds=[[0, 30]],
    )
    cube.add_dim_coord(tc, 0)
    if set_time_mean:
        cube.cell_methods = (CellMethod("mean", coords="time"), )
    return cube
Example #19
0
def _get_single_time_cube(set_time_mean=False):
    cube = stock.realistic_3d()[0:1, :, :]
    cube.remove_coord('time')
    cube.remove_coord('forecast_period')
    tc = DimCoord(
        points=[15, ],
        standard_name='time',
        units=cf_units.Unit('days since epoch', calendar='360_day'),
        bounds=[[0, 30], ],
    )
    cube.add_dim_coord(tc, 0)
    if set_time_mean:
        cube.cell_methods = (CellMethod("mean", coords='time'), )
    return cube
Example #20
0
    def setUp(self):
        self.cube = realistic_3d()

        self.metadata_1 = {
            'basename': 'file.nc',
            'start_date': PartialDateTime(year=2014, month=12),
            'end_date': PartialDateTime(year=2014, month=12),
            'frequency': 'mon'
        }
        self.metadata_2 = {
            'basename': 'file.nc',
            'start_date': PartialDateTime(year=2014, month=11),
            'end_date': PartialDateTime(year=2014, month=12),
            'frequency': 'mon'
        }
        self.metadata_3 = {
            'basename': 'file.nc',
            'start_date': PartialDateTime(year=2013, month=12),
            'end_date': PartialDateTime(year=2014, month=12),
            'frequency': 'mon'
        }
        self.metadata_4 = {
            'basename': 'file.nc',
            'start_date': PartialDateTime(year=2014, month=12),
            'end_date': PartialDateTime(year=2015, month=9),
            'frequency': 'mon'
        }
        self.metadata_5 = {
            'basename': 'file-clim.nc',
            'start_date': PartialDateTime(year=2014, month=12, day=20),
            'end_date': PartialDateTime(year=2014, month=12, day=22),
            'frequency': 'mon'
        }
        self.metadata_6 = {
            'basename': 'file-clim.nc',
            'start_date': PartialDateTime(year=2014, month=12, day=21),
            'end_date': PartialDateTime(year=2014, month=12, day=22),
            'frequency': 'mon'
        }
        self.metadata_high_freq = {
            'basename':
            'file.nc',
            'start_date':
            PartialDateTime(year=2014, month=12, day=21, hour=0, minute=0),
            'end_date':
            PartialDateTime(year=2014, month=12, day=22, hour=12, minute=0),
            'frequency':
            '6hr'
        }
Example #21
0
 def test_fulldims(self):
     testcube = stock.realistic_3d()
     ancil = iris.coords.AncillaryVariable(
         np.zeros(testcube.shape),
         long_name="ancil_data",
         units=1,
         attributes={
             "attr_1": 7,
             "attr_2": "chat"
         },
     )
     testcube.add_ancillary_variable(ancil, (0, 1, 2))
     with self.temp_filename(suffix=".nc") as filename:
         iris.save(testcube, filename)
         self.assertCDL(filename)
Example #22
0
    def test_aliases(self):
        # Check that saving cubes with *differing* ancillaries of the same name
        # is correctly resolved.
        testcube_1 = stock.realistic_3d()
        testcube_2 = testcube_1.copy()
        testcube_2.units = "m"
        testcube_2.rename("alternate_data")

        ancil1 = iris.coords.AncillaryVariable(np.zeros(testcube_1[0].shape),
                                               long_name="latlon_refs",
                                               units="s")
        testcube_1.add_ancillary_variable(ancil1, (1, 2))

        ancil2 = ancil1.copy()
        ancil2.data[0, 0] += 1.0
        testcube_2.add_ancillary_variable(ancil2, (1, 2))
        with self.temp_filename(suffix=".nc") as filename:
            iris.save([testcube_1, testcube_2], filename)
            self.assertCDL(filename)
Example #23
0
 def test_multiple(self):
     # Test saving with multiple ancillary variables.
     testcube = stock.realistic_3d()
     ancil1_time_lat_lon = iris.coords.AncillaryVariable(
         np.zeros(testcube.shape), long_name="data_values", units=1)
     testcube.add_ancillary_variable(ancil1_time_lat_lon, (0, 1, 2))
     ancil2_time = iris.coords.AncillaryVariable(
         np.zeros(testcube[:, 0, 0].shape),
         long_name="time_values",
         units="s",
     )
     testcube.add_ancillary_variable(ancil2_time, 0)
     ancil3_lon = iris.coords.AncillaryVariable(
         np.zeros(testcube[0, 0, :].shape),
         long_name="lon_values",
         units="m",
     )
     testcube.add_ancillary_variable(ancil3_lon, 2)
     with self.temp_filename(suffix=".nc") as filename:
         iris.save(testcube, filename)
         self.assertCDL(filename)
Example #24
0
def _make_fioesm20_cube():
    """
    Use an Iris test cube and modify the metadata and bounds to make it look
    like a CMIP6.CMIP.FIO-QLNM.FIO-ESM-2-0.historical cube, which has a
    non-monotonic latitude coordinate that is an auxillary coordinate rather
    than a dimension coordinate.

    Returns:
        An `Iris.cube.Cube` object that looks like a cube loaded from file
        for the CMIP6.CMIP.FIO-QLNM.FIO-ESM-2-0.historical experiment.
    """
    cube = realistic_3d()
    cube.attributes['mip_era'] = 'CMIP6'
    cube.attributes['institution_id'] = 'FIO-QLNM'
    cube.attributes['source_id'] = 'FIO-ESM-2-0'
    for coord_name in ['latitude', 'longitude']:
        coord = cube.coord('grid_' + coord_name)
        coord.standard_name = coord_name

    iris.util.demote_dim_coord_to_aux_coord(cube, 'latitude')
    # Cannot set invalid bounds because the setter checks them and so
    # construct new coordinate instead and replace the existing latitude
    latitude = cube.coord('latitude')
    point_spacing = latitude.points[1] - latitude.points[0]
    bounds = (np.array([latitude.points,
                        latitude.points + point_spacing]).transpose())
    bounds[-1, 1] = latitude.points[-1]

    new_latitude = iris.coords.AuxCoord(latitude.points,
                                        standard_name=latitude.standard_name,
                                        long_name=latitude.long_name,
                                        var_name=latitude.var_name,
                                        units=latitude.units,
                                        bounds=bounds,
                                        attributes=latitude.attributes,
                                        coord_system=latitude.coord_system)
    cube.replace_coord(new_latitude)
    return cube
Example #25
0
def _make_fgoals_cube():
    """
    Use an Iris test cube and modify the metadata and bounds to make it look
    like a CMIP6.CAS.FGOALS-f3-L cube. The FGOALS-f3-L bounds are not
    contiguous.

    Returns:
        An `Iris.cube.Cube` object that looks like a cube loaded from file
        for the CMIP6.CAS.FGOALS-f3-L model.
    """
    cube = realistic_3d()
    cube.attributes['mip_era'] = 'CMIP6'
    cube.attributes['institution_id'] = 'CAS'
    cube.attributes['source_id'] = 'FGOALS-f3-L'
    for coord_name in ['latitude', 'longitude']:
        coord = cube.coord('grid_' + coord_name)
        coord.standard_name = coord_name
        point_spacing = coord.points[1] - coord.points[0]
        coord.bounds = (np.array([
            coord.points - (0.4 * point_spacing),
            coord.points + (0.4 * point_spacing)
        ]).transpose())
    return cube
 def setUp(self):
     super(TestCubeHelp, self).setUp()
     abs_path = os.path.dirname(os.path.abspath(__file__))
     self.tmp_dir_time = abs_path + '/' + 'tmp_dir_time/'
     if not os.path.exists(self.tmp_dir_time):
         os.mkdir(self.tmp_dir_time)
     self.tmp_dir_ocean = abs_path + '/' + 'tmp_dir_ocean/'
     if not os.path.exists(self.tmp_dir_ocean):
         os.mkdir(self.tmp_dir_ocean)
     base_cube = stock.realistic_3d()
     cube_1 = base_cube[0:2]
     cube_2 = base_cube[2:4]
     cube_3 = base_cube[4:]
     new_time = cf_units.Unit('hours since 1980-01-01 00:00:00',
                              'gregorian')
     cube_2.dim_coords[0].convert_units(new_time)
     new_time = cf_units.Unit('hours since 1990-01-01 00:00:00',
                              'gregorian')
     cube_3.dim_coords[0].convert_units(new_time)
     self.temp_1_time = 'temp_1_time.nc'
     self.temp_2_time = 'temp_2_time.nc'
     self.temp_3_time = 'temp_3_time.nc'
     iris.save(cube_1, self.tmp_dir_time + self.temp_1_time)
     iris.save(cube_2, self.tmp_dir_time + self.temp_2_time)
     iris.save(cube_3, self.tmp_dir_time + self.temp_3_time)
     base_ocean_cube = common._generate_ocean_cube()
     base_ocean_cube = base_ocean_cube.concatenate_cube()
     cube_1 = base_ocean_cube[0:10]
     cube_2 = base_ocean_cube[10:15]
     cube_3 = base_ocean_cube[15:]
     self.temp_1_ocean = 'temp_1_ocean.nc'
     self.temp_2_ocean = 'temp_2_ocean.nc'
     self.temp_3_ocean = 'temp_3_ocean.nc'
     iris.save(cube_1, self.tmp_dir_ocean + self.temp_1_ocean)
     iris.save(cube_2, self.tmp_dir_ocean + self.temp_2_ocean)
     iris.save(cube_3, self.tmp_dir_ocean + self.temp_3_ocean)
 def test_fix_partial_datetime(self):
     test_cube = stock.realistic_3d()
     test_cube.coord('time').guess_bounds()
     test_constr_point = iris.Constraint(
         time=lambda cell: cell.point.day == 22)
     test_constr_pdt = iris.Constraint(time=iris.time.PartialDateTime(
         day=22))
     test_constr_full_pdt = iris.Constraint(
         time=iris.time.PartialDateTime(2014, 12, 22))
     test_constr_full_point = iris.Constraint(
         time=lambda cell: cell.point.year == 2014 and cell.point.month ==
         12 and cell.point.day == 22)
     fixed_constr_point = _fix_partial_datetime(test_constr_point)
     fixed_constr_pdt = _fix_partial_datetime(test_constr_pdt)
     fixed_constr_full_pdt = _fix_partial_datetime(test_constr_full_pdt)
     fixed_constr_full_point = _fix_partial_datetime(test_constr_full_point)
     self.assertNotIsInstance(fixed_constr_pdt._coord_values['time'],
                              iris.time.PartialDateTime)
     self.assertNotIsInstance(fixed_constr_full_pdt._coord_values['time'],
                              iris.time.PartialDateTime)
     self.assertNotIsInstance(fixed_constr_point._coord_values['time'],
                              iris.time.PartialDateTime)
     cube_constr_point = test_cube.extract(fixed_constr_point).coord('time')
     cube_constr_pdt = test_cube.extract(fixed_constr_pdt).coord('time')
     cube_constr_full_pdt = test_cube.extract(fixed_constr_full_pdt).coord(
         'time')
     cube_constr_full_point = test_cube.extract(
         fixed_constr_full_point).coord('time')
     self.assertEqual(cube_constr_point.points[0],
                      cube_constr_pdt.points[0])
     self.assertEqual(cube_constr_point.points[1],
                      cube_constr_pdt.points[1])
     self.assertEqual(cube_constr_full_point.points[0],
                      cube_constr_full_pdt.points[0])
     self.assertEqual(cube_constr_full_point.points[1],
                      cube_constr_full_pdt.points[1])
Example #28
0
 def setUp(self):
     self.cube = realistic_3d()
     self.coords = ('grid_longitude', 'grid_latitude')
     self.projection = iplt.default_projection(self.cube)
Example #29
0
 def setUp(self):
     self.cube = stock.realistic_3d()
     self.pp_field = mock.MagicMock(spec=pp.PPField3)
     self.pp_field.HEADER_DEFN = pp.PPField3.HEADER_DEFN
     self.patch('iris.fileformats.pp.PPField3',
                return_value=self.pp_field)
Example #30
0
    def test_bounds_mismatch(self):
        cube = stock.realistic_3d()
        cube.coord('grid_longitude').guess_bounds()

        with self.assertRaisesRegexp(ValueError, 'bounds'):
            result_non_circ = _xy_range(cube)
Example #31
0
 def setUp(self):
     self.cube = realistic_3d()
     self.axes = tests.mock.sentinel.axes
Example #32
0
    def test_non_circular(self):
        cube = stock.realistic_3d()
        assert not cube.coord("grid_longitude").circular

        result_non_circ = _xy_range(cube)
        self.assertEqual(result_non_circ, ((-5.0, 5.0), (-4.0, 4.0)))
Example #33
0
 def test_normal_cube_is_unchanged(self):
     cube = realistic_3d()
     reference_cube = realistic_3d()
     ch.fix_known_issues(cube)
     self.assertEqual(cube, reference_cube)
Example #34
0
 def test_no_fix_required_message(self):
     cube = realistic_3d()
     ch.fix_known_issues(cube)
     self.mock_logger.info.assert_not_called()
Example #35
0
 def setUp(self):
     self.cube = stock.realistic_3d()
Example #36
0
 def test_missing_attribute(self):
     cube = realistic_3d()
     fix = ExampleConcreteClass(cube)
     self.assertFalse(fix.is_fix_needed())
Example #37
0
    def test_bounds_mismatch(self):
        cube = stock.realistic_3d()
        cube.coord("grid_longitude").guess_bounds()

        with self.assertRaisesRegex(ValueError, "bounds"):
            _ = _xy_range(cube)
Example #38
0
 def test_different_attr_value(self):
     cube = realistic_3d()
     cube.attributes['attrib_1'] = 'a'
     cube.attributes['attrib_2'] = 'a'
     fix = ExampleConcreteClass(cube)
     self.assertFalse(fix.is_fix_needed())
Example #39
0
 def setUp(self):
     self.cube = realistic_3d()
     self.coords = ('grid_longitude', 'grid_latitude')
Example #40
0
 def test_all_attributes_match(self):
     cube = realistic_3d()
     cube.attributes['attrib_1'] = 'a'
     cube.attributes['attrib_2'] = 'b'
     fix = ExampleConcreteClass(cube)
     self.assertTrue(fix.is_fix_needed())
Example #41
0
 def setUp(self):
     self.cube = stock.realistic_3d()[0, 0, 0]
     self.representer = CubeRepresentation(self.cube)
     self.representer.repr_html()
Example #42
0
    def test_bounds_mismatch(self):
        cube = stock.realistic_3d()
        cube.coord('grid_longitude').guess_bounds()

        with self.assertRaisesRegex(ValueError, 'bounds'):
            result_non_circ = _xy_range(cube)
Example #43
0
 def setUp(self):
     super(TestCubeEqualiser, self).setUp()
     abs_path = os.path.dirname(os.path.abspath(__file__))
     self.tmp_dir = abs_path + '/' + 'tmp_dir/'
     self.tmp_dir_aux = abs_path + '/' + 'tmp_dir_aux/'
     self.tmp_dir_attr = abs_path + '/' + 'tmp_dir_attr/'
     self.tmp_dir_time = abs_path + '/' + 'tmp_dir_time/'
     if not os.path.exists(self.tmp_dir):
         os.mkdir(self.tmp_dir)
     if not os.path.exists(self.tmp_dir_attr):
         os.mkdir(self.tmp_dir_attr)
     if not os.path.exists(self.tmp_dir_aux):
         os.mkdir(self.tmp_dir_aux)
     if not os.path.exists(self.tmp_dir_time):
         os.mkdir(self.tmp_dir_time)
     base_cube = stock.realistic_3d()
     cube_1 = base_cube[0:2]
     cube_2 = base_cube[2:4]
     cube_3 = base_cube[4:]
     new_time = cf_units.Unit('hours since 1980-01-01 00:00:00',
                              'gregorian')
     cube_2.dim_coords[0].convert_units(new_time)
     new_time = cf_units.Unit('hours since 1990-01-01 00:00:00',
                              'gregorian')
     cube_3.dim_coords[0].convert_units(new_time)
     self.temp_1_time = 'temp_1_time.nc'
     self.temp_2_time = 'temp_2_time.nc'
     self.temp_3_time = 'temp_3_time.nc'
     iris.save(cube_1, self.tmp_dir_time + self.temp_1_time)
     iris.save(cube_2, self.tmp_dir_time + self.temp_2_time)
     iris.save(cube_3, self.tmp_dir_time + self.temp_3_time)
     cube_1 = base_cube[0:2]
     cube_2 = base_cube[2:4]
     cube_3 = base_cube[4:]
     self.temp_1 = 'temp_1.nc'
     self.temp_2 = 'temp_2.nc'
     self.temp_3 = 'temp_3.nc'
     iris.save(cube_1, self.tmp_dir + self.temp_1)
     iris.save(cube_2, self.tmp_dir + self.temp_2)
     iris.save(cube_3, self.tmp_dir + self.temp_3)
     cube_1 = base_cube[0:2]
     cube_2 = base_cube[2:4]
     cube_3 = base_cube[4:]
     cube_2.attributes['history'] = 'some differing attributes'
     cube_2.attributes['creation_date'] = 'life day'
     cube_3.attributes['tracking_id'] = 'askbjQODOQwd210934AS'
     self.temp_1_attr = 'temp_1_attr.nc'
     self.temp_2_attr = 'temp_2_attr.nc'
     self.temp_3_attr = 'temp_3_attr.nc'
     iris.save(cube_1, self.tmp_dir_attr + self.temp_1_attr)
     iris.save(cube_2, self.tmp_dir_attr + self.temp_2_attr)
     iris.save(cube_3, self.tmp_dir_attr + self.temp_3_attr)
     cube_1 = base_cube[0:2]
     cube_2 = base_cube[2:4]
     cube_3 = base_cube[4:]
     height_coord = iris.coords.AuxCoord(2,
                                         standard_name='height',
                                         long_name='height',
                                         var_name='height',
                                         units='m')
     cube_2.add_aux_coord(height_coord)
     self.temp_1_aux = 'temp_1_aux.nc'
     self.temp_2_aux = 'temp_2_aux.nc'
     self.temp_3_aux = 'temp_3_aux.nc'
     iris.save(cube_1, self.tmp_dir_aux + self.temp_1_aux)
     iris.save(cube_2, self.tmp_dir_aux + self.temp_2_aux)
     iris.save(cube_3, self.tmp_dir_aux + self.temp_3_aux)
Example #44
0
    def test_non_circular(self):
        cube = stock.realistic_3d()
        assert not cube.coord('grid_longitude').circular

        result_non_circ = _xy_range(cube)
        self.assertEqual(result_non_circ, ((-5.0, 5.0), (-4.0, 4.0)))
Example #45
0
 def setUp(self):
     self.cube = stock.realistic_3d()
Example #46
0
 def setUp(self):
     self.cube = realistic_3d()
     self.axes = tests.mock.sentinel.axes
     self.patcher = self.patch('cube_browser.Plot2D._check_coords')