Beispiel #1
0
 def test_tri_polar(self):
     # extract
     sampled_cube = traj_interpolate(self.cube,
                                     self.sample_points,
                                     method="nearest")
     self.assertCML(sampled_cube,
                    ("trajectory", "tri_polar_latitude_slice.cml"))
 def test_colpex__nearest(self):
     # Check a smallish nearest-neighbour interpolation against a result
     # snapshot.
     test_cube = self.cube[0][0]
     # Test points on a regular grid, a bit larger than the source region.
     xmin, xmax = [fn(test_cube.coord(axis='x').points)
                   for fn in (np.min, np.max)]
     ymin, ymax = [fn(test_cube.coord(axis='x').points)
                   for fn in (np.min, np.max)]
     fractions = [-0.23, -0.01, 0.27, 0.624, 0.983, 1.052, 1.43]
     x_points = [xmin + frac * (xmax - xmin) for frac in fractions]
     y_points = [ymin + frac * (ymax - ymin) for frac in fractions]
     x_points, y_points = np.meshgrid(x_points, y_points)
     sample_points = [('grid_longitude', x_points.flatten()),
                      ('grid_latitude', y_points.flatten())]
     result = traj_interpolate(test_cube, sample_points,
                               method='nearest')
     expected = [
         288.07168579, 288.07168579, 287.9367981, 287.82736206,
         287.78564453, 287.8374939, 287.8374939, 288.07168579,
         288.07168579, 287.9367981, 287.82736206, 287.78564453,
         287.8374939, 287.8374939, 288.07168579, 288.07168579,
         287.9367981, 287.82736206, 287.78564453, 287.8374939,
         287.8374939, 288.07168579, 288.07168579, 287.9367981,
         287.82736206, 287.78564453, 287.8374939, 287.8374939,
         288.07168579, 288.07168579, 287.9367981, 287.82736206,
         287.78564453, 287.8374939, 287.8374939, 288.07168579,
         288.07168579, 287.9367981, 287.82736206, 287.78564453,
         287.8374939, 287.8374939, 288.07168579, 288.07168579,
         287.9367981, 287.82736206, 287.78564453, 287.8374939,
         287.8374939]
     self.assertArrayAllClose(result.data, expected)
Beispiel #3
0
    def test_trajectory_extraction_zigzag(self):
        # Extract a zig-zag trajectory
        waypoints = [
            {
                'grid_latitude': -0.1188,
                'grid_longitude': 359.5886
            },
            {
                'grid_latitude': -0.0828,
                'grid_longitude': 359.6606
            },
            {
                'grid_latitude': -0.0468,
                'grid_longitude': 359.6246
            },
        ]
        trajectory = Trajectory(waypoints, sample_count=20)
        sample_points = self._traj_to_sample_points(trajectory)
        trajectory_cube = traj_interpolate(self.cube[0, 0], sample_points)
        expected = np.array([
            287.95953369, 287.9190979, 287.95550537, 287.93240356,
            287.83850098, 287.87869263, 287.90942383, 287.9463501,
            287.74365234, 287.68856812, 287.75588989, 287.54611206,
            287.48522949, 287.53356934, 287.60217285, 287.43795776,
            287.59701538, 287.52468872, 287.45025635, 287.52716064
        ],
                            dtype=np.float32)

        self.assertCML(trajectory_cube, ('trajectory', 'zigzag.cml'),
                       checksum=False)
        self.assertArrayAllClose(trajectory_cube.data, expected, rtol=2.0e-7)
