climate-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jo...@apache.org
Subject svn commit: r1514765 - /incubator/climate/branches/RefactorInput/ocw/tests/test_dataset_processor.py
Date Fri, 16 Aug 2013 16:01:59 GMT
Author: joyce
Date: Fri Aug 16 16:01:59 2013
New Revision: 1514765

URL: http://svn.apache.org/r1514765
Log:
CLIMATE-255 - Clean up new Subset tests and (once again) fix the test I broke and accidently
committed.

Modified:
    incubator/climate/branches/RefactorInput/ocw/tests/test_dataset_processor.py

Modified: incubator/climate/branches/RefactorInput/ocw/tests/test_dataset_processor.py
URL: http://svn.apache.org/viewvc/incubator/climate/branches/RefactorInput/ocw/tests/test_dataset_processor.py?rev=1514765&r1=1514764&r2=1514765&view=diff
==============================================================================
--- incubator/climate/branches/RefactorInput/ocw/tests/test_dataset_processor.py (original)
+++ incubator/climate/branches/RefactorInput/ocw/tests/test_dataset_processor.py Fri Aug 16
16:01:59 2013
@@ -25,125 +25,125 @@ import numpy.ma as ma
 import logging
 logging.basicConfig(level=logging.CRITICAL)
 
-#class CustomAssertions:
-    ## Custom Assertions to handle Numpy Arrays
-    #def assert1DArraysEqual(self, array1, array2):
-        #self.assertSequenceEqual(tuple(array1), tuple(array2))
-
-#class TestEnsemble(unittest.TestCase, CustomAssertions): 
-    #def test_unequal_dataset_shapes(self):
-        #self.ten_year_dataset = ten_year_monthly_dataset()
-        #self.two_year_dataset = two_year_daily_dataset()
-        #with self.assertRaises(ValueError):
-            #self.ensemble_dataset = dp.ensemble([self.ten_year_dataset, self.two_year_dataset])
-    
-    #def test_ensemble_logic(self):
-        #self.datasets = []
-        #self.datasets.append(build_ten_cube_dataset(1))
-        #self.datasets.append(build_ten_cube_dataset(2))
-        #self.three = build_ten_cube_dataset(3)
-        #self.datasets.append(self.three)
-        #self.datasets.append(build_ten_cube_dataset(4))
-        #self.datasets.append(build_ten_cube_dataset(5))
-        #self.ensemble = dp.ensemble(self.datasets)
-        #self.ensemble_flat = self.ensemble.values.flatten()
-        #self.three_flat = self.three.values.flatten()
-        #self.assert1DArraysEqual(self.ensemble_flat, self.three_flat)
-    
-    #def test_ensemble_name(self):
-        #self.ensemble_dataset_name = "Dataset Ensemble"
-        #self.datasets = []
-        #self.datasets.append(build_ten_cube_dataset(1))
-        #self.datasets.append(build_ten_cube_dataset(2))
-        #self.ensemble = dp.ensemble(self.datasets)
-        #self.assertEquals(self.ensemble.name, self.ensemble_dataset_name)
-        
-
-#class TestTemporalRebin(unittest.TestCase, CustomAssertions):
-    
-    #def setUp(self):
-        #self.ten_year_monthly_dataset = ten_year_monthly_dataset()
-        #self.ten_year_annual_times = np.array([datetime.datetime(year, 1, 1) for year in
range(2000, 2010)])
-        #self.two_years_daily_dataset = two_year_daily_dataset()
-    
-    #def test_monthly_to_annual_rebin(self):
-        #annual_dataset = dp.temporal_rebin(self.ten_year_monthly_dataset, datetime.timedelta(days=365))
-        #self.assert1DArraysEqual(annual_dataset.times, self.ten_year_annual_times)
-    
-    #def test_monthly_to_full_rebin(self):
-        #full_dataset = dp.temporal_rebin(self.ten_year_monthly_dataset, datetime.timedelta(days=3650))
-        #full_times = [datetime.datetime(2004, 12, 16)]
-        #self.assertEqual(full_dataset.times, full_times)
-    
-    #def test_daily_to_monthly_rebin(self):
-        #"""This test takes a really long time to run.  TODO: Figure out where the performance
drag is"""
-        #monthly_dataset = dp.temporal_rebin(self.two_years_daily_dataset, datetime.timedelta(days=31))
-        #bins = list(set([datetime.datetime(time_reading.year, time_reading.month, 1) for
time_reading in self.two_years_daily_dataset.times]))
-        #bins = np.array(bins)
-        #bins.sort()
-        #self.assert1DArraysEqual(monthly_dataset.times, bins)
-    
-    #def test_daily_to_annual_rebin(self):
-        #annual_dataset = dp.temporal_rebin(self.two_years_daily_dataset, datetime.timedelta(days=366))
-        #bins = list(set([datetime.datetime(time_reading.year, 1, 1) for time_reading in
self.two_years_daily_dataset.times]))
-        #bins = np.array(bins)
-        #bins.sort()
-        #self.assert1DArraysEqual(annual_dataset.times, bins)
-        
-    
-    #def test_non_rebin(self):
-        #"""This will take a monthly dataset and ask for a monthly rebin of 28 days.  The
resulting
-        #dataset should have the same time values"""
-        #monthly_dataset = dp.temporal_rebin(self.ten_year_monthly_dataset, datetime.timedelta(days=28))
-        #good_times = self.ten_year_monthly_dataset.times
-        #self.assert1DArraysEqual(monthly_dataset.times, good_times)
-
-
-#class TestRcmesSpatialRegrid(unittest.TestCase):
-
-    #def test_return_array_shape(self):
-        #spatial_values = np.ones([90,180])
-        #spatial_values = ma.array(spatial_values)
-        
-        #lat_range = ma.array(range(-89, 90, 2))
-        #lon_range = ma.array(range(-179, 180, 2))
-        
-        #lons, lats = np.meshgrid(lon_range, lat_range)
-        ## Convert these to masked arrays
-        #lats = ma.array(lats)
-        #lons = ma.array(lons)
-        
-        #lat2_range = np.array(range(-89, 90, 4))
-        #lon2_range = np.array(range(-179, 180, 4))
-        
-        #lons2, lats2 = np.meshgrid(lon2_range, lat2_range)
-        ## Convert to masked arrays
-        #lats2 = ma.array(lats2)
-        #lons2 = ma.array(lons2)
-
-        #regridded_values = dp._rcmes_spatial_regrid(spatial_values, lats, lons, lats2, lons2)
-        #self.assertEqual(regridded_values.shape, lats2.shape)
-        #self.assertEqual(regridded_values.shape, lons2.shape)
-
-#class TestSpatialRegrid(unittest.TestCase, CustomAssertions):
-    
-    #def setUp(self):
-        #self.input_dataset = ten_year_monthly_dataset()
-        #self.new_lats = np.array(range(-89, 90, 4))
-        #self.new_lons = np.array(range(-179, 180, 4))
-        #self.regridded_dataset = dp.spatial_regrid(self.input_dataset, self.new_lats, self.new_lons)
-
-
-    #def test_returned_lats(self):
-        #self.assert1DArraysEqual(self.regridded_dataset.lats, self.new_lats)
-
-    #def test_returned_lons(self):
-        #self.assert1DArraysEqual(self.regridded_dataset.lons, self.new_lons)
-
-    #def test_shape_of_values(self):
-        #regridded_data_shape = self.regridded_dataset.values.shape
-        #expected_data_shape = (len(self.input_dataset.times), len(self.new_lats), len(self.new_lons))
-        #self.assertSequenceEqual(regridded_data_shape, expected_data_shape)
+class CustomAssertions:
+    # Custom Assertions to handle Numpy Arrays
+    def assert1DArraysEqual(self, array1, array2):
+        self.assertSequenceEqual(tuple(array1), tuple(array2))
+
+class TestEnsemble(unittest.TestCase, CustomAssertions): 
+    def test_unequal_dataset_shapes(self):
+        self.ten_year_dataset = ten_year_monthly_dataset()
+        self.two_year_dataset = two_year_daily_dataset()
+        with self.assertRaises(ValueError):
+            self.ensemble_dataset = dp.ensemble([self.ten_year_dataset, self.two_year_dataset])
+    
+    def test_ensemble_logic(self):
+        self.datasets = []
+        self.datasets.append(build_ten_cube_dataset(1))
+        self.datasets.append(build_ten_cube_dataset(2))
+        self.three = build_ten_cube_dataset(3)
+        self.datasets.append(self.three)
+        self.datasets.append(build_ten_cube_dataset(4))
+        self.datasets.append(build_ten_cube_dataset(5))
+        self.ensemble = dp.ensemble(self.datasets)
+        self.ensemble_flat = self.ensemble.values.flatten()
+        self.three_flat = self.three.values.flatten()
+        self.assert1DArraysEqual(self.ensemble_flat, self.three_flat)
+    
+    def test_ensemble_name(self):
+        self.ensemble_dataset_name = "Dataset Ensemble"
+        self.datasets = []
+        self.datasets.append(build_ten_cube_dataset(1))
+        self.datasets.append(build_ten_cube_dataset(2))
+        self.ensemble = dp.ensemble(self.datasets)
+        self.assertEquals(self.ensemble.name, self.ensemble_dataset_name)
+        
+
+class TestTemporalRebin(unittest.TestCase, CustomAssertions):
+    
+    def setUp(self):
+        self.ten_year_monthly_dataset = ten_year_monthly_dataset()
+        self.ten_year_annual_times = np.array([datetime.datetime(year, 1, 1) for year in
range(2000, 2010)])
+        self.two_years_daily_dataset = two_year_daily_dataset()
+    
+    def test_monthly_to_annual_rebin(self):
+        annual_dataset = dp.temporal_rebin(self.ten_year_monthly_dataset, datetime.timedelta(days=365))
+        self.assert1DArraysEqual(annual_dataset.times, self.ten_year_annual_times)
+    
+    def test_monthly_to_full_rebin(self):
+        full_dataset = dp.temporal_rebin(self.ten_year_monthly_dataset, datetime.timedelta(days=3650))
+        full_times = [datetime.datetime(2004, 12, 16)]
+        self.assertEqual(full_dataset.times, full_times)
+    
+    def test_daily_to_monthly_rebin(self):
+        """This test takes a really long time to run.  TODO: Figure out where the performance
drag is"""
+        monthly_dataset = dp.temporal_rebin(self.two_years_daily_dataset, datetime.timedelta(days=31))
+        bins = list(set([datetime.datetime(time_reading.year, time_reading.month, 1) for
time_reading in self.two_years_daily_dataset.times]))
+        bins = np.array(bins)
+        bins.sort()
+        self.assert1DArraysEqual(monthly_dataset.times, bins)
+    
+    def test_daily_to_annual_rebin(self):
+        annual_dataset = dp.temporal_rebin(self.two_years_daily_dataset, datetime.timedelta(days=366))
+        bins = list(set([datetime.datetime(time_reading.year, 1, 1) for time_reading in self.two_years_daily_dataset.times]))
+        bins = np.array(bins)
+        bins.sort()
+        self.assert1DArraysEqual(annual_dataset.times, bins)
+        
+    
+    def test_non_rebin(self):
+        """This will take a monthly dataset and ask for a monthly rebin of 28 days.  The
resulting
+        dataset should have the same time values"""
+        monthly_dataset = dp.temporal_rebin(self.ten_year_monthly_dataset, datetime.timedelta(days=28))
+        good_times = self.ten_year_monthly_dataset.times
+        self.assert1DArraysEqual(monthly_dataset.times, good_times)
+
+
+class TestRcmesSpatialRegrid(unittest.TestCase):
+
+    def test_return_array_shape(self):
+        spatial_values = np.ones([90,180])
+        spatial_values = ma.array(spatial_values)
+        
+        lat_range = ma.array(range(-89, 90, 2))
+        lon_range = ma.array(range(-179, 180, 2))
+        
+        lons, lats = np.meshgrid(lon_range, lat_range)
+        # Convert these to masked arrays
+        lats = ma.array(lats)
+        lons = ma.array(lons)
+        
+        lat2_range = np.array(range(-89, 90, 4))
+        lon2_range = np.array(range(-179, 180, 4))
+        
+        lons2, lats2 = np.meshgrid(lon2_range, lat2_range)
+        # Convert to masked arrays
+        lats2 = ma.array(lats2)
+        lons2 = ma.array(lons2)
+
+        regridded_values = dp._rcmes_spatial_regrid(spatial_values, lats, lons, lats2, lons2)
+        self.assertEqual(regridded_values.shape, lats2.shape)
+        self.assertEqual(regridded_values.shape, lons2.shape)
+
+class TestSpatialRegrid(unittest.TestCase, CustomAssertions):
+    
+    def setUp(self):
+        self.input_dataset = ten_year_monthly_dataset()
+        self.new_lats = np.array(range(-89, 90, 4))
+        self.new_lons = np.array(range(-179, 180, 4))
+        self.regridded_dataset = dp.spatial_regrid(self.input_dataset, self.new_lats, self.new_lons)
+
+
+    def test_returned_lats(self):
+        self.assert1DArraysEqual(self.regridded_dataset.lats, self.new_lats)
+
+    def test_returned_lons(self):
+        self.assert1DArraysEqual(self.regridded_dataset.lons, self.new_lons)
+
+    def test_shape_of_values(self):
+        regridded_data_shape = self.regridded_dataset.values.shape
+        expected_data_shape = (len(self.input_dataset.times), len(self.new_lats), len(self.new_lons))
+        self.assertSequenceEqual(regridded_data_shape, expected_data_shape)
 
 class TestSubset(unittest.TestCase):
     def setUp(self):
