def list_moments(constraint, kernel):
col = GeneralGriddedCollocator()
sample = make_square_5x3_2d_cube()
data1 = make_regular_2d_ungridded_data(10, -10, 10, 6, -5, 5)
data2 = make_regular_2d_ungridded_data(10, -10, 10, 6, -5, 5)
data2.metadata._name = 'snow'
data2.data *= 2
output = col.collocate(sample, UngriddedDataList([data1, data2]), constraint, kernel)
assert len(output) == 6
assert output[0].var_name == 'rain'
assert output[1].var_name == 'rain_std_dev'
assert output[2].var_name == 'rain_num_points'
assert output[3].var_name == 'snow'
assert output[4].var_name == 'snow_std_dev'
assert output[5].var_name == 'snow_num_points'
expected_data1 = numpy.array([[4.5, 6.5, 8.5],
[16.5, 18.5, 20.5],
[28.5, 30.5, 32.5],
[40.5, 42.5, 44.5],
[52.5, 54.5, 56.5]])
expected_data2 = 2 * expected_data1
expected_stddev1 = numpy.ones((5, 3)) * 3.5118845842842465
expected_stddev2 = expected_stddev1 * 2
expected_num = numpy.ones((5, 3)) * 4
assert numpy.array_equal(output[0].data, expected_data1)
assert numpy.allclose(output[1].data, expected_stddev1)
assert numpy.array_equal(output[2].data, expected_num)
assert numpy.array_equal(output[3].data, expected_data2)
assert numpy.allclose(output[4].data, expected_stddev2)
assert numpy.array_equal(output[5].data, expected_num)
def test_list_ungridded_ungridded_box_mean(self):
ug_data_1 = mock.make_regular_2d_ungridded_data()
ug_data_2 = mock.make_regular_2d_ungridded_data(data_offset=3)
ug_data_2.long_name = 'TOTAL SNOWFALL RATE: LS+CONV KG/M2/S'
ug_data_2.standard_name = 'snowfall_flux'
ug_data_2.metadata._name = 'snow'
data_list = UngriddedDataList([ug_data_1, ug_data_2])
sample_points = mock.make_regular_2d_ungridded_data()
constraint = SepConstraintKdtree('500km')
kernel = moments()
col = GeneralUngriddedCollocator()
output = col.collocate(sample_points, data_list, constraint, kernel)
expected_result = np.array(list(range(1, 16)))
expected_n = np.array(15 * [1])
assert len(output) == 6
assert isinstance(output, UngriddedDataList)
assert output[3].var_name == 'snow'
assert output[4].var_name == 'snow_std_dev'
assert output[5].var_name == 'snow_num_points'
assert np.allclose(output[0].data, expected_result)
assert all(output[1].data.mask)
assert np.allclose(output[2].data, expected_n)
assert np.allclose(output[3].data, expected_result + 3)
assert all(output[4].data.mask)
assert np.allclose(output[5].data, expected_n)
def test_GIVEN_ungridded_datagroups_with_different_num_vars_WHEN_read_datagroups_THEN_data_returned_in_list(
self):
datagroup_1 = {
'variables': ['var1', 'var2'],
'filenames': ['filename1.nc'],
'product': None
}
datagroup_2 = {
'variables': ['var3'],
'filenames': ['filename2.nc'],
'product': 'cis'
}
var1 = make_regular_2d_ungridded_data()
var2 = make_regular_2d_ungridded_data()
var3 = make_regular_2d_ungridded_data()
get_data_func = MagicMock(side_effect=[var1, var2, var3])
get_var_func = MagicMock(side_effect=lambda f: {
'filename1.nc': ['var1', 'var2'],
'filename2.nc': ['var3']
}[f])
reader = DataReader(get_data_func=get_data_func,
get_variables_func=get_var_func)
data = reader.read_datagroups([datagroup_1, datagroup_2])
assert_that(len(data), is_(3))
assert_that(data[0], is_(var1))
assert_that(data[1], is_(var2))
assert_that(data[2], is_(var3))
def test_list_ungridded_ungridded_box_mean(self):
ug_data_1 = mock.make_regular_2d_ungridded_data()
ug_data_2 = mock.make_regular_2d_ungridded_data(data_offset=3)
ug_data_2.long_name = 'TOTAL SNOWFALL RATE: LS+CONV KG/M2/S'
ug_data_2.standard_name = 'snowfall_rate'
ug_data_2.metadata._name = 'snow'
data_list = UngriddedDataList([ug_data_1, ug_data_2])
sample_points = mock.make_regular_2d_ungridded_data()
constraint = SepConstraintKdtree('500km')
kernel = moments()
col = GeneralUngriddedCollocator()
output = col.collocate(sample_points, data_list, constraint, kernel)
expected_result = np.array(list(range(1, 16)))
expected_stddev = np.array(15 * [float('inf')])
expected_n = np.array(15 * [1])
assert len(output) == 6
assert isinstance(output, UngriddedDataList)
assert output[3].var_name == 'snow'
assert output[4].var_name == 'snow_std_dev'
assert output[5].var_name == 'snow_num_points'
assert np.allclose(output[0].data, expected_result)
assert np.allclose(output[1].data, expected_stddev)
assert np.allclose(output[2].data, expected_n)
assert np.allclose(output[3].data, expected_result + 3)
assert np.allclose(output[4].data, expected_stddev)
assert np.allclose(output[5].data, expected_n)
def test_GIVEN_multiple_variables_WHEN_subset_THEN_DataWriter_called_correctly(self):
variables = ['var_name1', 'var_name2']
filename = 'filename'
xmin, xmax = -10, 10
ymin, ymax = 40, 60
limits = {'x': SubsetLimits(xmin, xmax, False),
'y': SubsetLimits(ymin, ymax, False)}
output_file = 'output.hdf'
def _mock_subset(data, constraint):
# Modify the data slightly so we can be sure it's passed in correctly
for var in data:
var.data += 1
return data
mock_subsetter = Subsetter()
mock_subsetter.subset = _mock_subset
mock_data_reader = DataReader()
mock_data_reader.read_data_list = MagicMock(return_value=UngriddedDataList([make_regular_2d_ungridded_data(),
make_regular_2d_ungridded_data()]))
mock_data_writer = DataWriter()
mock_data_writer.write_data = MagicMock()
subset = Subset(limits, output_file, subsetter=mock_subsetter,
data_reader=mock_data_reader, data_writer=mock_data_writer)
subset.subset(variables, filename, product=None)
assert_that(mock_data_writer.write_data.call_count, is_(1))
written_data = mock_data_writer.write_data.call_args[0][0]
written_filename = mock_data_writer.write_data.call_args[0][1]
assert_that(written_data[0].data_flattened.tolist(), is_([2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]))
assert_that(written_data[0].data_flattened.tolist(), written_data[1].data_flattened.tolist())
assert_that(written_filename, is_(output_file))
def setUp(self):
"""
Create the dummy objects necessary for testing
"""
self.ug = make_regular_2d_ungridded_data()
self.ug_1 = make_regular_2d_ungridded_data()
self.gd = make_from_cube(make_mock_cube())
self.gd_large = make_from_cube(make_mock_cube(50, 30))
def setUp(self):
"""
Create the dummy objects necessary for testing
"""
self.ug = make_regular_2d_ungridded_data()
self.ug_1 = make_regular_2d_ungridded_data()
self.gd = make_from_cube(make_mock_cube())
self.gd_large = make_from_cube(make_mock_cube(50, 30))
def test_can_create_list_from_generators_and_other_iterators(self):
from cis.test.util.mock import make_regular_2d_ungridded_data
import itertools
another_list = UngriddedDataList((make_regular_2d_ungridded_data(), make_regular_2d_ungridded_data()))
assert_that(len(another_list) == 2)
dict = {1: [make_regular_2d_ungridded_data()], 2: [make_regular_2d_ungridded_data()]}
another_list = UngriddedDataList(itertools.chain.from_iterable(d for d in dict.values()))
assert_that(len(another_list) == 2)
def test_GIVEN_variables_not_compatible_shape_THEN_raises_EvaluationError(self):
data1 = mock.make_regular_2d_ungridded_data()
data2 = mock.make_regular_2d_ungridded_data(lat_dim_length=6)
data1.metadata._name = 'var1'
data2.metadata._name = 'var2'
self.data = [data1, data2]
expr = 'var1 + var2'
with self.assertRaises(EvaluationError):
res = self.calc.evaluate(self.data, expr)
def test_GIVEN_flattened_and_unflattened_datasets_WHEN_analyze_THEN_StatisticsResults_returned(self):
data1 = mock.make_regular_2d_ungridded_data()
data2 = mock.make_regular_2d_ungridded_data()
data2._data = data2.data_flattened
for coord in data2.coords():
coord._data = coord.data_flattened
stats = StatsAnalyzer(data1, data2)
results = stats.analyze()
assert_that(len(results), is_(14))
def test_GIVEN_flattened_and_unflattened_datasets_WHEN_analyze_THEN_StatisticsResults_returned(
self):
data1 = mock.make_regular_2d_ungridded_data()
data2 = mock.make_regular_2d_ungridded_data()
data2._data = data2.data_flattened
for coord in data2.coords():
coord._data = coord.data_flattened
stats = StatsAnalyzer(data1, data2)
results = stats.analyze()
assert_that(len(results), is_(14))
def test_single_data(self):
sample = mock.make_regular_2d_ungridded_data()
data = mock.make_regular_2d_ungridded_data(data_offset=10)
col = DummyCollocator()
con = None
kernel = None
output = col.collocate(sample, data, con, kernel)
assert len(output) == 1
assert numpy.array_equal(output[0].data, data.data)
def test_single_data(self):
sample = mock.make_regular_2d_ungridded_data()
data = mock.make_regular_2d_ungridded_data(data_offset=10)
col = DummyCollocator()
con = None
kernel = None
output = col.collocate(sample, data, con, kernel)
assert len(output) == 1
assert numpy.array_equal(output[0].data, data.data)
def test_GIVEN_two_variables_WHEN_calculate_THEN_variable_values_not_changed(self):
# This is to fix an issue where the calculator was taking a reference to the input list and therefore changing
# its value when output.
data1 = mock.make_regular_2d_ungridded_data()
data2 = mock.make_regular_2d_ungridded_data()
data1.metadata._name = 'var1'
data2.metadata._name = 'var2'
self.data = [data1, data2]
expr = 'var1 + var2'
res = self.calc.evaluate(self.data, expr)
assert_that(numpy.array_equal(data1.data, data2.data))
def test_GIVEN_ungridded_data_basic_addition_WHEN_calculate_THEN_addition_successful(self):
data1 = mock.make_regular_2d_ungridded_data()
data2 = mock.make_regular_2d_ungridded_data()
data1.metadata._name = 'var1'
data2.metadata._name = 'var2'
self.data = [data1, data2]
expr = 'var1 + var2'
res = self.calc.evaluate(self.data, expr)
expected = 2 * self.data[1].data.flatten()
assert_that(numpy.array_equal(res.data, expected))
def test_implicit_comparative_scatter(self):
from cis.test.util.mock import make_regular_2d_ungridded_data
from cis.data_io.ungridded_data import UngriddedDataList
d = UngriddedDataList([make_regular_2d_ungridded_data(), make_regular_2d_ungridded_data(data_offset=2)])
# This is needed to setup the coord shapes unfortunately...
_ = d[0].data
_ = d[1].data
d[0].metadata._name = 'snow'
d[1].plot(xaxis=d[0])
self.check_graphic()
def test_combining(self):
from cis.test.util.mock import make_regular_2d_ungridded_data
another_list = UngriddedDataList([make_regular_2d_ungridded_data(), make_regular_2d_ungridded_data()])
# Test adding
assert_that(isinstance(self.ungridded_data_list + another_list, UngriddedDataList))
# Test extending
another_list.extend(self.ungridded_data_list)
assert_that(isinstance(another_list, UngriddedDataList))
assert_that(len(another_list) == 4)
# Test can't add single items
with assert_raises(TypeError):
self.ungridded_data_list + another_list[0]
def test_list_of_data(self):
sample = mock.make_regular_2d_ungridded_data()
data = UngriddedDataList([mock.make_regular_2d_ungridded_data(data_offset=5),
mock.make_regular_2d_ungridded_data(data_offset=10)])
col = DummyCollocator()
con = None
kernel = None
output = col.collocate(sample, data, con, kernel)
assert len(output) == 2
assert numpy.array_equal(output[0].data, data[0].data)
assert numpy.array_equal(output[1].data, data[1].data)
def test_explicit_comparative_scatter(self):
from cis.test.util.mock import make_regular_2d_ungridded_data
from cis.data_io.ungridded_data import UngriddedDataList
d = UngriddedDataList([make_regular_2d_ungridded_data(), make_regular_2d_ungridded_data(data_offset=2)])
# This is needed to setup the coord shapes unfortunately...
# TODO: Fix this in the Coord somewhere
_ = d[0].data
_ = d[1].data
d[0].metadata._name = 'snow'
d.plot(how='comparativescatter')
self.check_graphic()
def test_GIVEN_ungridded_data_one_flattened_WHEN_calculate_THEN_compared_on_flattened_grid(self):
data1 = mock.make_regular_2d_ungridded_data()
data2 = mock.make_regular_2d_ungridded_data()
data2._data = data2.data_flattened
for coord in data2.coords():
coord._data = coord.data_flattened
data1.metadata._name = 'var1'
data2.metadata._name = 'var2'
self.data = [data1, data2]
expr = 'var1 + var2'
res = self.calc.evaluate(self.data, expr)
expected = 2 * self.data[1].data
assert_that(numpy.array_equal(res.data, expected))
assert_that(res.data.shape, is_((15,)))
def test_can_create_list_from_generators_and_other_iterators(self):
from cis.test.util.mock import make_regular_2d_ungridded_data
import itertools
another_list = UngriddedDataList((make_regular_2d_ungridded_data(),
make_regular_2d_ungridded_data()))
assert_that(len(another_list) == 2)
dict = {
1: [make_regular_2d_ungridded_data()],
2: [make_regular_2d_ungridded_data()]
}
another_list = UngriddedDataList(
itertools.chain.from_iterable(d for d in dict.values()))
assert_that(len(another_list) == 2)
def test_other_longitude_wrapping_multiple_ranges_forced_minus_180_to_180(self):
"""
Test that ungridded data which crosses the dateline gets plotted correctly
"""
from cis.plotting.formatted_plot import Plotter
from cis.test.util.mock import make_regular_2d_ungridded_data
datas = [make_regular_2d_ungridded_data(lat_dim_length=2, lon_dim_length=90, lon_min=-175., lon_max=145.),
make_regular_2d_ungridded_data(lon_dim_length=90, lon_min=5., lon_max=325., lat_min=30, lat_max=60)]
Plotter(datas, xaxis='longitude', yaxis='latitude', width=8, height=6, cbarscale=None,
ymin=-90, ymax=90, xmin=-180, xmax=180,
layer_opts=[{'label': '-180to180', 'itemwidth': 50}, {'label': '0to360', 'itemwidth': 50}])
self.check_graphic()
def can_collocate_list_of_data(constraint, kernel):
col = GeneralGriddedCollocator()
sample = make_square_5x3_2d_cube()
data1 = make_regular_2d_ungridded_data(10, -10, 10, 6, -5, 5, 0)
data2 = make_regular_2d_ungridded_data(10, -10, 10, 6, -5, 5, 10)
output = col.collocate(sample, UngriddedDataList([data1, data2]), constraint, kernel)
assert len(output) == 2
expected_data2 = numpy.array([[14.5, 16.5, 18.5],
[26.5, 28.5, 30.5],
[38.5, 40.5, 42.5],
[50.5, 52.5, 54.5],
[62.5, 64.5, 66.5]])
expected_data1 = expected_data2 - 10
assert_arrays_equal(output[0].data, expected_data1)
assert_arrays_equal(output[1].data, expected_data2)
def test_list_of_data(self):
sample = mock.make_regular_2d_ungridded_data()
data = UngriddedDataList([
mock.make_regular_2d_ungridded_data(data_offset=5),
mock.make_regular_2d_ungridded_data(data_offset=10)
])
col = DummyCollocator()
con = None
kernel = None
output = col.collocate(sample, data, con, kernel)
assert len(output) == 2
assert numpy.array_equal(output[0].data, data[0].data)
assert numpy.array_equal(output[1].data, data[1].data)
def test_GIVEN_multiple_datagroups_WHEN_read_datagroups_THEN_get_data_called_correctly(
self):
datagroup_1 = {
'variables': ['var1', 'var2'],
'filenames': ['filename1.nc'],
'product': None
}
datagroup_2 = {
'variables': ['var3', 'var4'],
'filenames': ['filename2.nc'],
'product': 'cis'
}
get_data_func = MagicMock(
return_value=make_regular_2d_ungridded_data())
get_var_func = MagicMock(side_effect=lambda f: {
'filename1.nc': ['var1', 'var2'],
'filename2.nc': ['var3', 'var4']
}[f])
reader = DataReader(get_data_func=get_data_func,
get_variables_func=get_var_func)
data = reader.read_datagroups([datagroup_1, datagroup_2])
assert_that(get_data_func.call_count, is_(4))
assert_that(get_data_func.call_args_list[0][0],
is_((['filename1.nc'], 'var1', None)))
assert_that(get_data_func.call_args_list[1][0],
is_((['filename1.nc'], 'var2', None)))
assert_that(get_data_func.call_args_list[2][0],
is_((['filename2.nc'], 'var3', 'cis')))
assert_that(get_data_func.call_args_list[3][0],
is_((['filename2.nc'], 'var4', 'cis')))
def test_horizontal_constraint_in_2d(self):
from cis.data_io.Coord import Coord, CoordList
from cis.data_io.ungridded_data import Metadata
ug_data = mock.make_regular_2d_ungridded_data()
ug_data_points = ug_data.as_data_frame(time_index=False, name='vals').dropna(axis=1)
sample_points = UngriddedData(np.array([0.0]), Metadata(),
CoordList([Coord(np.array([7.5]), Metadata(standard_name='latitude')),
Coord(np.array([-2.5]), Metadata(standard_name='longitude'))]))
sample_points_view = sample_points.as_data_frame(time_index=False, name='vals').dropna(axis=1)
# sample_point = HyperPoint(lat=7.5, lon=-2.5)
# sample_points = HyperPointList([sample_point])
coord_map = None
# One degree near 0, 0 is about 110km in latitude and longitude, so 300km should keep us to within 3 degrees
# in each direction
constraint = SepConstraintKdtree(h_sep=400)
index = HaversineDistanceKDTreeIndex()
index.index_data(sample_points, ug_data_points, coord_map, leafsize=2)
constraint.haversine_distance_kd_tree_index = index
# This should leave us with 4 points
ref_vals = np.array([10, 11, 13, 14])
indices = constraint.haversine_distance_kd_tree_index.find_points_within_distance_sample(sample_points_view, 400)
new_vals = ug_data.data.flat[indices]
eq_(ref_vals.size, len(new_vals[0]))
assert (np.equal(ref_vals, new_vals).all())
def test_GIVEN_single_variable_WHEN_subset_THEN_Subsetter_called_correctly(self):
variable = 'var_name'
filename = 'filename'
xmin, xmax = -10, 10
ymin, ymax = 40, 60
limits = {'x': SubsetLimits(xmin, xmax, False),
'y': SubsetLimits(ymin, ymax, False)}
output_file = 'output.hdf'
mock_data_reader = DataReader()
mock_data_reader.read_data_list = MagicMock(return_value=make_regular_2d_ungridded_data())
mock_data_writer = DataWriter()
mock_data_writer.write_data = Mock()
mock_subsetter = Subsetter()
mock_subsetter.subset = MagicMock(side_effect=lambda *args: args[0]) # Return the data array unmodified
subset = Subset(limits, output_file, subsetter=mock_subsetter,
data_reader=mock_data_reader, data_writer=mock_data_writer)
subset.subset(variable, filename, product=None)
assert_that(mock_subsetter.subset.call_count, is_(1))
called_data = mock_subsetter.subset.call_args[0][0]
called_constraint = mock_subsetter.subset.call_args[0][1]
assert_that(called_data.data_flattened.tolist(),
is_([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]))
assert_that(called_constraint, instance_of(UngriddedSubsetConstraint))
assert_that(called_constraint._limits['lat'][1:3], is_((ymin, ymax)))
assert_that(called_constraint._limits['lon'][1:3], is_((xmin, xmax)))
def test_other_longitude_wrapping_multiple_ranges_forced_minus_180_to_180(self):
"""
Test that ungridded data which crosses the dateline gets plotted correctly
"""
from cis.plotting import Plotter
from cis.test.util.mock import make_regular_2d_ungridded_data
datas = [make_regular_2d_ungridded_data(lat_dim_length=2, lon_dim_length=90, lon_min=-175., lon_max=145.),
make_regular_2d_ungridded_data(lon_dim_length=90, lon_min=5., lon_max=325., lat_min=30, lat_max=60)]
Plotter(datas, x_variable='longitude', y_variable='latitude', plotwidth=8, plotheight=6, cbarscale=None,
itemwidth=50, yrange={'ymin':-90, 'ymax':90}, xrange={'xmin':-180,'xmax':180},
datagroups=[{'itemstyle':'', 'cmap':'jet', 'edgecolor':'', 'label': '-180to180'},
{'itemstyle':'', 'cmap':'jet', 'edgecolor':'', 'label': '0to360'}])
self.check_graphic()
def test_already_collocated_in_col_ungridded_to_ungridded_in_2d(self):
ug_data = mock.make_regular_2d_ungridded_data()
# This point already exists on the cube with value 5 - which shouldn't be a problem
sample_points = UngriddedData.from_points_array([HyperPoint(0.0, 0.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)
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_GIVEN_operation_results_in_wrong_shape_THEN_raises_EvaluationError(self):
data1 = mock.make_regular_2d_ungridded_data()
data1.metadata._name = 'var1'
self.data = [data1]
expr = 'numpy.mean(var1)'
with self.assertRaises(EvaluationError):
res = self.calc.evaluate(self.data, expr)
def test_histogram(self):
from cis.test.util.mock import make_regular_2d_ungridded_data
d = make_regular_2d_ungridded_data()
d.plot(how='histogram')
self.check_graphic()
def test_already_collocated_in_col_ungridded_to_ungridded_in_2d(self):
ug_data = mock.make_regular_2d_ungridded_data()
# This point already exists on the cube with value 5 - which shouldn't be a problem
sample_points = UngriddedData.from_points_array([HyperPoint(0.0, 0.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)
def test_invalid_args(self):
from cis.test.util.mock import make_regular_2d_ungridded_data
from nose.tools import assert_raises
d = make_regular_2d_ungridded_data()
with assert_raises(AttributeError):
d.plot(how='histogram', contnlevels=5)
def test_combining(self):
from cis.test.util.mock import make_regular_2d_ungridded_data
another_list = UngriddedDataList([
make_regular_2d_ungridded_data(),
make_regular_2d_ungridded_data()
])
# Test adding
assert_that(
isinstance(self.ungridded_data_list + another_list,
UngriddedDataList))
# Test extending
another_list.extend(self.ungridded_data_list)
assert_that(isinstance(another_list, UngriddedDataList))
assert_that(len(another_list) == 4)
# Test can't add single items
with assert_raises(TypeError):
self.ungridded_data_list + another_list[0]
def test_already_collocated_in_col_ungridded_to_ungridded_in_2d(self):
from cis.collocation.col_implementations import GeneralUngriddedCollocator, nn_horizontal, DummyConstraint
ug_data = mock.make_regular_2d_ungridded_data()
# This point already exists on the cube with value 5 - which shouldn't be a problem
sample_points = UngriddedData.from_points_array([HyperPoint(0.0, 0.0)])
col = GeneralUngriddedCollocator()
new_data = col.collocate(sample_points, ug_data, DummyConstraint(), nn_horizontal())[0]
eq_(new_data.data[0], 8.0)
def test_GIVEN_single_variable_ungridded_WHEN_read_data_THEN_GriddedData_returned(self):
variables = 'var1'
filenames = 'filename1'
product = None
get_data_func = MagicMock(return_value=make_regular_2d_ungridded_data())
reader = DataReader(get_data_func=get_data_func)
data = reader.read_data_list(filenames, variables, product)[0]
# Check the data read function is called correctly
assert_that(get_data_func.call_count, is_(1))
call_args = get_data_func.call_args_list[0][0]
assert_that(call_args[0], is_([filenames]))
assert_that(call_args[1], is_(variables))
assert_that(call_args[2], is_(product))
# Check the data we got back is as expected
assert_that(data, instance_of(UngriddedData))
assert_that(data.data.tolist(), is_(make_regular_2d_ungridded_data().data.tolist()))
def test_GIVEN_ungridded_data_with_no_time_WHEN_call_as_data_frame_THEN_returns_valid_data_frame(self):
from cis.test.util.mock import make_regular_2d_ungridded_data
ug_data = make_regular_2d_ungridded_data()
df = ug_data.as_data_frame()
assert_that(df['rainfall_rate'][5] == 6)
assert_that(df['latitude'][7] == 0)
assert_that(df['rainfall_rate'].median() == 8.0)
def test_scatter2d_over_bluemarble(self):
from cis.test.util.mock import make_regular_2d_ungridded_data
d = make_regular_2d_ungridded_data()
ax = d.plot(how='scatter2d')
ax.bluemarble()
self.check_graphic()
def test_GIVEN_NO_range_WHEN_data_is_minus_0_to_360_THEN_returns_0(self):
from cis.test.util.mock import make_regular_2d_ungridded_data
data = make_regular_2d_ungridded_data(lat_dim_length=2, lon_dim_length=90, lon_min=5, lon_max=345.)
self.plot.packed_data_items = [data]
self.plot.set_x_wrap_start(self.plot, None)
eq_(self.plot.x_wrap_start, 0)
def test_GIVEN_range_15_to_45_WHEN_data_is_minus_180_to_180_THEN_returns_180(self):
from cis.test.util.mock import make_regular_2d_ungridded_data
data = make_regular_2d_ungridded_data(lat_dim_length=2, lon_dim_length=90, lon_min=-175., lon_max=145.)
self.plot.packed_data_items = [data]
self.plot.set_x_wrap_start(self.plot, 15)
eq_(self.plot.x_wrap_start, 0)
def test_GIVEN_data_is_minus_0_to_360_THEN_returns_0(self):
from cis.test.util.mock import make_regular_2d_ungridded_data
data = make_regular_2d_ungridded_data(lat_dim_length=2,
lon_dim_length=90,
lon_min=5,
lon_max=345.)
eq_(find_longitude_wrap_start(data), 0)
def test_GIVEN_ungridded_data_with_no_time_WHEN_call_as_data_frame_THEN_returns_valid_data_frame(
self):
from cis.test.util.mock import make_regular_2d_ungridded_data
ug_data = make_regular_2d_ungridded_data()
df = ug_data.as_data_frame()
assert_that(df['rainfall_rate'][5] == 6)
assert_that(df['latitude'][7] == 0)
assert_that(df['rainfall_rate'].median() == 8.0)
def test_can_iterate_over_all_points(self):
ug = mock.make_regular_2d_ungridded_data()
hpv = ug.get_all_points()
count = 0
vals = []
for p in hpv:
count += 1
vals.append(p.val[0])
assert(count == 15)
assert(vals == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])
def test_scatter2d_over_bluemarble_coord_axis(self):
from cis.test.util.mock import make_regular_2d_ungridded_data
d = make_regular_2d_ungridded_data()
d.lat.axis = ''
d.lon.axis=''
ax = d.plot(how='scatter2d', xaxis=d.lon, yaxis=d.lat)
ax.bluemarble()
self.check_graphic()
def test_GIVEN_multiple_variable_mix_of_gridded_ungridded_WHEN_read_data_THEN_raises_TypeError(
self):
variables = ['var1', 'var2']
filenames = 'filename1'
product = None
gridded_data = make_square_5x3_2d_cube()
gridded_data.__class__ = GriddedData
ungridded_data = make_regular_2d_ungridded_data()
get_data_func = MagicMock(side_effect=[gridded_data, ungridded_data])
reader = DataReader(get_data_func=get_data_func)
with self.assertRaises(TypeError):
data = reader.read_data_list(filenames, variables, product)[0]
def test_GIVEN_single_variable_ungridded_WHEN_read_data_THEN_GriddedData_returned(
self):
variables = 'var1'
filenames = 'filename1'
product = None
get_data_func = MagicMock(
return_value=make_regular_2d_ungridded_data())
reader = DataReader(get_data_func=get_data_func)
data = reader.read_data_list(filenames, variables, product)[0]
# Check the data read function is called correctly
assert_that(get_data_func.call_count, is_(1))
call_args = get_data_func.call_args_list[0][0]
assert_that(call_args[0], is_([filenames]))
assert_that(call_args[1], is_(variables))
assert_that(call_args[2], is_(product))
# Check the data we got back is as expected
assert_that(data, instance_of(UngriddedData))
assert_that(data.data.tolist(),
is_(make_regular_2d_ungridded_data().data.tolist()))
def test_bluemarble_minus_180_180(self):
"""
Test that ungridded data which crosses the dateline gets plotted correctly
"""
from cis.plotting.formatted_plot import Plotter
from cis.test.util.mock import make_regular_2d_ungridded_data
data = make_regular_2d_ungridded_data(lat_dim_length=2, lon_dim_length=90, lon_min=-175., lon_max=145.)
Plotter([data], xaxis='longitude', yaxis='latitude', width=8, height=6, cbarscale=None,
layer_opts=[{'itemwidth': 50}], ymin=-90, ymax=90, nasabluemarble=True)
self.check_graphic()
def test_coastline_color(self):
"""
Test that ungridded data which crosses the dateline gets plotted correctly
"""
from cis.test.util.mock import make_regular_2d_ungridded_data
from cis.plotting.formatted_plot import Plotter
data = make_regular_2d_ungridded_data(lon_dim_length=90, lon_min=5., lon_max=325., lat_min=-30, lat_max=30)
Plotter([data], xaxis='longitude', yaxis='latitude', width=8, height=6, cbarscale=None,
ymin=-90, ymax=90, coastlinescolour='red', layer_opts=[{'itemwidth': 50}])
self.check_graphic()