Beispiel #4
0
    def test_tri_polar__nearest(self):
        # Check a smallish nearest-neighbour interpolation against a result
        # snapshot.
        test_cube = self.cube
        # Use just one 2d layer, just to be faster.
        test_cube = test_cube[0][0]
        # Fix the fill value of the data to zero, just so that we get the same
        # result under numpy < 1.11 as with 1.11.
        # NOTE: numpy<1.11 *used* to assign missing data points into an
        # unmasked array as =0.0, now =fill-value.
        # TODO: arguably, we should support masked data properly in the
        # interpolation routine.  In the legacy code, that is unfortunately
        # just not the case.
        test_cube.data.fill_value = 0

        # Test points on a regular global grid, with unrelated steps + offsets
        # and an extended range of longitude values.
        x_points = np.arange(-185.23, +360.0, 73.123)
        y_points = np.arange(-89.12, +90.0, 42.847)
        x_points, y_points = np.meshgrid(x_points, y_points)
        sample_points = [('longitude', x_points.flatten()),
                         ('latitude', y_points.flatten())]
        result = traj_interpolate(test_cube, sample_points, method='nearest')
        expected = [
            0., 0., 0., 0., 0., 0., 0., 0., 12.13186264, 10.69991493,
            9.86881161, 7.08723927, 9.04308414, 12.56258678, 10.63761806,
            9.19426727, 28.93525505, 23.85289955, 26.94649506, 0., 27.88831711,
            28.65439224, 23.39414215, 26.78363228, 13.53453922, 0.,
            17.41485596, 0., 0., 13.0413475, 0., 17.10849571, -1.67040622,
            -1.64783156, 0., -1.97898054, -1.67642927, -1.65173221, -1.623945,
            0.
        ]

        self.assertArrayAllClose(result.data, expected)
 def test_trajectory_extraction(self):
     # Pull out a single point - no interpolation required
     single_point = traj_interpolate(self.cube,
                                     [('grid_latitude', [-0.1188]),
                                      ('grid_longitude', [359.57958984])])
     expected = self.cube[..., 10, 0].data
     self.assertArrayAllClose(single_point[..., 0].data,
                              expected, rtol=2.0e-7)
     self.assertCML(single_point, ('trajectory', 'single_point.cml'),
                    checksum=False)
 def test_trajectory_extraction_calc(self):
     # Pull out another point and test against a manually calculated result.
     single_point = [['grid_latitude', [-0.1188]],
                     ['grid_longitude', [359.584090412]]]
     scube = self.cube[0, 0, 10:11, 4:6]
     x0 = scube.coord('grid_longitude')[0].points
     x1 = scube.coord('grid_longitude')[1].points
     y0 = scube.data[0, 0]
     y1 = scube.data[0, 1]
     expected = y0 + ((y1 - y0) * ((359.584090412 - x0)/(x1 - x0)))
     trajectory_cube = traj_interpolate(scube, single_point)
     self.assertArrayAllClose(trajectory_cube.data, expected, rtol=2.0e-7)
    def test_hybrid_height(self):
        cube = istk.simple_4d_with_hybrid_height()
        # Put a biggus array on the cube so we can test deferred loading.
        cube.lazy_data(biggus.NumpyArrayAdapter(cube.data))

        traj = (('grid_latitude', [20.5, 21.5, 22.5, 23.5]),
                ('grid_longitude', [31, 32, 33, 34]))
        xsec = traj_interpolate(cube, traj, method='nearest')

        # Check that creating the trajectory hasn't led to the original
        # data being loaded.
        self.assertTrue(cube.has_lazy_data())
        self.assertCML([cube, xsec], ('trajectory', 'hybrid_height.cml'))
 def test_trajectory_extraction_axis_aligned(self):
     # Extract a simple, axis-aligned trajectory that is similar to an
     # indexing operation.
     # (It's not exactly the same because the source cube doesn't have
     # regular spacing.)
     waypoints = [
         {'grid_latitude': -0.1188, 'grid_longitude': 359.57958984},
         {'grid_latitude': -0.1188, 'grid_longitude': 359.66870117}
     ]
     trajectory = Trajectory(waypoints, sample_count=100)
     sample_points = self._traj_to_sample_points(trajectory)
     trajectory_cube = traj_interpolate(self.cube, sample_points)
     self.assertCML(trajectory_cube, ('trajectory',
                                      'constant_latitude.cml'))
Beispiel #9
0
    def test_hybrid_height(self):
        cube = istk.simple_4d_with_hybrid_height()
        # Put a lazy array into the cube so we can test deferred loading.
        cube.data = as_lazy_data(cube.data)

        traj = (
            ("grid_latitude", [20.5, 21.5, 22.5, 23.5]),
            ("grid_longitude", [31, 32, 33, 34]),
        )
        xsec = traj_interpolate(cube, traj, method="nearest")

        # Check that creating the trajectory hasn't led to the original
        # data being loaded.
        self.assertTrue(cube.has_lazy_data())
        self.assertCML([cube, xsec], ("trajectory", "hybrid_height.cml"))
