class TestDatasetFunctions(unittest.TestCase):
def setUp(self):
self.lat = np.array([10, 12, 14, 16, 18])
self.lon = np.array([100, 102, 104, 106, 108])
self.time = np.array([dt.datetime(2000, x, 1) for x in range(1, 13)])
flat_array = np.array(range(300))
self.value = flat_array.reshape(12, 5, 5)
self.variable = 'prec'
self.test_dataset = Dataset(self.lat, self.lon, self.time,
self.value, self.variable)
def test_spatial_boundaries(self):
self.assertEqual(
self.test_dataset.spatial_boundaries(),
(min(self.lat), max(self.lat), min(self.lon), max(self.lon)))
def test_time_range(self):
self.assertEqual(
self.test_dataset.time_range(),
(dt.datetime(2000, 1, 1), dt.datetime(2000, 12, 1)))
def test_spatial_resolution(self):
self.assertEqual(self.test_dataset.spatial_resolution(), (2, 2))
def test_temporal_resolution(self):
self.assertEqual(self.test_dataset.temporal_resolution(), 'monthly')
class TestEvaluationSettingsGeneration(unittest.TestCase):
@classmethod
def setUpClass(self):
self.lats = np.array(range(-10, 10, 1))
self.lons = np.array(range(-20, 20, 1))
self.times = np.array([dt.datetime(2000, x, 1) for x in range(1, 13)])
flat_array = np.array(range(9600))
self.values = flat_array.reshape(12, 20, 40)
self.dataset = Dataset(
self.lats,
self.lons,
self.times,
self.values,
)
self.evaluation = Evaluation(self.dataset, [], [])
def test_default_data_return(self):
new_eval = Evaluation(None, [], [])
default_output = {
'temporal_time_delta': 999,
'spatial_regrid_lats': (-90, 90, 1),
'spatial_regrid_lons': (-180, 180, 1),
'subset': [-90, 90, -180, 180, "1500-01-01", "2500-01-01"],
}
out = writer.generate_evaluation_information(new_eval)
self.assertEquals(default_output, out)
def test_handles_only_reference_dataset(self):
new_eval = Evaluation(self.dataset, [], [])
default_output = {
'temporal_time_delta': 999,
'spatial_regrid_lats': (-90, 90, 1),
'spatial_regrid_lons': (-180, 180, 1),
'subset': [-90, 90, -180, 180, "1500-01-01", "2500-01-01"],
}
out = writer.generate_evaluation_information(new_eval)
self.assertNotEquals(default_output, out)
def test_handles_only_target_dataset(self):
new_eval = Evaluation(None, [self.dataset], [])
default_output = {
'temporal_time_delta': 999,
'spatial_regrid_lats': (-90, 90, 1),
'spatial_regrid_lons': (-180, 180, 1),
'subset': [-90, 90, -180, 180, "1500-01-01", "2500-01-01"],
}
out = writer.generate_evaluation_information(new_eval)
self.assertNotEquals(default_output, out)
def test_daily_temporal_bin(self):
new_times = np.array([dt.datetime(2000, 1, 1, x) for x in range(1, 13)])
dataset = Dataset(
self.lats,
self.lons,
new_times,
self.values,
)
new_eval = Evaluation(dataset, [], [])
out = writer.generate_evaluation_information(new_eval)
self.assertEquals(out['temporal_time_delta'], 1)
def test_monthly_temporal_bin(self):
out = writer.generate_evaluation_information(self.evaluation)
self.assertEquals(out['temporal_time_delta'], 31)
def test_yearly_temporal_bin(self):
new_times = np.array([dt.datetime(2000 + x, 1, 1) for x in range(1, 13)])
dataset = Dataset(
self.lats,
self.lons,
new_times,
self.values,
)
new_eval = Evaluation(dataset, [], [])
out = writer.generate_evaluation_information(new_eval)
self.assertEquals(out['temporal_time_delta'], 366)
def test_spatial_regrid_lats(self):
out = writer.generate_evaluation_information(self.evaluation)
lats = out['spatial_regrid_lats']
lat_range = np.arange(lats[0], lats[1], lats[2])
self.assertTrue(np.array_equal(lat_range, self.lats))
def test_spatial_regrid_lons(self):
out = writer.generate_evaluation_information(self.evaluation)
lons = out['spatial_regrid_lons']
lat_range = np.arange(lons[0], lons[1], lons[2])
self.assertTrue(np.array_equal(lat_range, self.lons))
def test_subset_with_single_dataset(self):
out = writer.generate_evaluation_information(self.evaluation)
subset = out['subset']
ds_lat_min, ds_lat_max, ds_lon_min, ds_lon_max = self.dataset.spatial_boundaries()
start, end = self.dataset.time_range()
self.assertEqual(ds_lat_min, subset[0])
self.assertEqual(ds_lat_max, subset[1])
self.assertEqual(ds_lon_min, subset[2])
self.assertEqual(ds_lon_max, subset[3])
self.assertEquals(str(start), subset[4])
self.assertEquals(str(end), subset[5])
def test_subset_with_multiple_datasets(self):
new_ds = Dataset(
np.arange(0, 20, 1),
self.lons,
self.times,
self.values
)
new_eval = Evaluation(self.dataset, [new_ds], [])
out = writer.generate_evaluation_information(new_eval)
subset = out['subset']
ds_lat_min, ds_lat_max, ds_lon_min, ds_lon_max = self.dataset.spatial_boundaries()
start, end = self.dataset.time_range()
self.assertEqual(ds_lat_min, subset[0])
# Check that we actually used the different max lat value that we
# created by adding 'new_ds'.
self.assertEqual(max(new_ds.lats), subset[1])
self.assertEqual(ds_lon_min, subset[2])
self.assertEqual(ds_lon_max, subset[3])
self.assertEquals(str(start), subset[4])
self.assertEquals(str(end), subset[5])
class TestDatasetFunctions(unittest.TestCase):
def setUp(self):
self.lat = np.array([10, 12, 14, 16, 18])
self.lon = np.array([100, 102, 104, 106, 108])
self.time = np.array([dt.datetime(2000, x, 1) for x in range(1, 13)])
flat_array = np.array(range(300))
self.value = flat_array.reshape(12, 5, 5)
self.variable = 'prec'
self.test_dataset = Dataset(self.lat, self.lon, self.time,
self.value, self.variable)
def test_spatial_boundaries(self):
self.assertEqual(
self.test_dataset.spatial_boundaries(),
(min(self.lat), max(self.lat), min(self.lon), max(self.lon)))
def test_time_range(self):
self.assertEqual(
self.test_dataset.time_range(),
(dt.datetime(2000, 1, 1), dt.datetime(2000, 12, 1)))
def test_spatial_resolution(self):
self.assertEqual(self.test_dataset.spatial_resolution(), (2, 2))
def test_spatial_resolution_2_dim_lat_lon(self):
self.lat = np.array([10, 12, 14, 16, 18, 20])
self.lon = np.array([100, 102, 104, 106, 108, 110])
self.lat = self.lat.reshape(3, 2)
self.lon = self.lon.reshape(3, 2)
flat_array = np.array(range(72))
self.value = flat_array.reshape(12, 3, 2)
self.test_dataset = Dataset(self.lat, self.lon, self.time,
self.value, self.variable)
self.assertEqual(self.test_dataset.spatial_resolution(), (6, 6))
def test_temporal_resolution_hourly(self):
self.time = np.array([dt.datetime(2000, 1, 1),
dt.datetime(2000, 1, 1)])
flat_array = np.array(range(50))
self.value = flat_array.reshape(2, 5, 5)
self.test_dataset = Dataset(self.lat, self.lon, self.time,
self.value, self.variable)
self.assertEqual(self.test_dataset.temporal_resolution(), 'minutely')
def test_temporal_resolution_monthly(self):
self.assertEqual(self.test_dataset.temporal_resolution(), 'monthly')
def test_temporal_resolution_daily(self):
self.time = np.array([dt.datetime(2000, 3, x) for x in range(1, 31)])
flat_array = np.array(range(750))
self.value = flat_array.reshape(30, 5, 5)
self.test_dataset = Dataset(self.lat, self.lon, self.time,
self.value, self.variable)
self.assertEqual(self.test_dataset.temporal_resolution(), 'daily')
def test_temporal_resolution_yearly(self):
self.time = np.array([dt.datetime(x, 6, 1) for x in range(2000, 2015)])
flat_array = np.array(range(375))
self.value = flat_array.reshape(15, 5, 5)
self.test_dataset = Dataset(self.lat, self.lon, self.time,
self.value, self.variable)
self.assertEqual(self.test_dataset.temporal_resolution(), 'yearly')
def test_str_(self):
dataset = self.test_dataset
lat_min, lat_max, lon_min, lon_max = dataset.spatial_boundaries()
start, end = dataset.time_range()
lat_range = "({}, {})".format(lat_min, lon_min)
lon_range = "({}, {})".format(lon_min, lon_min)
time_range = "({}, {})".format(start, end)
formatted_repr = (
"<Dataset - name: {}, "
"lat-range: {}, "
"lon-range: {}, "
"time_range: {}, "
"var: {}, "
"units: {}>"
)
output = formatted_repr.format(
dataset.name if dataset.name != "" else None,
lat_range,
lon_range,
time_range,
dataset.variable,
dataset.units
)
self.assertEqual(str(self.test_dataset), output)
class TestDatasetFunctions(unittest.TestCase):
def setUp(self):
self.lat = np.array([10, 12, 14, 16, 18])
self.lon = np.array([100, 102, 104, 106, 108])
self.time = np.array([dt.datetime(2000, x, 1) for x in range(1, 13)])
flat_array = np.array(range(300))
self.value = flat_array.reshape(12, 5, 5)
self.variable = 'prec'
self.test_dataset = Dataset(self.lat, self.lon, self.time, self.value,
self.variable)
def test_spatial_boundaries(self):
self.assertEqual(
self.test_dataset.spatial_boundaries(),
(min(self.lat), max(self.lat), min(self.lon), max(self.lon)))
def test_time_range(self):
self.assertEqual(self.test_dataset.time_range(),
(dt.datetime(2000, 1, 1), dt.datetime(2000, 12, 1)))
def test_spatial_resolution(self):
self.assertEqual(self.test_dataset.spatial_resolution(), (2, 2))
def test_spatial_resolution_2_dim_lat_lon(self):
self.lat = np.array([10, 12, 14, 16, 18, 20])
self.lon = np.array([100, 102, 104, 106, 108, 110])
self.lat = self.lat.reshape(3, 2)
self.lon = self.lon.reshape(3, 2)
flat_array = np.array(range(72))
self.value = flat_array.reshape(12, 3, 2)
self.test_dataset = Dataset(self.lat, self.lon, self.time, self.value,
self.variable)
self.assertEqual(self.test_dataset.spatial_resolution(), (6, 6))
def test_temporal_resolution_hourly(self):
self.time = np.array(
[dt.datetime(2000, 1, 1),
dt.datetime(2000, 1, 1)])
flat_array = np.array(range(50))
self.value = flat_array.reshape(2, 5, 5)
self.test_dataset = Dataset(self.lat, self.lon, self.time, self.value,
self.variable)
self.assertEqual(self.test_dataset.temporal_resolution(), 'minutely')
def test_temporal_resolution_monthly(self):
self.assertEqual(self.test_dataset.temporal_resolution(), 'monthly')
def test_temporal_resolution_daily(self):
self.time = np.array([dt.datetime(2000, 3, x) for x in range(1, 31)])
flat_array = np.array(range(750))
self.value = flat_array.reshape(30, 5, 5)
self.test_dataset = Dataset(self.lat, self.lon, self.time, self.value,
self.variable)
self.assertEqual(self.test_dataset.temporal_resolution(), 'daily')
def test_temporal_resolution_yearly(self):
self.time = np.array([dt.datetime(x, 6, 1) for x in range(2000, 2015)])
flat_array = np.array(range(375))
self.value = flat_array.reshape(15, 5, 5)
self.test_dataset = Dataset(self.lat, self.lon, self.time, self.value,
self.variable)
self.assertEqual(self.test_dataset.temporal_resolution(), 'yearly')
def test_str_(self):
dataset = self.test_dataset
lat_min, lat_max, lon_min, lon_max = dataset.spatial_boundaries()
start, end = dataset.time_range()
lat_range = "({}, {})".format(lat_min, lon_min)
lon_range = "({}, {})".format(lon_min, lon_min)
time_range = "({}, {})".format(start, end)
formatted_repr = ("<Dataset - name: {}, "
"lat-range: {}, "
"lon-range: {}, "
"time_range: {}, "
"var: {}, "
"units: {}>")
output = formatted_repr.format(
dataset.name if dataset.name != "" else None, lat_range, lon_range,
time_range, dataset.variable, dataset.units)
self.assertEqual(str(self.test_dataset), output)
class TestEvaluationSettingsGeneration(unittest.TestCase):
@classmethod
def setUpClass(self):
self.lats = np.array(range(-10, 10, 1))
self.lons = np.array(range(-20, 20, 1))
self.times = np.array([dt.datetime(2000, x, 1) for x in range(1, 13)])
flat_array = np.array(range(9600))
self.values = flat_array.reshape(12, 20, 40)
self.dataset = Dataset(
self.lats,
self.lons,
self.times,
self.values,
)
self.evaluation = Evaluation(self.dataset, [], [])
def test_default_data_return(self):
new_eval = Evaluation(None, [], [])
default_output = {
'temporal_time_delta': 999,
'spatial_regrid_lats': (-90, 90, 1),
'spatial_regrid_lons': (-180, 180, 1),
'subset': [-90, 90, -180, 180, "1500-01-01", "2500-01-01"],
}
out = writer.generate_evaluation_information(new_eval)
self.assertEquals(default_output, out)
def test_handles_only_reference_dataset(self):
new_eval = Evaluation(self.dataset, [], [])
default_output = {
'temporal_time_delta': 999,
'spatial_regrid_lats': (-90, 90, 1),
'spatial_regrid_lons': (-180, 180, 1),
'subset': [-90, 90, -180, 180, "1500-01-01", "2500-01-01"],
}
out = writer.generate_evaluation_information(new_eval)
self.assertNotEquals(default_output, out)
def test_handles_only_target_dataset(self):
new_eval = Evaluation(None, [self.dataset], [])
default_output = {
'temporal_time_delta': 999,
'spatial_regrid_lats': (-90, 90, 1),
'spatial_regrid_lons': (-180, 180, 1),
'subset': [-90, 90, -180, 180, "1500-01-01", "2500-01-01"],
}
out = writer.generate_evaluation_information(new_eval)
self.assertNotEquals(default_output, out)
def test_daily_temporal_bin(self):
new_times = np.array(
[dt.datetime(2000, 1, 1, x) for x in range(1, 13)])
dataset = Dataset(
self.lats,
self.lons,
new_times,
self.values,
)
new_eval = Evaluation(dataset, [], [])
out = writer.generate_evaluation_information(new_eval)
self.assertEquals(out['temporal_time_delta'], 1)
def test_monthly_temporal_bin(self):
out = writer.generate_evaluation_information(self.evaluation)
self.assertEquals(out['temporal_time_delta'], 31)
def test_yearly_temporal_bin(self):
new_times = np.array(
[dt.datetime(2000 + x, 1, 1) for x in range(1, 13)])
dataset = Dataset(
self.lats,
self.lons,
new_times,
self.values,
)
new_eval = Evaluation(dataset, [], [])
out = writer.generate_evaluation_information(new_eval)
self.assertEquals(out['temporal_time_delta'], 366)
def test_spatial_regrid_lats(self):
out = writer.generate_evaluation_information(self.evaluation)
lats = out['spatial_regrid_lats']
lat_range = np.arange(lats[0], lats[1], lats[2])
self.assertTrue(np.array_equal(lat_range, self.lats))
def test_spatial_regrid_lons(self):
out = writer.generate_evaluation_information(self.evaluation)
lons = out['spatial_regrid_lons']
lat_range = np.arange(lons[0], lons[1], lons[2])
self.assertTrue(np.array_equal(lat_range, self.lons))
def test_subset_with_single_dataset(self):
out = writer.generate_evaluation_information(self.evaluation)
subset = out['subset']
ds_lat_min, ds_lat_max, ds_lon_min, ds_lon_max = self.dataset.spatial_boundaries(
)
start, end = self.dataset.temporal_boundaries()
self.assertEqual(ds_lat_min, subset[0])
self.assertEqual(ds_lat_max, subset[1])
self.assertEqual(ds_lon_min, subset[2])
self.assertEqual(ds_lon_max, subset[3])
self.assertEquals(str(start), subset[4])
self.assertEquals(str(end), subset[5])
def test_subset_with_multiple_datasets(self):
new_ds = Dataset(np.arange(0, 20, 1), self.lons, self.times,
self.values)
new_eval = Evaluation(self.dataset, [new_ds], [])
out = writer.generate_evaluation_information(new_eval)
subset = out['subset']
ds_lat_min, ds_lat_max, ds_lon_min, ds_lon_max = self.dataset.spatial_boundaries(
)
start, end = self.dataset.temporal_boundaries()
self.assertEqual(ds_lat_min, subset[0])
# Check that we actually used the different max lat value that we
# created by adding 'new_ds'.
self.assertEqual(max(new_ds.lats), subset[1])
self.assertEqual(ds_lon_min, subset[2])
self.assertEqual(ds_lon_max, subset[3])
self.assertEquals(str(start), subset[4])
self.assertEquals(str(end), subset[5])