def test_hybrid_alt_Coord_order_doesnt_matter(self): from cis.test.util.mock import make_mock_cube from cis.data_io.ungridded_data import UngriddedData from cis.data_io.hyperpoint import HyperPoint import datetime as dt cube = make_mock_cube(time_dim_length=3, hybrid_ht_len=10) cube.transpose() sample_points = UngriddedData.from_points_array( # This point actually lies outside the lower bounds for altitude at this point in space [ HyperPoint(lat=1.0, lon=1.0, alt=5000.0, t=dt.datetime(1984, 8, 28, 8, 34)), # This point lies in the middle of the altitude bounds at this point HyperPoint(lat=4.0, lon=4.0, alt=6000.0, t=dt.datetime(1984, 8, 28, 8, 34)), # This point lies outside the upper bounds for altitude at this point HyperPoint(lat=-4.0, lon=-4.0, alt=6500.0, t=dt.datetime(1984, 8, 27, 2, 18, 52)) ]) interpolator = GriddedUngriddedInterpolator(cube, sample_points, 'nn') values = interpolator(cube, fill_value=None) wanted = np.asarray([221.0, 345.0, 100.0]) assert_array_almost_equal(values, wanted)
def test_collocation_of_alt_points_on_hybrid_altitude_and_pressure_coordinates( self): cube = make_from_cube( mock.make_mock_cube(time_dim_length=3, hybrid_pr_len=10, geopotential_height=True)) sample_points = UngriddedData.from_points_array( # Test point with both pressure and altitude should interpolate over the altitude only (since that is also # present in the data cube) [ HyperPoint(lat=0.0, lon=0.0, alt=234.5, t=dt.datetime(1984, 8, 28, 0, 0, 0)), HyperPoint(lat=5.0, lon=5.0, alt=355.5, t=dt.datetime(1984, 8, 28, 0, 0)) ]) col = GriddedUngriddedCollocator(fill_value=np.NAN) new_data = col.collocate(sample_points, cube, None, 'lin')[0] assert_almost_equal(new_data.data[0], 225.5, decimal=7) assert_almost_equal(new_data.data[1], 346.5, decimal=7)
def test_hybrid_Coord(self): from cis.test.util.mock import make_mock_cube from cis.data_io.ungridded_data import UngriddedData from cis.data_io.hyperpoint import HyperPoint import datetime as dt cube = make_mock_cube(time_dim_length=3, hybrid_pr_len=10) sample_points = UngriddedData.from_points_array([ HyperPoint(lat=0.0, lon=0.0, pres=111100040.5, alt=5000, t=dt.datetime(1984, 8, 28, 0, 0, 0)), HyperPoint(lat=0.0, lon=0.0, pres=113625040.5, alt=4000, t=dt.datetime(1984, 8, 28, 12, 0, 0)), HyperPoint(lat=5.0, lon=2.5, pres=177125044.5, alt=3000, t=dt.datetime(1984, 8, 28, 0, 0, 0)), HyperPoint(lat=-4.0, lon=-4.0, pres=166600039.0, alt=3500, t=dt.datetime(1984, 8, 27)) ]) interpolator = GriddedUngriddedInterpolator(cube, sample_points, 'lin') values = interpolator(cube) wanted = np.ma.masked_invalid( np.ma.array([221.5, 226.5, 330.5, np.nan])) assert_array_almost_equal(values, wanted)
def test_coordinates_exactly_between_points_in_col_ungridded_to_ungridded_in_2d( self): """ This works out the edge case where the points are exactly in the middle or two or more datapoints. The nn_horizontal algorithm will start with the first point as the nearest and iterates through the points finding any points which are closer than the current closest. If two distances were exactly the same you would expect the first point to be chosen. This doesn't seem to always be the case but is probably down to floating points errors in the haversine calculation as these test points are pretty close together. This test is only really for documenting the behaviour for equidistant points. """ from cis.collocation.col_implementations import GeneralUngriddedCollocator, nn_horizontal, SepConstraintKdtree ug_data = mock.make_regular_2d_ungridded_data() sample_points = UngriddedData.from_points_array([ HyperPoint(2.5, 2.5), HyperPoint(-2.5, 2.5), HyperPoint(2.5, -2.5), HyperPoint(-2.5, -2.5) ]) col = GeneralUngriddedCollocator() new_data = col.collocate(sample_points, ug_data, SepConstraintKdtree(), nn_horizontal())[0] eq_(new_data.data[0], 11.0) eq_(new_data.data[1], 5.0) eq_(new_data.data[2], 10.0) eq_(new_data.data[3], 4.0)
def test_collocation_of_alt_points_on_hybrid_pressure_and_altitude_coordinates( self): """ Kernel should use the auxilliary altitude dimension when altitude is present in the coordinates """ cube = make_from_cube( mock.make_mock_cube(time_dim_length=3, hybrid_pr_len=10, geopotential_height=True)) sample_points = UngriddedData.from_points_array( # This point actually lies outside the lower bounds for altitude at this point in space [ HyperPoint(lat=1.0, lon=1.0, alt=10, t=dt.datetime(1984, 8, 28, 8, 34)), # This point lies in the middle of the altitude bounds at this point HyperPoint(lat=4.0, lon=4.0, alt=354, t=dt.datetime(1984, 8, 28, 8, 34)), # This point lies outside the upper bounds for altitude at this point HyperPoint(lat=-4.0, lon=-4.0, alt=1000, t=dt.datetime(1984, 8, 27, 2, 18, 52)) ]) col = GriddedUngriddedCollocator(extrapolate=True) new_data = col.collocate(sample_points, cube, None, 'nn')[0] eq_(new_data.data[0], float(cube[2, 1, 1, 0].data)) eq_(new_data.data[1], float(cube[3, 2, 1, 4].data)) eq_(new_data.data[2], float(cube[1, 0, 0, 9].data))
def test_collocation_of_pres_points_on_hybrid_pressure_coordinates_and_altitude_coordinates( self): """ When only pressure coordinate is present this should be used for the collocation """ cube = make_from_cube( mock.make_mock_cube(time_dim_length=3, hybrid_pr_len=10)) sample_points = UngriddedData.from_points_array( # This point actually lies outside the lower bounds for altitude at this point in space [ HyperPoint(lat=1.0, lon=1.0, pres=1100000.0, t=dt.datetime(1984, 8, 28, 8, 34)), # This point lies in the middle of the altitude bounds at this point HyperPoint(lat=4.0, lon=4.0, pres=184600000.0, t=dt.datetime(1984, 8, 28, 8, 34)), # This point lies outside the upper bounds for altitude at this point HyperPoint(lat=-4.0, lon=-4.0, pres=63100049.0, t=dt.datetime(1984, 8, 27, 2, 18, 52)) ]) col = GriddedUngriddedCollocator(extrapolate=True) new_data = col.collocate(sample_points, cube, None, 'nn')[0] eq_(new_data.data[0], float(cube[2, 1, 1, 0].data)) eq_(new_data.data[1], float(cube[3, 2, 1, 4].data)) eq_(new_data.data[2], float(cube[1, 0, 0, 9].data))
def test_gridded_ungridded_lin(self): data = make_from_cube(mock.make_mock_cube()) data.name = lambda: 'Name' data.var_name = 'var_name' data._standard_name = 'y_wind' sample = UngriddedData.from_points_array([ HyperPoint(lat=1.0, lon=1.0, alt=12.0, t=dt.datetime(1984, 8, 29, 8, 34)), HyperPoint(lat=3.0, lon=3.0, alt=7.0, t=dt.datetime(1984, 8, 29, 8, 34)), HyperPoint(lat=-1.0, lon=-1.0, alt=5.0, t=dt.datetime(1984, 8, 29, 8, 34)) ]) constraint = None col = GriddedUngriddedCollocator() output = col.collocate(sample, data, constraint, 'lin') expected_result = np.array([8.8, 10.4, 7.2]) assert len(output) == 1 assert isinstance(output, UngriddedDataList) assert np.allclose(output[0].data, expected_result)
def test_coordinates_outside_grid_in_col_ungridded_to_ungridded_in_2d( self): from cis.collocation.col_implementations import GeneralUngriddedCollocator, nn_pressure, SepConstraintKdtree import datetime as dt ug_data = mock.make_regular_4d_ungridded_data() sample_points = HyperPointList() sample_points.append( HyperPoint(lat=0.0, lon=0.0, pres=0.1, t=dt.datetime(1984, 8, 29, 8, 34))) sample_points.append( HyperPoint(lat=0.0, lon=0.0, pres=91.0, t=dt.datetime(1984, 9, 2, 1, 23))) sample_points.append( HyperPoint(lat=0.0, lon=0.0, pres=890.0, t=dt.datetime(1984, 9, 4, 15, 54))) sample_points = UngriddedData.from_points_array(sample_points) col = GeneralUngriddedCollocator() new_data = col.collocate(sample_points, ug_data, SepConstraintKdtree(), nn_pressure())[0] eq_(new_data.data[0], 1.0) eq_(new_data.data[1], 46.0) eq_(new_data.data[2], 46.0)
def test_basic_col_in_4d(self): from cis.collocation.col_implementations import GeneralUngriddedCollocator, nn_altitude, SepConstraintKdtree import datetime as dt ug_data = mock.make_regular_4d_ungridded_data() sample_points = HyperPointList() sample_points.append( HyperPoint(lat=1.0, lon=1.0, alt=12.0, t=dt.datetime(1984, 8, 29, 8, 34))) sample_points.append( HyperPoint(lat=4.0, lon=4.0, alt=34.0, t=dt.datetime(1984, 9, 2, 1, 23))) sample_points.append( HyperPoint(lat=-4.0, lon=-4.0, alt=89.0, t=dt.datetime(1984, 9, 4, 15, 54))) sample_points = UngriddedData.from_points_array(sample_points) col = GeneralUngriddedCollocator() new_data = col.collocate(sample_points, ug_data, SepConstraintKdtree(), nn_altitude())[0] eq_(new_data.data[0], 6.0) eq_(new_data.data[1], 16.0) eq_(new_data.data[2], 46.0)
def test_wrapping_of_pres_points_on_hybrid_pressure_coordinates_on_0_360_grid( self): cube = make_from_cube( mock.make_mock_cube(time_dim_length=3, hybrid_pr_len=10, lon_dim_length=36, lon_range=(0., 350.))) # Ensure the longitude coord is circular cube.coord(standard_name='longitude').circular = True sample_points = UngriddedData.from_points_array([ HyperPoint(lat=0.0, lon=355.0, pres=1482280045.0, t=dt.datetime(1984, 8, 28, 0, 0, 0)), HyperPoint(lat=5.0, lon=2.5, pres=1879350048.0, t=dt.datetime(1984, 8, 28, 0, 0, 0)) ]) col = GriddedUngriddedCollocator(extrapolate=False) new_data = col.collocate(sample_points, cube, None, 'lin')[0] eq_(new_data.data[0], 2701.0011131725005) eq_(new_data.data[1], 3266.1930161260775)
def test_is_not_same_point_in_time_with_pressure_and_altitude_with_points_with_different_values( ): assert (not HyperPoint( lat=10.0, lon=50.0, alt=10.0, pres=5.0, t=500.0, val=14.4).same_point_in_time( HyperPoint( lat=10.0, lon=50.0, alt=10.0, pres=5.0, t=501.0, val=15.1)))
def test_missing_data_for_missing_sample_with_no_extrapolation(self): cube = make_from_cube( mock.make_mock_cube(time_dim_length=3, hybrid_ht_len=10)) sample_points = UngriddedData.from_points_array([ HyperPoint(lat=0.0, lon=0.0, alt=5550.0, t=dt.datetime(1984, 8, 28)), HyperPoint(lat=4.0, lon=4.0, alt=6000.0, t=dt.datetime(1984, 8, 28)), HyperPoint(lat=-4.0, lon=-4.0, alt=6500.0, t=dt.datetime(1984, 8, 27)) ]) sample_mask = [False, True, False] sample_points.data = np.ma.array([0, 0, 0], mask=sample_mask) col = GriddedUngriddedCollocator(fill_value=np.NAN, missing_data_for_missing_sample=True) new_data = col.collocate(sample_points, cube, None, 'lin')[0] assert_almost_equal(new_data.data[0], 222.4814815, decimal=7) # This point should be masked because of the sampling assert np.ma.is_masked(new_data.data[1]) # And this one because of the extrapolation assert np.ma.is_masked(new_data.data[2])
def test_negative_lon_points_on_hybrid_altitude_coordinates_with_0_360_grid( self): cube = make_from_cube( mock.make_mock_cube(time_dim_length=3, hybrid_ht_len=10, lon_dim_length=36, lon_range=(0., 350.))) sample_points = UngriddedData.from_points_array([ HyperPoint(lat=1.0, lon=111.0, alt=5000.0, t=dt.datetime(1984, 8, 28, 8, 34)), HyperPoint(lat=4.0, lon=141.0, alt=12000.0, t=dt.datetime(1984, 8, 28, 8, 34)), HyperPoint(lat=-4.0, lon=-14.0, alt=10000.0, t=dt.datetime(1984, 8, 27, 2, 18, 52)) ]) col = GriddedUngriddedCollocator(extrapolate=True) new_data = col.collocate(sample_points, cube, None, 'nn')[0] eq_(new_data.data[0], 2501.0) # float(cube[2,11,1,0].data)) eq_(new_data.data[1], 3675.0) # float(cube[3,14,1,4].data)) eq_(new_data.data[2], 2139.0) # float(cube[1,35,0,8].data))
def test_collocation_of_pres_points_on_hybrid_pressure_coordinates(self): cube = make_from_cube( mock.make_mock_cube(time_dim_length=3, hybrid_pr_len=10)) sample_points = UngriddedData.from_points_array([ HyperPoint(lat=0.0, lon=0.0, pres=111100040.5, t=dt.datetime(1984, 8, 28, 0, 0, 0)), HyperPoint(lat=0.0, lon=0.0, pres=113625040.5, t=dt.datetime(1984, 8, 28, 12, 0, 0)), HyperPoint(lat=5.0, lon=2.5, pres=177125044.5, t=dt.datetime(1984, 8, 28, 0, 0, 0)), HyperPoint(lat=-4.0, lon=-4.0, pres=166600039.0, t=dt.datetime(1984, 8, 27)) ]) col = GriddedUngriddedCollocator() new_data = col.collocate(sample_points, cube, None, 'lin')[0] # Exactly on the lat, lon, time points, interpolated over pressure assert_almost_equal(new_data.data[0], 221.5, decimal=5) # Exactly on the lat, lon, points, interpolated over time and pressure assert_almost_equal(new_data.data[1], 226.5, decimal=7) # Exactly on the lat, time points, interpolated over longitude and pressure assert_almost_equal(new_data.data[2], 330.5, decimal=7) # Outside of the pressure bounds - extrapolation off assert np.ma.is_masked(new_data.data[3])
def test_collocation_of_alt_pres_points_on_hybrid_altitude_coordinates( self): cube = make_from_cube( mock.make_mock_cube(time_dim_length=3, hybrid_ht_len=10)) sample_points = UngriddedData.from_points_array([ HyperPoint(lat=0.0, lon=0.0, alt=5550.0, pres=10000.0, t=dt.datetime(1984, 8, 28)), HyperPoint(lat=4.0, lon=4.0, alt=6000.0, pres=1000.0, t=dt.datetime(1984, 8, 28)), HyperPoint(lat=-4.0, lon=-4.0, alt=6500.0, pres=100.0, t=dt.datetime(1984, 8, 27)) ]) col = GriddedUngriddedCollocator(fill_value=np.NAN) new_data = col.collocate(sample_points, cube, None, 'lin')[0] assert_almost_equal(new_data.data[0], 222.4814815, decimal=7) assert_almost_equal(new_data.data[1], 321.0467626, decimal=7) # Test that points outside the cell are returned as masked, rather than extrapolated by default assert np.ma.is_masked(new_data.data[2])
def test_missing_data_for_missing_sample(self): data = make_from_cube(mock.make_mock_cube()) data.name = lambda: 'Name' data.var_name = 'var_name' data._standard_name = 'y_wind' sample = UngriddedData.from_points_array([ HyperPoint(lat=1.0, lon=1.0, alt=12.0, t=dt.datetime(1984, 8, 29, 8, 34)), HyperPoint(lat=3.0, lon=3.0, alt=7.0, t=dt.datetime(1984, 8, 29, 8, 34)), HyperPoint(lat=-1.0, lon=-1.0, alt=5.0, t=dt.datetime(1984, 8, 29, 8, 34)) ]) constraint = None sample_mask = [False, True, False] sample.data = np.ma.array([0, 0, 0], mask=sample_mask) col = GriddedUngriddedCollocator(missing_data_for_missing_sample=True) output = col.collocate(sample, data, constraint, 'nn') assert len(output) == 1 assert isinstance(output, UngriddedDataList) assert np.array_equal(output[0].data.mask, sample_mask)
def test_wrapping_of_alt_points_on_hybrid_height_coordinates_on_0_360_grid( self): cube = make_from_cube( mock.make_mock_cube(time_dim_length=3, hybrid_ht_len=10, lon_dim_length=36, lon_range=(0., 350.))) # Shift the cube around so that the dim which isn't hybrid (time) is at the front. This breaks the fix we used # for air pressure... cube.transpose([2, 0, 1, 3]) # Ensure the longitude coord is circular cube.coord(standard_name='longitude').circular = True sample_points = UngriddedData.from_points_array([ HyperPoint(lat=4.0, lon=355.0, alt=11438.0, t=dt.datetime(1984, 8, 28)), HyperPoint(lat=0.0, lon=2.0, alt=10082.0, t=dt.datetime(1984, 8, 28)) ]) col = GriddedUngriddedCollocator(extrapolate=False) new_data = col.collocate(sample_points, cube, None, 'lin')[0] eq_(new_data.data[0], 3563.0) eq_(new_data.data[1], 2185.0)
def test_same_point_in_time_with_points_with_different_values(): assert (HyperPoint(lat=10.0, lon=50.0, alt=5.0, t=500.0, val=14.4).same_point_in_time( HyperPoint(lat=10.0, lon=50.0, alt=5.0, t=500.0, val=15.1)))
def test_same_point_in_space_with_pressure_and_altitude_with_points_with_different_times( ): assert (HyperPoint(lat=10.0, lon=50.0, alt=5.0, pres=10.0, t=500.0).same_point_in_space( HyperPoint(lat=10.0, lon=50.0, alt=5.0, pres=10.0, t=501.0)))
def test_collocation_of_pres_alt_points_on_hybrid_pressure_coordinates_multi_var( self): cube_list = [ make_from_cube( mock.make_mock_cube(time_dim_length=3, hybrid_pr_len=10)) ] cube_list.append( make_from_cube( mock.make_mock_cube(time_dim_length=3, hybrid_pr_len=10, data_offset=100))) sample_points = UngriddedData.from_points_array([ HyperPoint(lat=0.0, lon=0.0, pres=111100040.5, alt=5000, t=dt.datetime(1984, 8, 28, 0, 0, 0)), HyperPoint(lat=0.0, lon=0.0, pres=113625040.5, alt=4000, t=dt.datetime(1984, 8, 28, 12, 0, 0)), HyperPoint(lat=5.0, lon=2.5, pres=177125044.5, alt=3000, t=dt.datetime(1984, 8, 28, 0, 0, 0)), HyperPoint(lat=-4.0, lon=-4.0, pres=166600039.0, alt=3500, t=dt.datetime(1984, 8, 27)) ]) col = GriddedUngriddedCollocator() outlist = col.collocate(sample_points, cube_list, None, 'lin') # First data set: new_data = outlist[0] # Exactly on the lat, lon, time points, interpolated over pressure assert_almost_equal(new_data.data[0], 221.5, decimal=5) # Exactly on the lat, lon, points, interpolated over time and pressure assert_almost_equal(new_data.data[1], 226.5, decimal=7) # Exactly on the lat, time points, interpolated over longitude and pressure assert_almost_equal(new_data.data[2], 330.5, decimal=7) # Outside of the pressure bounds - extrapolation off assert np.ma.is_masked(new_data.data[3]) # Second dataset: new_data = outlist[1] # Exactly on the lat, lon, time points, interpolated over pressure assert_almost_equal(new_data.data[0], 321.5, decimal=5) # Exactly on the lat, lon, points, interpolated over time and pressure assert_almost_equal(new_data.data[1], 326.5, decimal=7) # Exactly on the lat, time points, interpolated over longitude and pressure assert_almost_equal(new_data.data[2], 430.5, decimal=7) # Outside of the pressure bounds - extrapolation off assert np.ma.is_masked(new_data.data[3])
def test_same_point_in_space_with_pressure_and_altitude_with_points_with_different_values( ): assert (HyperPoint(lat=10.0, lon=50.0, alt=5.0, pres=10.0, val=14.4).same_point_in_space( HyperPoint(lat=10.0, lon=50.0, alt=5.0, pres=10.0, val=15.1)))
def test_same_point_in_time_with_pressure_and_altitude_with_points_with_different_spatial_coords( ): assert (HyperPoint(lat=10.0, lon=50.0, alt=5.0, pres=4.0, t=500.0).same_point_in_time( HyperPoint(lat=10.0, lon=50.0, alt=10.0, pres=9.0, t=500.0)))
def test_basic_col_gridded_to_ungridded_using_li_in_2d(self): cube = make_from_cube(mock.make_square_5x3_2d_cube()) sample_points = UngriddedData.from_points_array([ HyperPoint(1.0, 1.0), HyperPoint(4.0, 4.0), HyperPoint(-4.0, -4.0) ]) col = GriddedUngriddedCollocator() new_data = col.collocate(sample_points, cube, None, 'lin')[0] assert_almost_equal(new_data.data[0], 8.8) assert_almost_equal(new_data.data[1], 11.2) assert_almost_equal(new_data.data[2], 4.8)
def test_negative_lon_points_in_2d_dont_matter(self): """ This is exactly the same test as above, except we ommit the point with negative longitude, this makes the collocator wrap the longitude coordinate and gives a slightly different interpolation result... """ cube = make_from_cube(mock.make_square_5x3_2d_cube()) sample_points = UngriddedData.from_points_array( [HyperPoint(1.0, 1.0), HyperPoint(4.0, 4.0)]) col = GriddedUngriddedCollocator() new_data = col.collocate(sample_points, cube, None, 'lin')[0] assert_almost_equal(new_data.data[0], 8.8) assert_almost_equal(new_data.data[1], 11.2)
def test_basic_col_gridded_to_ungridded_in_2d(self): cube = make_from_cube(mock.make_square_5x3_2d_cube()) sample_points = UngriddedData.from_points_array([ HyperPoint(lat=1.0, lon=1.0), HyperPoint(lat=4.0, lon=4.0), HyperPoint(lat=-4.0, lon=-4.0) ]) col = GriddedUngriddedCollocator() new_data = col.collocate(sample_points, cube, None, 'nn')[0] eq_(new_data.data[0], 8.0) # float(cube[2,1].data)) eq_(new_data.data[1], 12.0) # float(cube[3,2].data)) eq_(new_data.data[2], 4.0) # float(cube[1,0].data))
def test_coordinates_outside_grid_in_col_gridded_to_ungridded_in_2d(self): cube = make_from_cube(mock.make_square_5x3_2d_cube()) sample_points = UngriddedData.from_points_array([ HyperPoint(5.5, 5.5), HyperPoint(-5.5, 5.5), HyperPoint(5.5, -5.5), HyperPoint(-5.5, -5.5) ]) col = GriddedUngriddedCollocator(extrapolate=True) new_data = col.collocate(sample_points, cube, None, 'nn')[0] eq_(new_data.data[0], 12.0) eq_(new_data.data[1], 6.0) eq_(new_data.data[2], 10.0) eq_(new_data.data[3], 4.0)
def test_basic_col_gridded_to_ungridded_in_2d_with_time(self): cube = make_from_cube(mock.make_square_5x3_2d_cube_with_time()) sample_points = [ HyperPoint(lat=1.0, lon=1.0, t=dt.datetime(1984, 8, 28, 8, 34)), HyperPoint(lat=4.0, lon=4.0, t=dt.datetime(1984, 8, 31, 1, 23)), HyperPoint(lat=-4.0, lon=-4.0, t=dt.datetime(1984, 9, 2, 15, 54)) ] sample_points = UngriddedData.from_points_array(sample_points) col = GriddedUngriddedCollocator(extrapolate=True) new_data = col.collocate(sample_points, cube, None, 'nn')[0] eq_(new_data.data[0], 51.0) eq_(new_data.data[1], 82.0) eq_(new_data.data[2], 28.0)
def test_basic_col_with_incompatible_points_throws_a_TypeError(self): from cis.collocation.col_implementations import GeneralUngriddedCollocator, nn_pressure, SepConstraintKdtree ug_data = mock.make_regular_4d_ungridded_data() # Make sample points with no time dimension specified sample_points = UngriddedData.from_points_array([ HyperPoint(1.0, 1.0), HyperPoint(4.0, 4.0), HyperPoint(-4.0, -4.0) ]) col = GeneralUngriddedCollocator() with self.assertRaises(AttributeError): new_data = col.collocate(sample_points, ug_data, SepConstraintKdtree(), nn_pressure())[0]
def test_basic_col_in_2d(self): # lat: -10 to 10 step 5; lon -5 to 5 step 5 ug_data = mock.make_regular_2d_ungridded_data() sample_points = UngriddedData.from_points_array([ HyperPoint(lat=1.0, lon=1.0), HyperPoint(lat=4.0, lon=4.0), HyperPoint(lat=-4.0, lon=-4.0) ]) col = GeneralUngriddedCollocator(fill_value=-999) new_data = col.collocate(sample_points, ug_data, SepConstraintKdtree(), nn_horizontal_only())[0] eq_(new_data.data[0], 8.0) eq_(new_data.data[1], 12.0) eq_(new_data.data[2], 4.0)
def test_basic_col_in_2d(self): from cis.collocation.col_implementations import GeneralUngriddedCollocator, nn_horizontal, SepConstraintKdtree ug_data = mock.make_regular_2d_ungridded_data() sample_points = UngriddedData.from_points_array([ HyperPoint(lat=1.0, lon=1.0), HyperPoint(lat=4.0, lon=4.0), HyperPoint(lat=-4.0, lon=-4.0) ]) col = GeneralUngriddedCollocator() new_data = col.collocate(sample_points, ug_data, SepConstraintKdtree(), nn_horizontal())[0] eq_(new_data.data[0], 8.0) eq_(new_data.data[1], 12.0) eq_(new_data.data[2], 4.0)