@@ -165,45 +165,48 @@ class TestSubset(unittest.TestCase):
         self.assertEqual(subset.times.shape[0], 37)
         self.assertEqual(subset.values.shape, (37, 82, 162))
 
-    def test_subset_with_out_of_dataset_bounds_subregion(self):
+class TestFailingSubset(unittest.TestCase):
+    def setUp(self):
+        self.target_dataset = ten_year_monthly_dataset()
         self.target_dataset.lats = np.array(range(-89, 88, 2))
         self.target_dataset.lons = np.array(range(-179, 178, 2))
 
-        # Out of dataset bounds lat_min test
+        self.subregion = ds.Bounds(
+            -81, 81, 
+            -161, 161, 
+            datetime.datetime(2001, 1, 1), 
+            datetime.datetime(2004, 1, 1)
+        )
+
+    def test_out_of_dataset_bounds_lat_min(self):
         self.subregion.lat_min = -90
         with self.assertRaises(ValueError):
             dp.subset(self.subregion, self.target_dataset)
-        self.subregion.lat_min = -81
 
-        # Out of dataset bounds lat_max test
+    def test_out_of_dataset_bounds_lat_max(self):
         self.subregion.lat_max = 90
         with self.assertRaises(ValueError):
             dp.subset(self.subregion, self.target_dataset)
