Ignore:
Timestamp:
Jun 22, 2010, 12:04:32 PM (14 years ago)
Author:
hudson
Message:

More swb tests passing. Cleaned up some pylint errors.

Location:
trunk/anuga_core/source/anuga/file
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/anuga_core/source/anuga/file/test_csv.py

    r7772 r7866  
    220220       
    221221
     222   
     223    def test_csv2polygons(self):
     224        """test loading of a csv polygon file.
     225        """
     226       
     227        path = get_pathname_from_package('anuga.shallow_water')               
     228        testfile = os.path.join(path, 'polygon_values_example.csv')               
     229
     230        polygons, values = load_csv_as_polygons(testfile,
     231                                        value_name='floors')
     232
     233        assert len(polygons) == 7, 'Must have seven polygons'
     234        assert len(values) == 7, 'Must have seven values'
     235           
     236        # Known floor values
     237        floors = {'1': 2, '2': 0, '3': 1, '4': 2, '5': 0, '8': 1, '9': 1}
     238       
     239        # Known polygon values
     240        known_polys = {'1': [[422681.61,871117.55],
     241                             [422691.02,871117.60],
     242                             [422690.87,871084.23],
     243                             [422649.36,871081.85],
     244                             [422649.36,871080.39],
     245                             [422631.86,871079.50],
     246                             [422631.72,871086.75],
     247                             [422636.75,871087.20],
     248                             [422636.75,871091.50],
     249                             [422649.66,871092.09],
     250                             [422649.83,871084.91],
     251                             [422652.94,871084.90],
     252                             [422652.84,871092.39],
     253                             [422681.83,871093.73],
     254                             [422681.61,871117.55]],
     255                       '2': [[422664.22,870785.46],
     256                             [422672.48,870780.14],
     257                             [422668.17,870772.62],
     258                             [422660.35,870777.17],
     259                             [422664.22,870785.46]],
     260                       '3': [[422661.30,871215.06],
     261                             [422667.50,871215.70],
     262                             [422668.30,871204.86],
     263                             [422662.21,871204.33],
     264                             [422661.30,871215.06]],
     265                       '4': [[422473.44,871191.22],
     266                             [422478.33,871192.26],
     267                             [422479.52,871186.03],
     268                             [422474.78,871185.14],
     269                             [422473.44,871191.22]],
     270                       '5': [[422369.69,871049.29],
     271                             [422378.63,871053.58],
     272                             [422383.91,871044.51],
     273                             [422374.97,871040.32],
     274                             [422369.69,871049.29]],
     275                       '8': [[422730.56,871203.13],
     276                             [422734.10,871204.90],
     277                             [422735.26,871202.18],
     278                             [422731.87,871200.58],
     279                             [422730.56,871203.13]],
     280                       '9': [[422659.85,871213.80],
     281                             [422660.91,871210.97],
     282                             [422655.42,871208.85],
     283                             [422654.36,871211.68],
     284                             [422659.85,871213.80]]
     285                       }       
     286       
     287
     288       
     289               
     290        for id in ['1', '2', '3', '4', '5' ,'8' ,'9']:
     291            assert id in polygons.keys()
     292            assert id in values.keys()           
     293
     294            assert int(values[id]) == int(floors[id])
     295            assert len(polygons[id]) == len(known_polys[id])
     296            assert num.allclose(polygons[id], known_polys[id])
     297
     298
     299    def test_csv2polygons_with_clipping(self):
     300        """test_csv2polygons with optional clipping
     301        """
     302        #FIXME(Ole): Not Done!!
     303       
     304        path = get_pathname_from_package('anuga.shallow_water')               
     305        testfile = os.path.join(path, 'polygon_values_example.csv')               
     306
     307        polygons, values = load_csv_as_polygons(testfile,
     308                                        value_name='floors',
     309                                        clipping_polygons=None)
     310
     311        assert len(polygons) == 7, 'Must have seven polygons'
     312        assert len(values) == 7, 'Must have seven values'
     313           
     314        # Known floor values
     315        floors = {'1': 2, '2': 0, '3': 1, '4': 2, '5': 0, '8': 1, '9': 1}
     316       
     317        # Known polygon values
     318        known_polys = {'1': [[422681.61,871117.55],
     319                             [422691.02,871117.60],
     320                             [422690.87,871084.23],
     321                             [422649.36,871081.85],
     322                             [422649.36,871080.39],
     323                             [422631.86,871079.50],
     324                             [422631.72,871086.75],
     325                             [422636.75,871087.20],
     326                             [422636.75,871091.50],
     327                             [422649.66,871092.09],
     328                             [422649.83,871084.91],
     329                             [422652.94,871084.90],
     330                             [422652.84,871092.39],
     331                             [422681.83,871093.73],
     332                             [422681.61,871117.55]],
     333                       '2': [[422664.22,870785.46],
     334                             [422672.48,870780.14],
     335                             [422668.17,870772.62],
     336                             [422660.35,870777.17],
     337                             [422664.22,870785.46]],
     338                       '3': [[422661.30,871215.06],
     339                             [422667.50,871215.70],
     340                             [422668.30,871204.86],
     341                             [422662.21,871204.33],
     342                             [422661.30,871215.06]],
     343                       '4': [[422473.44,871191.22],
     344                             [422478.33,871192.26],
     345                             [422479.52,871186.03],
     346                             [422474.78,871185.14],
     347                             [422473.44,871191.22]],
     348                       '5': [[422369.69,871049.29],
     349                             [422378.63,871053.58],
     350                             [422383.91,871044.51],
     351                             [422374.97,871040.32],
     352                             [422369.69,871049.29]],
     353                       '8': [[422730.56,871203.13],
     354                             [422734.10,871204.90],
     355                             [422735.26,871202.18],
     356                             [422731.87,871200.58],
     357                             [422730.56,871203.13]],
     358                       '9': [[422659.85,871213.80],
     359                             [422660.91,871210.97],
     360                             [422655.42,871208.85],
     361                             [422654.36,871211.68],
     362                             [422659.85,871213.80]]
     363                       }       
     364       
     365
     366       
     367               
     368        for id in ['1', '2', '3', '4', '5' ,'8' ,'9']:
     369            assert id in polygons.keys()
     370            assert id in values.keys()           
     371
     372            assert int(values[id]) == int(floors[id])
     373            assert len(polygons[id]) == len(known_polys[id])
     374            assert num.allclose(polygons[id], known_polys[id])
     375
     376
     377
     378
     379   
     380    def test_csv2building_polygons(self):
     381        """test_csv2building_polygons
     382        """
     383       
     384        path = get_pathname_from_package('anuga.shallow_water')               
     385        testfile = os.path.join(path, 'polygon_values_example.csv')               
     386
     387        polygons, values = load_csv_as_building_polygons(testfile,
     388                                                 floor_height=3)
     389
     390        assert len(polygons) == 7, 'Must have seven polygons'
     391        assert len(values) == 7, 'Must have seven values'
     392           
     393        # Known floor values
     394        floors = {'1': 6, '2': 0, '3': 3, '4': 6, '5': 0, '8': 3, '9': 3}
     395       
     396               
     397        for id in ['1', '2', '3', '4', '5' ,'8' ,'9']:
     398            assert id in polygons.keys()
     399            assert id in values.keys()           
     400
     401            assert float(values[id]) == float(floors[id])
     402
    222403
    223404
  • trunk/anuga_core/source/anuga/file/test_sww.py

    r7770 r7866  
    251251                assert coordinates2[points2[tuple(coordinates1[coordinate])]][1]==coordinates1[coordinate][1]
    252252
     253
     254    def test_triangulation(self):
     255        #
     256        # 
     257       
     258        filename = tempfile.mktemp("_data_manager.sww")
     259        outfile = NetCDFFile(filename, netcdf_mode_w)
     260        points_utm = num.array([[0.,0.],[1.,1.], [0.,1.]])
     261        volumes = (0,1,2)
     262        elevation = [0,1,2]
     263        new_origin = None
     264        new_origin = Geo_reference(56, 0, 0)
     265        times = [0, 10]
     266        number_of_volumes = len(volumes)
     267        number_of_points = len(points_utm)
     268        sww = Write_sww(['elevation'], ['stage', 'xmomentum', 'ymomentum'])
     269        sww.store_header(outfile, times, number_of_volumes,
     270                         number_of_points, description='fully sick testing',
     271                         verbose=self.verbose,sww_precision=netcdf_float)
     272        sww.store_triangulation(outfile, points_utm, volumes,
     273                                elevation,  new_origin=new_origin,
     274                                verbose=self.verbose)       
     275        outfile.close()
     276        fid = NetCDFFile(filename)
     277
     278        x = fid.variables['x'][:]
     279        y = fid.variables['y'][:]
     280        fid.close()
     281
     282        assert num.allclose(num.array(map(None, x,y)), points_utm)
     283        os.remove(filename)
     284
     285       
     286    def test_triangulationII(self):
     287        #
     288        # 
     289       
     290        filename = tempfile.mktemp("_data_manager.sww")
     291        outfile = NetCDFFile(filename, netcdf_mode_w)
     292        points_utm = num.array([[0.,0.],[1.,1.], [0.,1.]])
     293        volumes = (0,1,2)
     294        elevation = [0,1,2]
     295        new_origin = None
     296        #new_origin = Geo_reference(56, 0, 0)
     297        times = [0, 10]
     298        number_of_volumes = len(volumes)
     299        number_of_points = len(points_utm)
     300        sww = Write_sww(['elevation'], ['stage', 'xmomentum', 'ymomentum'])       
     301        sww.store_header(outfile, times, number_of_volumes,
     302                         number_of_points, description='fully sick testing',
     303                         verbose=self.verbose,sww_precision=netcdf_float)
     304        sww.store_triangulation(outfile, points_utm, volumes,
     305                                new_origin=new_origin,
     306                                verbose=self.verbose)
     307        sww.store_static_quantities(outfile, elevation=elevation)                               
     308                               
     309        outfile.close()
     310        fid = NetCDFFile(filename)
     311
     312        x = fid.variables['x'][:]
     313        y = fid.variables['y'][:]
     314        results_georef = Geo_reference()
     315        results_georef.read_NetCDF(fid)
     316        assert results_georef == Geo_reference(DEFAULT_ZONE, 0, 0)
     317        fid.close()
     318
     319        assert num.allclose(num.array(map(None, x,y)), points_utm)
     320        os.remove(filename)
     321
     322       
     323    def test_triangulation_new_origin(self):
     324        #
     325        # 
     326       
     327        filename = tempfile.mktemp("_data_manager.sww")
     328        outfile = NetCDFFile(filename, netcdf_mode_w)
     329        points_utm = num.array([[0.,0.],[1.,1.], [0.,1.]])
     330        volumes = (0,1,2)
     331        elevation = [0,1,2]
     332        new_origin = None
     333        new_origin = Geo_reference(56, 1, 554354)
     334        points_utm = new_origin.change_points_geo_ref(points_utm)
     335        times = [0, 10]
     336        number_of_volumes = len(volumes)
     337        number_of_points = len(points_utm)
     338        sww = Write_sww(['elevation'], ['stage', 'xmomentum', 'ymomentum'])       
     339        sww.store_header(outfile, times, number_of_volumes,
     340                         number_of_points, description='fully sick testing',
     341                         verbose=self.verbose,sww_precision=netcdf_float)
     342        sww.store_triangulation(outfile, points_utm, volumes,
     343                                elevation,  new_origin=new_origin,
     344                                verbose=self.verbose)
     345        outfile.close()
     346        fid = NetCDFFile(filename)
     347
     348        x = fid.variables['x'][:]
     349        y = fid.variables['y'][:]
     350        results_georef = Geo_reference()
     351        results_georef.read_NetCDF(fid)
     352        assert results_georef == new_origin
     353        fid.close()
     354
     355        absolute = Geo_reference(56, 0,0)
     356        assert num.allclose(num.array(
     357            absolute.change_points_geo_ref(map(None, x,y),
     358                                           new_origin)),points_utm)
     359       
     360        os.remove(filename)
     361       
     362    def test_triangulation_points_georeference(self):
     363        #
     364        # 
     365       
     366        filename = tempfile.mktemp("_data_manager.sww")
     367        outfile = NetCDFFile(filename, netcdf_mode_w)
     368        points_utm = num.array([[0.,0.],[1.,1.], [0.,1.]])
     369        volumes = (0,1,2)
     370        elevation = [0,1,2]
     371        new_origin = None
     372        points_georeference = Geo_reference(56, 1, 554354)
     373        points_utm = points_georeference.change_points_geo_ref(points_utm)
     374        times = [0, 10]
     375        number_of_volumes = len(volumes)
     376        number_of_points = len(points_utm)
     377        sww = Write_sww(['elevation'], ['stage', 'xmomentum', 'ymomentum'])       
     378        sww.store_header(outfile, times, number_of_volumes,
     379                         number_of_points, description='fully sick testing',
     380                         verbose=self.verbose,sww_precision=netcdf_float)
     381        sww.store_triangulation(outfile, points_utm, volumes,
     382                                elevation,  new_origin=new_origin,
     383                                points_georeference=points_georeference,
     384                                verbose=self.verbose)       
     385        outfile.close()
     386        fid = NetCDFFile(filename)
     387
     388        x = fid.variables['x'][:]
     389        y = fid.variables['y'][:]
     390        results_georef = Geo_reference()
     391        results_georef.read_NetCDF(fid)
     392        assert results_georef == points_georeference
     393        fid.close()
     394
     395        assert num.allclose(num.array(map(None, x,y)), points_utm)
     396        os.remove(filename)
     397       
     398    def test_triangulation_2_geo_refs(self):
     399        #
     400        # 
     401       
     402        filename = tempfile.mktemp("_data_manager.sww")
     403        outfile = NetCDFFile(filename, netcdf_mode_w)
     404        points_utm = num.array([[0.,0.],[1.,1.], [0.,1.]])
     405        volumes = (0,1,2)
     406        elevation = [0,1,2]
     407        new_origin = Geo_reference(56, 1, 1)
     408        points_georeference = Geo_reference(56, 0, 0)
     409        points_utm = points_georeference.change_points_geo_ref(points_utm)
     410        times = [0, 10]
     411        number_of_volumes = len(volumes)
     412        number_of_points = len(points_utm)
     413        sww = Write_sww(['elevation'], ['stage', 'xmomentum', 'ymomentum'])       
     414        sww.store_header(outfile, times, number_of_volumes,
     415                         number_of_points, description='fully sick testing',
     416                         verbose=self.verbose,sww_precision=netcdf_float)
     417        sww.store_triangulation(outfile, points_utm, volumes,
     418                                elevation,  new_origin=new_origin,
     419                                points_georeference=points_georeference,
     420                                verbose=self.verbose)       
     421        outfile.close()
     422        fid = NetCDFFile(filename)
     423
     424        x = fid.variables['x'][:]
     425        y = fid.variables['y'][:]
     426        results_georef = Geo_reference()
     427        results_georef.read_NetCDF(fid)
     428        assert results_georef == new_origin
     429        fid.close()
     430
     431
     432        absolute = Geo_reference(56, 0,0)
     433        assert num.allclose(num.array(
     434            absolute.change_points_geo_ref(map(None, x,y),
     435                                           new_origin)),points_utm)
     436        os.remove(filename)
     437
    253438#################################################################################
    254439
Note: See TracChangeset for help on using the changeset viewer.