Beispiel #10
0
    def test_hybrid_height(self):
        cube = istk.simple_4d_with_hybrid_height()
        # Put a lazy array into the cube so we can test deferred loading.
        cube.data = as_lazy_data(cube.data)

        # Use opionated grid-latitudes to avoid the issue of platform
        # specific behaviour within SciPy cKDTree choosing a different
        # equi-distant nearest neighbour point when there are multiple
        # valid candidates.
        traj = (
            ("grid_latitude", [20.4, 21.6, 22.6, 23.6]),
            ("grid_longitude", [31, 32, 33, 34]),
        )
        xsec = traj_interpolate(cube, traj, method="nearest")

        # Check that creating the trajectory hasn't led to the original
        # data being loaded.
        self.assertTrue(cube.has_lazy_data())
        self.assertCML([cube, xsec], ("trajectory", "hybrid_height.cml"))
Beispiel #11
0
    def test_trajectory_extraction_zigzag(self):
        # Extract a zig-zag trajectory
        waypoints = [
            {'grid_latitude': -0.1188, 'grid_longitude': 359.5886},
            {'grid_latitude': -0.0828, 'grid_longitude': 359.6606},
            {'grid_latitude': -0.0468, 'grid_longitude': 359.6246},
        ]
        trajectory = Trajectory(waypoints, sample_count=20)
        sample_points = self._traj_to_sample_points(trajectory)
        trajectory_cube = traj_interpolate(
            self.cube[0, 0], sample_points)
        expected = np.array([287.95953369, 287.9190979, 287.95550537,
                             287.93240356, 287.83850098, 287.87869263,
                             287.90942383, 287.9463501, 287.74365234,
                             287.68856812, 287.75588989, 287.54611206,
                             287.48522949, 287.53356934, 287.60217285,
                             287.43795776, 287.59701538, 287.52468872,
                             287.45025635, 287.52716064], dtype=np.float32)

        self.assertCML(trajectory_cube, ('trajectory', 'zigzag.cml'),
                       checksum=False)
        self.assertArrayAllClose(trajectory_cube.data, expected, rtol=2.0e-7)
Beispiel #12
0
    def test_tri_polar__nearest(self):
        # Check a smallish nearest-neighbour interpolation against a result
        # snapshot.
        test_cube = self.cube
        # Use just one 2d layer, just to be faster.
        test_cube = test_cube[0][0]
        # Fix the fill value of the data to zero, just so that we get the same
        # result under numpy < 1.11 as with 1.11.
        # NOTE: numpy<1.11 *used* to assign missing data points into an
        # unmasked array as =0.0, now =fill-value.
        # TODO: arguably, we should support masked data properly in the
        # interpolation routine.  In the legacy code, that is unfortunately
        # just not the case.
        test_cube.data.set_fill_value(0.0)

        # Test points on a regular global grid, with unrelated steps + offsets
        # and an extended range of longitude values.
        x_points = np.arange(-185.23, +360.0, 73.123)
        y_points = np.arange(-89.12, +90.0, 42.847)
        x_points, y_points = np.meshgrid(x_points, y_points)
        sample_points = [('longitude', x_points.flatten()),
                         ('latitude', y_points.flatten())]
        result = traj_interpolate(test_cube, sample_points,
                                  method='nearest')
        expected = [
            0., 0., 0., 0.,
            0., 0., 0., 0.,
            12.13186264, 10.69991493, 9.86881161, 7.08723927,
            9.04308414, 12.56258678, 10.63761806, 9.19426727,
            28.93525505, 23.85289955, 26.94649506, 0.,
            27.88831711, 28.65439224, 23.39414215, 26.78363228,
            13.53453922, 0., 17.41485596, 0.,
            0., 13.0413475, 0., 17.10849571,
            -1.67040622, -1.64783156, 0., -1.97898054,
            -1.67642927, -1.65173221, -1.623945, 0.]

        self.assertArrayAllClose(result.data, expected)
 def test_tri_polar(self):
     # extract
     sampled_cube = traj_interpolate(self.cube, self.sample_points)
     self.assertCML(sampled_cube, ('trajectory',
                                   'tri_polar_latitude_slice.cml'))