Ignore:
Timestamp:
Oct 24, 2006, 12:59:08 PM (18 years ago)
Author:
ole
Message:

Refactored references to domain.filename away.
Use

domain.set_name()
domain.get_name()

instead.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • anuga_core/source/anuga/shallow_water/test_data_manager.py

    r3820 r3846  
    162162        from Scientific.IO.NetCDF import NetCDFFile
    163163
    164         self.domain.filename = 'datatest' + str(id(self))
    165         self.domain.format = 'sww'
     164        self.domain.set_name('datatest' + str(id(self)))
     165        self.domain.format = 'sww' #Remove??
    166166        self.domain.smooth = False
    167167
    … …  
    209209        from Scientific.IO.NetCDF import NetCDFFile
    210210
    211         self.domain.filename = 'datatest' + str(id(self))
     211        self.domain.set_name('datatest' + str(id(self)))
    212212        self.domain.format = 'sww'
    213213        self.domain.smooth = True
    … …  
    266266        from Scientific.IO.NetCDF import NetCDFFile
    267267
    268         self.domain.filename = 'datatest' + str(id(self))
     268        self.domain.set_name('datatest' + str(id(self)))
    269269        self.domain.format = 'sww'
    270270        self.domain.smooth = True
    … …  
    321321        from Scientific.IO.NetCDF import NetCDFFile
    322322
    323         self.domain.filename = 'datatest' + str(id(self))
     323        self.domain.set_name('datatest' + str(id(self)))
    324324        self.domain.format = 'sww'
    325325        self.domain.smooth = True
    … …  
    376376        from Scientific.IO.NetCDF import NetCDFFile
    377377
    378         self.domain.filename = 'datatest' + str(id(self))
     378        self.domain.set_name('datatest' + str(id(self)))
    379379        self.domain.format = 'sww'
    380380        self.domain.smooth = True
    … …  
    432432        from Scientific.IO.NetCDF import NetCDFFile
    433433
    434         self.domain.filename = 'synctest'
     434        self.domain.set_name('synctest')
    435435        self.domain.format = 'sww'
    436436        self.domain.smooth = False
    … …  
    467467        from Scientific.IO.NetCDF import NetCDFFile
    468468
    469         self.domain.filename = 'datatest' + str(id(self))
     469        self.domain.set_name('datatest' + str(id(self)))
    470470        self.domain.format = 'sww'
    471471        self.domain.smooth = True
    … …  
    515515        from Scientific.IO.NetCDF import NetCDFFile
    516516
    517         self.domain.filename = 'datatest' + str(id(self))
     517        self.domain.set_name('datatest' + str(id(self)))
    518518        self.domain.format = 'sww'
    519519        self.domain.smooth = True
    … …  
    11361136
    11371137        #Setup
    1138         self.domain.filename = 'datatest'
    1139 
    1140         prjfile = self.domain.filename + '_elevation.prj'
    1141         ascfile = self.domain.filename + '_elevation.asc'
    1142         swwfile = self.domain.filename + '.sww'
     1138        self.domain.set_name('datatest')
     1139
     1140        prjfile = self.domain.get_name() + '_elevation.prj'
     1141        ascfile = self.domain.get_name() + '_elevation.asc'
     1142        swwfile = self.domain.get_name() + '.sww'
    11431143
    11441144        self.domain.set_datadir('.')
    … …  
    11711171
    11721172        #Export to ascii/prj files
    1173         sww2dem(self.domain.filename,
     1173        sww2dem(self.domain.get_name(),
    11741174                quantity = 'elevation',
    11751175                cellsize = cellsize,
    … …  
    13031303        domain.default_order = 2
    13041304
    1305         domain.filename = 'datatest'
    1306 
    1307         prjfile = domain.filename + '_elevation.prj'
    1308         ascfile = domain.filename + '_elevation.asc'
    1309         swwfile = domain.filename + '.sww'
     1305        domain.set_name('datatest')
     1306
     1307        prjfile = domain.get_name() + '_elevation.prj'
     1308        ascfile = domain.get_name() + '_elevation.asc'
     1309        swwfile = domain.get_name() + '.sww'
    13101310
    13111311        domain.set_datadir('.')
    … …  
    13471347
    13481348        #Export to ascii/prj files
    1349         sww2dem(domain.filename,
     1349        sww2dem(domain.get_name(),
    13501350                quantity = 'elevation',
    13511351                cellsize = cellsize,
    … …  
    14871487        domain.default_order = 2
    14881488
    1489         domain.filename = 'datatest'
    1490 
    1491         prjfile = domain.filename + '_elevation.prj'
    1492         ascfile = domain.filename + '_elevation.asc'
    1493         swwfile = domain.filename + '.sww'
     1489        domain.set_name('datatest')
     1490
     1491        prjfile = domain.get_name() + '_elevation.prj'
     1492        ascfile = domain.get_name() + '_elevation.asc'
     1493        swwfile = domain.get_name() + '.sww'
    14941494
    14951495        domain.set_datadir('.')
    … …  
    15311531
    15321532        #Export to ascii/prj files
    1533         sww2dem(domain.filename,
     1533        sww2dem(domain.get_name(),
    15341534                quantity = 'elevation',
    15351535                cellsize = cellsize,
    … …  
    16411641
    16421642        #Setup
    1643         self.domain.filename = 'datatest'
    1644 
    1645         prjfile = self.domain.filename + '_stage.prj'
    1646         ascfile = self.domain.filename + '_stage.asc'
    1647         swwfile = self.domain.filename + '.sww'
     1643        self.domain.set_name('datatest')
     1644
     1645        prjfile = self.domain.get_name() + '_stage.prj'
     1646        ascfile = self.domain.get_name() + '_stage.asc'
     1647        swwfile = self.domain.get_name() + '.sww'
    16481648
    16491649        self.domain.set_datadir('.')
    … …  
    16771677
    16781678        #Export to ascii/prj files
    1679         sww2dem(self.domain.filename,
     1679        sww2dem(self.domain.get_name(),
    16801680                quantity = 'stage',
    16811681                cellsize = cellsize,
    16821682                reduction = min,
    1683                 format = 'asc')
     1683                format = 'asc')
    16841684
    16851685
    … …  
    17501750
    17511751        #Setup
    1752         self.domain.filename = 'datatest'
    1753 
    1754         prjfile = self.domain.filename + '_depth.prj'
    1755         ascfile = self.domain.filename + '_depth.asc'
    1756         swwfile = self.domain.filename + '.sww'
     1752        self.domain.set_name('datatest')
     1753
     1754        prjfile = self.domain.get_name() + '_depth.prj'
     1755        ascfile = self.domain.get_name() + '_depth.asc'
     1756        swwfile = self.domain.get_name() + '.sww'
    17571757
    17581758        self.domain.set_datadir('.')
    … …  
    17871787
    17881788        #Export to ascii/prj files
    1789         sww2dem(self.domain.filename,
     1789        sww2dem(self.domain.get_name(),
    17901790                basename_out = 'datatest_depth',
    17911791                quantity = 'stage - elevation',
    17921792                cellsize = cellsize,
    17931793                reduction = min,
    1794                 format = 'asc',
     1794                format = 'asc',
    17951795                verbose = False)
    17961796
    … …  
    19051905        domain.distribute_to_vertices_and_edges()
    19061906
    1907         domain.filename = 'datatest'
    1908 
    1909         prjfile = domain.filename + '_elevation.prj'
    1910         ascfile = domain.filename + '_elevation.asc'
    1911         swwfile = domain.filename + '.sww'
     1907        domain.set_name('datatest')
     1908
     1909        prjfile = domain.get_name() + '_elevation.prj'
     1910        ascfile = domain.get_name() + '_elevation.asc'
     1911        swwfile = domain.get_name() + '.sww'
    19121912
    19131913        domain.set_datadir('.')
    … …  
    19391939
    19401940        #Export to ascii/prj files
    1941         sww2dem(domain.filename,
     1941        sww2dem(domain.get_name(),
    19421942                quantity = 'elevation',
    19431943                cellsize = cellsize,
    19441944                verbose = False,
    1945                 format = 'asc')
     1945                format = 'asc')
    19461946
    19471947
    … …  
    20112011
    20122012        #Setup
    2013         self.domain.filename = 'datatest'
    2014 
    2015         headerfile = self.domain.filename + '.ers'
    2016         swwfile = self.domain.filename + '.sww'
     2013        self.domain.set_name('datatest')
     2014
     2015        headerfile = self.domain.get_name() + '.ers'
     2016        swwfile = self.domain.get_name() + '.sww'
    20172017
    20182018        self.domain.set_datadir('.')
    … …  
    20452045
    20462046        #Export to ers files
    2047         sww2dem(self.domain.filename,
     2047        sww2dem(self.domain.get_name(),
    20482048                quantity = 'elevation',
    20492049                cellsize = cellsize,
    20502050                NODATA_value = NODATA_value,
    20512051                verbose = False,
    2052                 format = 'ers')
     2052                format = 'ers')
    20532053
    20542054        #Check header data
    2055         from ermapper_grids import read_ermapper_header, read_ermapper_data
    2056 
    2057         header = read_ermapper_header(self.domain.filename + '_elevation.ers')
     2055        from ermapper_grids import read_ermapper_header, read_ermapper_data
     2056
     2057        header = read_ermapper_header(self.domain.get_name() + '_elevation.ers')
    20582058        #print header
    20592059        assert header['projection'].lower() == '"utm-56"'
    … …  
    20682068        assert int(header['nrofcellsperline']) == 5
    20692069        assert int(header['nullcellvalue']) == NODATA_value
    2070         #FIXME - there is more in the header
     2070        #FIXME - there is more in the header
    20712071
    20722072
    20732073        #Check grid data
    2074         grid = read_ermapper_data(self.domain.filename + '_elevation')
    2075 
    2076         #FIXME (Ole): Why is this the desired reference grid for -x-y?
    2077         ref_grid = [NODATA_value, NODATA_value, NODATA_value, NODATA_value, NODATA_value,
    2078                     -1,    -1.25, -1.5,  -1.75, -2.0,
    2079                     -0.75, -1.0,  -1.25, -1.5,  -1.75,
    2080                     -0.5,  -0.75, -1.0,  -1.25, -1.5,
    2081                     -0.25, -0.5,  -0.75, -1.0,  -1.25]
     2074        grid = read_ermapper_data(self.domain.get_name() + '_elevation')
     2075
     2076        #FIXME (Ole): Why is this the desired reference grid for -x-y?
     2077        ref_grid = [NODATA_value, NODATA_value, NODATA_value, NODATA_value, NODATA_value,
     2078                    -1,    -1.25, -1.5,  -1.75, -2.0,
     2079                    -0.75, -1.0,  -1.25, -1.5,  -1.75,
     2080                    -0.5,  -0.75, -1.0,  -1.25, -1.5,
     2081                    -0.25, -0.5,  -0.75, -1.0,  -1.25]
    20822082
    20832083
    20842084        #print grid
    2085         assert allclose(grid, ref_grid)
     2085        assert allclose(grid, ref_grid)
    20862086
    20872087        fid.close()
    … …  
    20912091        #Done (Ole) - it was because sww2ers didn't close it's sww file
    20922092        os.remove(sww.filename)
    2093         os.remove(self.domain.filename + '_elevation')
    2094         os.remove(self.domain.filename + '_elevation.ers')
     2093        os.remove(self.domain.get_name() + '_elevation')
     2094        os.remove(self.domain.get_name() + '_elevation.ers')
    20952095
    20962096
    … …  
    21102110
    21112111        # Setup
    2112         self.domain.filename = 'datatest'
    2113 
    2114         ptsfile = self.domain.filename + '_elevation.pts'
    2115         swwfile = self.domain.filename + '.sww'
     2112        self.domain.set_name('datatest')
     2113
     2114        ptsfile = self.domain.get_name() + '_elevation.pts'
     2115        swwfile = self.domain.get_name() + '.sww'
    21162116
    21172117        self.domain.set_datadir('.')
    … …  
    21442144        # Invoke interpolation for vertex points       
    21452145        points = concatenate( (x[:,NewAxis],y[:,NewAxis]), axis=1 )
    2146         sww2pts(self.domain.filename,
     2146        sww2pts(self.domain.get_name(),
    21472147                quantity = 'elevation',
    21482148                data_points = points,
    … …  
    21532153        #print 'P', point_values
    21542154        #print 'Ref', ref_point_values       
    2155         assert allclose(point_values, ref_point_values)       
     2155        assert allclose(point_values, ref_point_values)       
    21562156
    21572157
    … …  
    21602160        points = self.domain.get_centroid_coordinates()
    21612161        #print points
    2162         sww2pts(self.domain.filename,
     2162        sww2pts(self.domain.get_name(),
    21632163                quantity = 'elevation',
    21642164                data_points = points,
    … …  
    21712171        #print 'P', point_values
    21722172        #print 'Ref', ref_point_values       
    2173         assert allclose(point_values, ref_point_values)       
     2173        assert allclose(point_values, ref_point_values)       
    21742174
    21752175
    … …  
    22332233        #Check first value
    22342234        stage = fid.variables['stage'][:]
    2235         xmomentum = fid.variables['xmomentum'][:]
    2236         ymomentum = fid.variables['ymomentum'][:]
    2237 
    2238         #print ymomentum
     2235        xmomentum = fid.variables['xmomentum'][:]
     2236        ymomentum = fid.variables['ymomentum'][:]
     2237
     2238        #print ymomentum
    22392239
    22402240        assert allclose(stage[0,0], first_value/100)  #Meters
    … …  
    23512351
    23522352        for fid in [fid1,fid2,fid3]:
    2353             fid.createDimension(long_name,nx)
    2354             fid.createVariable(long_name,'d',(long_name,))
    2355             fid.variables[long_name].point_spacing='uneven'
    2356             fid.variables[long_name].units='degrees_east'
    2357             fid.variables[long_name].assignValue(h1_list)
    2358 
    2359             fid.createDimension(lat_name,ny)
    2360             fid.createVariable(lat_name,'d',(lat_name,))
    2361             fid.variables[lat_name].point_spacing='uneven'
    2362             fid.variables[lat_name].units='degrees_north'
    2363             fid.variables[lat_name].assignValue(h2_list)
    2364 
    2365             fid.createDimension(time_name,2)
    2366             fid.createVariable(time_name,'d',(time_name,))
    2367             fid.variables[time_name].point_spacing='uneven'
    2368             fid.variables[time_name].units='seconds'
    2369             fid.variables[time_name].assignValue([0.,1.])
    2370             if fid == fid3: break
     2353            fid.createDimension(long_name,nx)
     2354            fid.createVariable(long_name,'d',(long_name,))
     2355            fid.variables[long_name].point_spacing='uneven'
     2356            fid.variables[long_name].units='degrees_east'
     2357            fid.variables[long_name].assignValue(h1_list)
     2358
     2359            fid.createDimension(lat_name,ny)
     2360            fid.createVariable(lat_name,'d',(lat_name,))
     2361            fid.variables[lat_name].point_spacing='uneven'
     2362            fid.variables[lat_name].units='degrees_north'
     2363            fid.variables[lat_name].assignValue(h2_list)
     2364
     2365            fid.createDimension(time_name,2)
     2366            fid.createVariable(time_name,'d',(time_name,))
     2367            fid.variables[time_name].point_spacing='uneven'
     2368            fid.variables[time_name].units='seconds'
     2369            fid.variables[time_name].assignValue([0.,1.])
     2370            if fid == fid3: break
    23712371
    23722372
    23732373        for fid in [fid4]:
    2374             fid.createDimension(long_name,nx)
    2375             fid.createVariable(long_name,'d',(long_name,))
    2376             fid.variables[long_name].point_spacing='uneven'
    2377             fid.variables[long_name].units='degrees_east'
    2378             fid.variables[long_name].assignValue(h1_list)
    2379 
    2380             fid.createDimension(lat_name,ny)
    2381             fid.createVariable(lat_name,'d',(lat_name,))
    2382             fid.variables[lat_name].point_spacing='uneven'
    2383             fid.variables[lat_name].units='degrees_north'
    2384             fid.variables[lat_name].assignValue(h2_list)
     2374            fid.createDimension(long_name,nx)
     2375            fid.createVariable(long_name,'d',(long_name,))
     2376            fid.variables[long_name].point_spacing='uneven'
     2377            fid.variables[long_name].units='degrees_east'
     2378            fid.variables[long_name].assignValue(h1_list)
     2379
     2380            fid.createDimension(lat_name,ny)
     2381            fid.createVariable(lat_name,'d',(lat_name,))
     2382            fid.variables[lat_name].point_spacing='uneven'
     2383            fid.variables[lat_name].units='degrees_north'
     2384            fid.variables[lat_name].assignValue(h2_list)
    23852385
    23862386        name = {}
    … …  
    25152515
    25162516        for fid in [fid1,fid2,fid3]:
    2517             fid.createDimension(long_name,nx)
    2518             fid.createVariable(long_name,'d',(long_name,))
    2519             fid.variables[long_name].point_spacing='uneven'
    2520             fid.variables[long_name].units='degrees_east'
    2521             fid.variables[long_name].assignValue(h1_list)
    2522 
    2523             fid.createDimension(lat_name,ny)
    2524             fid.createVariable(lat_name,'d',(lat_name,))
    2525             fid.variables[lat_name].point_spacing='uneven'
    2526             fid.variables[lat_name].units='degrees_north'
    2527             fid.variables[lat_name].assignValue(h2_list)
    2528 
    2529             fid.createDimension(time_name,2)
    2530             fid.createVariable(time_name,'d',(time_name,))
    2531             fid.variables[time_name].point_spacing='uneven'
    2532             fid.variables[time_name].units='seconds'
    2533             fid.variables[time_name].assignValue([0.,1.])
    2534             if fid == fid3: break
     2517            fid.createDimension(long_name,nx)
     2518            fid.createVariable(long_name,'d',(long_name,))
     2519            fid.variables[long_name].point_spacing='uneven'
     2520            fid.variables[long_name].units='degrees_east'
     2521            fid.variables[long_name].assignValue(h1_list)
     2522
     2523            fid.createDimension(lat_name,ny)
     2524            fid.createVariable(lat_name,'d',(lat_name,))
     2525            fid.variables[lat_name].point_spacing='uneven'
     2526            fid.variables[lat_name].units='degrees_north'
     2527            fid.variables[lat_name].assignValue(h2_list)
     2528
     2529            fid.createDimension(time_name,2)
     2530            fid.createVariable(time_name,'d',(time_name,))
     2531            fid.variables[time_name].point_spacing='uneven'
     2532            fid.variables[time_name].units='seconds'
     2533            fid.variables[time_name].assignValue([0.,1.])
     2534            if fid == fid3: break
    25352535
    25362536
    25372537        for fid in [fid4]:
    2538             fid.createDimension(long_name,nx)
    2539             fid.createVariable(long_name,'d',(long_name,))
    2540             fid.variables[long_name].point_spacing='uneven'
    2541             fid.variables[long_name].units='degrees_east'
    2542             fid.variables[long_name].assignValue(h1_list)
    2543 
    2544             fid.createDimension(lat_name,ny)
    2545             fid.createVariable(lat_name,'d',(lat_name,))
    2546             fid.variables[lat_name].point_spacing='uneven'
    2547             fid.variables[lat_name].units='degrees_north'
    2548             fid.variables[lat_name].assignValue(h2_list)
     2538            fid.createDimension(long_name,nx)
     2539            fid.createVariable(long_name,'d',(long_name,))
     2540            fid.variables[long_name].point_spacing='uneven'
     2541            fid.variables[long_name].units='degrees_east'
     2542            fid.variables[long_name].assignValue(h1_list)
     2543
     2544            fid.createDimension(lat_name,ny)
     2545            fid.createVariable(lat_name,'d',(lat_name,))
     2546            fid.variables[lat_name].point_spacing='uneven'
     2547            fid.variables[lat_name].units='degrees_north'
     2548            fid.variables[lat_name].assignValue(h2_list)
    25492549
    25502550        name = {}
    … …  
    25752575
    25762576        for fid in [fid4]:
    2577             fid.createVariable(name[fid],'d',(lat_name,long_name))
     2577            fid.createVariable(name[fid],'d',(lat_name,long_name))
    25782578            fid.variables[name[fid]].point_spacing='uneven'
    25792579            fid.variables[name[fid]].units=units[fid]
    … …  
    26772677        from Scientific.IO.NetCDF import NetCDFFile
    26782678
    2679         self.domain.filename = 'datatest' + str(id(self))
     2679        self.domain.set_name('datatest' + str(id(self)))
    26802680        self.domain.format = 'sww'
    26812681        self.domain.smooth = True
    … …  
    26952695        sww.store_timestep('stage')
    26962696
    2697         file_and_extension_name = self.domain.filename + ".sww"
     2697        file_and_extension_name = self.domain.get_name() + ".sww"
    26982698        #print "file_and_extension_name",file_and_extension_name
    26992699        [xmin, xmax, ymin, ymax, stagemin, stagemax] = \
    … …  
    27312731        domain.visualise = False
    27322732        domain.store = True
    2733         domain.filename = 'bedslope'
     2733        domain.set_name('bedslope')
    27342734        domain.default_order=2
    27352735        #Bed-slope and friction
    … …  
    27662766        import os
    27672767
    2768         filename = domain.datadir+os.sep+domain.filename+'.sww'
     2768        filename = domain.datadir + os.sep + domain.get_name() + '.sww'
    27692769        domain2 = sww2domain(filename,None,fail_if_NaN=False,verbose = False)
    27702770        #points, vertices, boundary = rectangular(15,15)
    … …  
    27742774        ###################
    27752775
    2776         #os.remove(domain.filename + '.sww')
     2776        #os.remove(domain.get_name() + '.sww')
    27772777        os.remove(filename)
    27782778
    … …  
    28562856
    28572857    def test_sww2domain2(self):
    2858         ##################################################################
    2859         #Same as previous test, but this checks how NaNs are handled.
    2860         ##################################################################
    2861 
    2862 
    2863         from mesh_factory import rectangular
    2864         from Numeric import array
    2865 
    2866         #Create basic mesh
    2867         points, vertices, boundary = rectangular(2,2)
    2868 
    2869         #Create shallow water domain
    2870         domain = Domain(points, vertices, boundary)
    2871         domain.smooth = False
    2872         domain.visualise = False
    2873         domain.store = True
    2874         domain.set_name('test_file')
     2858        ##################################################################
     2859        #Same as previous test, but this checks how NaNs are handled.
     2860        ##################################################################
     2861
     2862
     2863        from mesh_factory import rectangular
     2864        from Numeric import array
     2865
     2866        #Create basic mesh
     2867        points, vertices, boundary = rectangular(2,2)
     2868
     2869        #Create shallow water domain
     2870        domain = Domain(points, vertices, boundary)
     2871        domain.smooth = False
     2872        domain.visualise = False
     2873        domain.store = True
     2874        domain.set_name('test_file')
    28752875        domain.set_datadir('.')
    2876         domain.default_order=2
    2877         domain.quantities_to_be_stored=['stage']
    2878 
    2879         domain.set_quantity('elevation', lambda x,y: -x/3)
    2880         domain.set_quantity('friction', 0.1)
    2881 
    2882         from math import sin, pi
    2883         Br = Reflective_boundary(domain)
    2884         Bt = Transmissive_boundary(domain)
    2885         Bd = Dirichlet_boundary([0.2,0.,0.])
    2886         Bw = Time_boundary(domain=domain,
    2887                            f=lambda t: [(0.1*sin(t*2*pi)), 0.0, 0.0])
    2888 
    2889         domain.set_boundary({'left': Bd, 'right': Br, 'top': Br, 'bottom': Br})
    2890 
    2891         h = 0.05
    2892         elevation = domain.quantities['elevation'].vertex_values
    2893         domain.set_quantity('stage', elevation + h)
    2894 
    2895         domain.check_integrity()
    2896 
    2897         for t in domain.evolve(yieldstep = 1, finaltime = 2.0):
    2898             pass
    2899             #domain.write_time()
     2876        domain.default_order=2
     2877        domain.quantities_to_be_stored=['stage']
     2878
     2879        domain.set_quantity('elevation', lambda x,y: -x/3)
     2880        domain.set_quantity('friction', 0.1)
     2881
     2882        from math import sin, pi
     2883        Br = Reflective_boundary(domain)
     2884        Bt = Transmissive_boundary(domain)
     2885        Bd = Dirichlet_boundary([0.2,0.,0.])
     2886        Bw = Time_boundary(domain=domain,
     2887                           f=lambda t: [(0.1*sin(t*2*pi)), 0.0, 0.0])
     2888
     2889        domain.set_boundary({'left': Bd, 'right': Br, 'top': Br, 'bottom': Br})
     2890
     2891        h = 0.05
     2892        elevation = domain.quantities['elevation'].vertex_values
     2893        domain.set_quantity('stage', elevation + h)
     2894
     2895        domain.check_integrity()
     2896
     2897        for t in domain.evolve(yieldstep = 1, finaltime = 2.0):
     2898            pass
     2899            #domain.write_time()
    29002900
    29012901
    29022902
    29032903        ##################################
    2904         #Import the file as a new domain
     2904        #Import the file as a new domain
    29052905        ##################################
    2906         from data_manager import sww2domain
    2907         from Numeric import allclose
     2906        from data_manager import sww2domain
     2907        from Numeric import allclose
    29082908        import os
    29092909
    2910         filename = domain.datadir+os.sep+domain.filename+'.sww'
    2911 
    2912         #Fail because NaNs are present
    2913         try:
    2914             domain2 = sww2domain(filename,boundary,fail_if_NaN=True,verbose=False)
    2915         except:
    2916             #Now import it, filling NaNs to be 0
    2917             filler = 0
    2918             domain2 = sww2domain(filename,None,fail_if_NaN=False,NaN_filler = filler,verbose=False)
     2910        filename = domain.datadir + os.sep + domain.get_name() + '.sww'
     2911
     2912        #Fail because NaNs are present
     2913        try:
     2914            domain2 = sww2domain(filename,boundary,fail_if_NaN=True,verbose=False)
     2915        except:
     2916            #Now import it, filling NaNs to be 0
     2917            filler = 0
     2918            domain2 = sww2domain(filename,None,fail_if_NaN=False,NaN_filler = filler,verbose=False)
    29192919
    29202920        #Clean up
    … …  
    29262926                'vertex_coordinates']
    29272927
    2928         for quantity in ['elevation']+domain.quantities_to_be_stored:
    2929             bits.append('get_quantity("%s").get_integral()' %quantity)
    2930             bits.append('get_quantity("%s").get_values()' %quantity)
    2931 
    2932         for bit in bits:
    2933         #    print 'testing that domain.'+bit+' has been restored'
    2934             assert allclose(eval('domain.'+bit),eval('domain2.'+bit))
    2935 
    2936         assert max(max(domain2.get_quantity('xmomentum').get_values()))==filler
    2937         assert min(min(domain2.get_quantity('xmomentum').get_values()))==filler
    2938         assert max(max(domain2.get_quantity('ymomentum').get_values()))==filler
    2939         assert min(min(domain2.get_quantity('ymomentum').get_values()))==filler
     2928        for quantity in ['elevation']+domain.quantities_to_be_stored:
     2929            bits.append('get_quantity("%s").get_integral()' %quantity)
     2930            bits.append('get_quantity("%s").get_values()' %quantity)
     2931
     2932        for bit in bits:
     2933        #    print 'testing that domain.'+bit+' has been restored'
     2934            assert allclose(eval('domain.'+bit),eval('domain2.'+bit))
     2935
     2936        assert max(max(domain2.get_quantity('xmomentum').get_values()))==filler
     2937        assert min(min(domain2.get_quantity('xmomentum').get_values()))==filler
     2938        assert max(max(domain2.get_quantity('ymomentum').get_values()))==filler
     2939        assert min(min(domain2.get_quantity('ymomentum').get_values()))==filler
    29402940
    29412941
    29422942
    29432943    #def test_weed(self):
    2944         from data_manager import weed
     2944        from data_manager import weed
    29452945
    29462946        coordinates1 = [[0.,0.],[1.,0.],[1.,1.],[1.,0.],[2.,0.],[1.,1.]]
    … …  
    29652965    #FIXME This fails - smooth makes the comparism too hard for allclose
    29662966    def ztest_sww2domain3(self):
    2967         ################################################
    2968         #DOMAIN.SMOOTH = TRUE !!!!!!!!!!!!!!!!!!!!!!!!!!
    2969         ################################################
    2970         from mesh_factory import rectangular
    2971         from Numeric import array
    2972         #Create basic mesh
     2967        ################################################
     2968        #DOMAIN.SMOOTH = TRUE !!!!!!!!!!!!!!!!!!!!!!!!!!
     2969        ################################################
     2970        from mesh_factory import rectangular
     2971        from Numeric import array
     2972        #Create basic mesh
    29732973
    29742974        yiel=0.01
    2975         points, vertices, boundary = rectangular(10,10)
    2976 
    2977         #Create shallow water domain
    2978         domain = Domain(points, vertices, boundary)
     2975        points, vertices, boundary = rectangular(10,10)
     2976
     2977        #Create shallow water domain
     2978        domain = Domain(points, vertices, boundary)
    29792979        domain.geo_reference = Geo_reference(56,11,11)
    2980         domain.smooth = True
    2981         domain.visualise = False
    2982         domain.store = True
    2983         domain.filename = 'bedslope'
    2984         domain.default_order=2
    2985         #Bed-slope and friction
    2986         domain.set_quantity('elevation', lambda x,y: -x/3)
    2987         domain.set_quantity('friction', 0.1)
    2988         # Boundary conditions
    2989         from math import sin, pi
    2990         Br = Reflective_boundary(domain)
    2991         Bt = Transmissive_boundary(domain)
    2992         Bd = Dirichlet_boundary([0.2,0.,0.])
    2993         Bw = Time_boundary(domain=domain,
    2994                            f=lambda t: [(0.1*sin(t*2*pi)), 0.0, 0.0])
    2995 
    2996         domain.set_boundary({'left': Bd, 'right': Bd, 'top': Bd, 'bottom': Bd})
    2997 
    2998         domain.quantities_to_be_stored.extend(['xmomentum','ymomentum'])
    2999         #Initial condition
    3000         h = 0.05
    3001         elevation = domain.quantities['elevation'].vertex_values
    3002         domain.set_quantity('stage', elevation + h)
    3003 
    3004 
    3005         domain.check_integrity()
    3006         #Evolution
    3007         for t in domain.evolve(yieldstep = yiel, finaltime = 0.05):
    3008         #    domain.write_time()
    3009             pass
    3010 
    3011 
    3012         ##########################################
    3013         #Import the example's file as a new domain
    3014         ##########################################
    3015         from data_manager import sww2domain
    3016         from Numeric import allclose
     2980        domain.smooth = True
     2981        domain.visualise = False
     2982        domain.store = True
     2983        domain.set_name('bedslope')
     2984        domain.default_order=2
     2985        #Bed-slope and friction
     2986        domain.set_quantity('elevation', lambda x,y: -x/3)
     2987        domain.set_quantity('friction', 0.1)
     2988        # Boundary conditions
     2989        from math import sin, pi
     2990        Br = Reflective_boundary(domain)
     2991        Bt = Transmissive_boundary(domain)
     2992        Bd = Dirichlet_boundary([0.2,0.,0.])
     2993        Bw = Time_boundary(domain=domain,
     2994                           f=lambda t: [(0.1*sin(t*2*pi)), 0.0, 0.0])
     2995
     2996        domain.set_boundary({'left': Bd, 'right': Bd, 'top': Bd, 'bottom': Bd})
     2997
     2998        domain.quantities_to_be_stored.extend(['xmomentum','ymomentum'])
     2999        #Initial condition
     3000        h = 0.05
     3001        elevation = domain.quantities['elevation'].vertex_values
     3002        domain.set_quantity('stage', elevation + h)
     3003
     3004
     3005        domain.check_integrity()
     3006        #Evolution
     3007        for t in domain.evolve(yieldstep = yiel, finaltime = 0.05):
     3008        #    domain.write_time()
     3009            pass
     3010
     3011
     3012        ##########################################
     3013        #Import the example's file as a new domain
     3014        ##########################################
     3015        from data_manager import sww2domain
     3016        from Numeric import allclose
    30173017        import os
    30183018
    3019         filename = domain.datadir+os.sep+domain.filename+'.sww'
    3020         domain2 = sww2domain(filename,None,fail_if_NaN=False,verbose = False)
    3021         #points, vertices, boundary = rectangular(15,15)
     3019        filename = domain.datadir + os.sep + domain.get_name() + '.sww'
     3020        domain2 = sww2domain(filename,None,fail_if_NaN=False,verbose = False)
     3021        #points, vertices, boundary = rectangular(15,15)
    30223022        #domain2.boundary = boundary
    30233023        ###################
    3024         ##NOW TEST IT!!!
     3024        ##NOW TEST IT!!!
    30253025        ###################
    30263026
    3027         os.remove(domain.filename + '.sww')
     3027        os.remove(domain.get_name() + '.sww')
    30283028
    30293029        #FIXME smooth domain so that they can be compared
    30303030
    30313031
    3032         bits = []#'vertex_coordinates']
    3033         for quantity in ['elevation']+domain.quantities_to_be_stored:
    3034             bits.append('quantities["%s"].get_integral()'%quantity)
    3035 
    3036 
    3037         for bit in bits:
    3038             #print 'testing that domain.'+bit+' has been restored'
     3032        bits = []#'vertex_coordinates']
     3033        for quantity in ['elevation']+domain.quantities_to_be_stored:
     3034            bits.append('quantities["%s"].get_integral()'%quantity)
     3035
     3036
     3037        for bit in bits:
     3038            #print 'testing that domain.'+bit+' has been restored'
    30393039            #print bit
    30403040            #print 'done'
    30413041            #print ('domain.'+bit), eval('domain.'+bit)
    30423042            #print ('domain2.'+bit), eval('domain2.'+bit)
    3043             assert allclose(eval('domain.'+bit),eval('domain2.'+bit),rtol=1.0e-1,atol=1.e-3)
     3043            assert allclose(eval('domain.'+bit),eval('domain2.'+bit),rtol=1.0e-1,atol=1.e-3)
    30443044            pass
    30453045
    … …  
    30493049        visualise = False
    30503050        visualise = True
    3051         domain.visualise = visualise
     3051        domain.visualise = visualise
    30523052        domain.time = 0.
    30533053        from time import sleep
    … …  
    30553055        final = .5
    30563056        domain.set_quantity('friction', 0.1)
    3057         domain.store = False
    3058         domain.set_boundary({'left': Bd, 'right': Bd, 'top': Bd, 'bottom': Br})
    3059 
    3060         for t in domain.evolve(yieldstep = yiel, finaltime = final):
     3057        domain.store = False
     3058        domain.set_boundary({'left': Bd, 'right': Bd, 'top': Bd, 'bottom': Br})
     3059
     3060        for t in domain.evolve(yieldstep = yiel, finaltime = final):
    30613061            if visualise: sleep(.03)
    3062             #domain.write_time()
    3063             pass
    3064 
    3065         domain2.smooth = True
    3066         domain2.visualise = visualise
    3067         domain2.store = False
    3068         domain2.default_order=2
    3069         domain2.set_quantity('friction', 0.1)
    3070         #Bed-slope and friction
    3071         # Boundary conditions
     3062            #domain.write_time()
     3063            pass
     3064
     3065        domain2.smooth = True
     3066        domain2.visualise = visualise
     3067        domain2.store = False
     3068        domain2.default_order=2
     3069        domain2.set_quantity('friction', 0.1)
     3070        #Bed-slope and friction
     3071        # Boundary conditions
    30723072        Bd2=Dirichlet_boundary([0.2,0.,0.])
    3073         Br2 = Reflective_boundary(domain2)
     3073        Br2 = Reflective_boundary(domain2)
    30743074        domain2.boundary = domain.boundary
    30753075        #print 'domain2.boundary'
    30763076        #print domain2.boundary
    3077         domain2.set_boundary({'left': Bd2, 'right': Bd2, 'top': Bd2, 'bottom': Br2})
     3077        domain2.set_boundary({'left': Bd2, 'right': Bd2, 'top': Bd2, 'bottom': Br2})
    30783078        #domain2.boundary = domain.boundary
    3079         #domain2.set_boundary({'exterior': Bd})
    3080 
    3081         domain2.check_integrity()
    3082 
    3083         for t in domain2.evolve(yieldstep = yiel, finaltime = final):
     3079        #domain2.set_boundary({'exterior': Bd})
     3080
     3081        domain2.check_integrity()
     3082
     3083        for t in domain2.evolve(yieldstep = yiel, finaltime = final):
    30843084            if visualise: sleep(.03)
    3085             #domain2.write_time()
    3086             pass
     3085            #domain2.write_time()
     3086            pass
    30873087
    30883088        ###################
    3089         ##NOW TEST IT!!!
     3089        ##NOW TEST IT!!!
    30903090        ##################
    30913091
    30923092        print '><><><><>>'
    3093         bits = [ 'vertex_coordinates']
    3094 
    3095         for quantity in ['elevation','xmomentum','ymomentum']:#+domain.quantities_to_be_stored:
    3096             #bits.append('quantities["%s"].get_integral()'%quantity)
    3097             bits.append('get_quantity("%s").get_values()' %quantity)
    3098 
    3099         for bit in bits:
     3093        bits = [ 'vertex_coordinates']
     3094
     3095        for quantity in ['elevation','xmomentum','ymomentum']:#+domain.quantities_to_be_stored:
     3096            #bits.append('quantities["%s"].get_integral()'%quantity)
     3097            bits.append('get_quantity("%s").get_values()' %quantity)
     3098
     3099        for bit in bits:
    31003100            print bit
    3101             assert allclose(eval('domain.'+bit),eval('domain2.'+bit))
     3101            assert allclose(eval('domain.'+bit),eval('domain2.'+bit))
    31023102
    31033103
    … …  
    32893289        from Scientific.IO.NetCDF import NetCDFFile
    32903290
    3291         # the memory optimised least squares
    3292         #  cellsize = 20,   # this one seems to hang
    3293         #  cellsize = 200000, # Ran 1 test in 269.703s
    3294                                 #Ran 1 test in 267.344s
    3295         #  cellsize = 20000,  # Ran 1 test in 460.922s
    3296         #  cellsize = 2000   #Ran 1 test in 5340.250s
    3297         #  cellsize = 200   #this one seems to hang, building matirx A
    3298 
    3299         # not optimised
    3300         # seems to hang
    3301         #  cellsize = 2000   # Ran 1 test in 5334.563s
     3291        # the memory optimised least squares
     3292        #  cellsize = 20,   # this one seems to hang
     3293        #  cellsize = 200000, # Ran 1 test in 269.703s
     3294                                #Ran 1 test in 267.344s
     3295        #  cellsize = 20000,  # Ran 1 test in 460.922s
     3296        #  cellsize = 2000   #Ran 1 test in 5340.250s
     3297        #  cellsize = 200   #this one seems to hang, building matirx A
     3298
     3299        # not optimised
     3300        # seems to hang
     3301        #  cellsize = 2000   # Ran 1 test in 5334.563s
    33023302        #Export to ascii/prj files
    33033303        sww2dem('karratha_100m',
    … …  
    46754675        #Check first value
    46764676        stage = fid.variables['stage'][:]
    4677         xmomentum = fid.variables['xmomentum'][:]
    4678         ymomentum = fid.variables['ymomentum'][:]
    4679 
    4680         #print ymomentum
     4677        xmomentum = fid.variables['xmomentum'][:]
     4678        ymomentum = fid.variables['ymomentum'][:]
     4679
     4680        #print ymomentum
    46814681        assert allclose(stage[0,0], e +tide)  #Meters
    46824682
Note: See TracChangeset for help on using the changeset viewer.