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()