-        self.subregion.lat_max = 81
 
-        # Out of dataset bounds lon_min test
+    def test_out_of_dataset_bounds_lon_min(self):
         self.subregion.lon_min = -180
         with self.assertRaises(ValueError):
             dp.subset(self.subregion, self.target_dataset)
-        self.subregion.lon_min = -161
 
-        # Out of dataset bounds lon_max test
+    def test_out_of_dataset_bounds_lon_max(self):
         self.subregion.lon_max = 180
         with self.assertRaises(ValueError):
             dp.subset(self.subregion, self.target_dataset)
-        self.subregion.lon_max = 161
 
-        # Out of dataset bounds start time test
+    def test_out_of_dataset_bounds_start(self):
         self.subregion.start = datetime.datetime(1999, 1, 1)
         with self.assertRaises(ValueError):
             dp.subset(self.subregion, self.target_dataset)
-        self.subregion.start = datetime.datetime(2001, 1, 1)
 
-        # Out of dataset bounds end time test
+    def test_out_of_dataset_bounds_end(self):
         self.subregion.end = datetime.datetime(2011, 1, 1)
         with self.assertRaises(ValueError):
             dp.subset(self.subregion, self.target_dataset)
-        self.subregion.end = datetime.datetime(2010, 1, 1)
 
 
 def ten_year_monthly_dataset():



Mime
View raw message