def read_result(fn, save_pl, matrix_A, ele, quantity_names, case_num, time_thinning=1): fid = NetCDFFile(fn, netcdf_mode_r) time = fid.variables['time'][:] upper_time_index = len(time) quantities = {} for i, name in enumerate(quantity_names): quantities[name] = fid.variables[name][:] quantities[name] = np.array(quantities[name][::time_thinning, :]) fid.close() for i, t in enumerate(time): for name in quantity_names: Q = quantities[name][i, :] # Quantities at timestep i result = matrix_A * Q result = np.asarray(result) result = result.reshape((100, 100)) if name == 'stage': result = result - ele save_name = save_pl + case_num + '_' + 'depth' + '_{0}.csv'.format( i) else: save_name = save_pl + case_num + '_' + name + '_{0}.csv'.format( i) np.savetxt(save_name, result, delimiter=",")
def __init__(self, *args, **kwargs): Visualiser.__init__(self, *args, **kwargs) fin = NetCDFFile(self.vis_source, 'r') self.xPoints = array(fin.variables['x'], Float) self.yPoints = array(fin.variables['y'], Float) self.quantityCache = {} fin.close()
def test_boundary_timeII(self): """ test_boundary_timeII(self): Test that starttime can be set in the middle of a boundary condition """ boundary_starttime = 0 boundary_filename = self.create_sww_boundary(boundary_starttime) #print "boundary_filename",boundary_filename filename = tempfile.mktemp(".sww") #print "filename",filename dir, base = os.path.split(filename) senario_name = base[:-4] mesh = Mesh() mesh.add_region_from_polygon([[10, 10], [90, 10], [90, 90], [10, 90]]) mesh.generate_mesh(verbose=False) domain = pmesh_to_domain_instance(mesh, anuga.Domain) domain.set_name(senario_name) domain.set_datadir(dir) new_starttime = 0. domain.set_starttime(new_starttime) # Setup initial conditions domain.set_quantity('elevation', 0.0) domain.set_quantity('stage', 0.0) Bf = anuga.File_boundary(boundary_filename, domain, use_cache=False, verbose=False) # Setup boundary conditions domain.set_boundary({'exterior': Bf}) for t in domain.evolve(yieldstep=5, finaltime=9.0): pass #print domain.boundary_statistics() #domain.write_time() #print "domain.time", domain.time # do an assertion on the time of the produced sww file fid = NetCDFFile(filename, netcdf_mode_r) #Open existing file for read times = fid.variables['time'][:] stage = fid.variables['stage'][:] #print stage #print "times", times #print "fid.starttime", fid.starttime assert num.allclose(fid.starttime, new_starttime) fid.close() #print "stage[2,0]", stage[2,0] msg = "This test is a bit hand crafted, based on the output file. " msg += "Not logic. " msg += "It's testing that starttime is working" assert num.allclose(stage[2, 0], 4.85825), msg # clean up os.remove(boundary_filename) os.remove(filename)
def test_triangulation_points_georeference(self): # # filename = tempfile.mktemp("_data_manager.sww") outfile = NetCDFFile(filename, netcdf_mode_w) points_utm = num.array([[0.,0.],[1.,1.], [0.,1.]]) volumes = [[0,1,2]] elevation = [0,1,2] new_origin = None points_georeference = Geo_reference(56, 1, 554354) points_utm = points_georeference.change_points_geo_ref(points_utm) times = [0, 10] number_of_volumes = len(volumes) number_of_points = len(points_utm) sww = Write_sww(['elevation'], ['stage', 'xmomentum', 'ymomentum']) sww.store_header(outfile, times, number_of_volumes, number_of_points, description='fully sick testing', verbose=self.verbose,sww_precision=netcdf_float) sww.store_triangulation(outfile, points_utm, volumes, elevation, new_origin=new_origin, points_georeference=points_georeference, verbose=self.verbose) outfile.close() fid = NetCDFFile(filename) x = fid.variables['x'][:] y = fid.variables['y'][:] results_georef = Geo_reference() results_georef.read_NetCDF(fid) assert results_georef == points_georeference fid.close() assert num.allclose(num.array(map(None, x,y)), points_utm) os.remove(filename)
def __init__(self, source, frameDelay=100, frameStep=1): """The source parameter is assumed to be a NetCDF sww file. The frameDelay parameter is the number of milliseconds waited between frames. """ Visualiser.__init__(self, source) self.frameNumber = 0 fin = NetCDFFile(self.source, 'r') self.maxFrameNumber = fin.variables['time'].shape[0] - 1 fin.close() #self.frameNumberTkVariable = StringVar() #self.frameNumberTkVariable.set('Frame - %05g'%self.framNumber) self.frameDelay = frameDelay self.xmin = None self.xmax = None self.ymin = None self.ymax = None self.zmin = None self.zmax = None self.frameStep = frameStep self.vtk_heightQuantityCache = [] for i in range(self.maxFrameNumber + 1): # maxFrameNumber is zero indexed. self.vtk_heightQuantityCache.append({}) self.paused = False self.movie = False
def test_sww_variable2(self): """Test that sww information can be written correctly multiple timesteps. Use average as reduction operator """ import time, os self.domain.set_name('datatest' + str(id(self))) self.domain.format = 'sww' self.domain.smooth = True self.domain.reduction = mean sww = SWW_file(self.domain) sww.store_connectivity() sww.store_timestep() #self.domain.tight_slope_limiters = 1 self.domain.evolve_to_end(finaltime=0.01) sww.store_timestep() # Check contents # Get NetCDF fid = NetCDFFile(sww.filename, netcdf_mode_r) # Get the variables x = fid.variables['x'] y = fid.variables['y'] z = fid.variables['elevation'] time = fid.variables['time'] stage = fid.variables['stage'] #Check values Q = self.domain.quantities['stage'] Q0 = Q.vertex_values[:, 0] Q1 = Q.vertex_values[:, 1] Q2 = Q.vertex_values[:, 2] A = stage[1, :] assert num.allclose(A[0], old_div((Q2[0] + Q1[1]), 2), rtol=1.0e-5, atol=1.0e-5) assert num.allclose(A[1], old_div((Q0[1] + Q1[3] + Q2[2]), 3), rtol=1.0e-5, atol=1.0e-5) assert num.allclose(A[2], Q0[3], rtol=1.0e-5, atol=1.0e-5) assert num.allclose(A[3], old_div((Q0[0] + Q1[5] + Q2[4]), 3), rtol=1.0e-5, atol=1.0e-5) #Center point assert num.allclose(A[4], old_div((Q1[0] + Q2[1] + Q0[2] +\ Q0[5] + Q2[6] + Q1[7]),6), rtol=1.0e-5, atol=1.0e-5) fid.close() #Cleanup os.remove(sww.filename)
def test_ferret2sww_lat_longII(self): # Test that min lat long works #The test file has # LON = 150.66667, 150.83334, 151, 151.16667 # LAT = -34.5, -34.33333, -34.16667, -34 ; #Read from anuga.coordinate_transforms.redfearn import redfearn fid = NetCDFFile(self.test_MOST_file + '_ha.nc') first_value = fid.variables['HA'][:][0,0,0] fourth_value = fid.variables['HA'][:][0,0,3] fid.close() #Call conversion (with zero origin) #ferret2sww('small', verbose=self.verbose, # origin = (56, 0, 0)) try: ferret2sww(self.test_MOST_file, verbose=self.verbose, origin = (56, 0, 0), minlat=-34.5, maxlat=-35) except AssertionError: pass else: self.assertTrue(0 ==1, 'Bad input did not throw exception error!')
def __init__(self, source, frameDelay=100, frameStep=1): """The source parameter is assumed to be a NetCDF sww file. The frameDelay parameter is the number of milliseconds waited between frames. """ Visualiser.__init__(self, source) self.frameNumber = 0 fin = NetCDFFile(self.source, 'r') self.maxFrameNumber = fin.variables['time'].shape[0] - 1 fin.close() #self.frameNumberTkVariable = StringVar() #self.frameNumberTkVariable.set('Frame - %05g'%self.framNumber) self.frameDelay = frameDelay self.xmin = None self.xmax = None self.ymin = None self.ymax = None self.zmin = None self.zmax = None self.frameStep= frameStep self.vtk_heightQuantityCache = [] for i in range(self.maxFrameNumber + 1): # maxFrameNumber is zero indexed. self.vtk_heightQuantityCache.append({}) self.paused = False self.movie = False
def test_ferret2sww_lat_longII(self): # Test that min lat long works #The test file has # LON = 150.66667, 150.83334, 151, 151.16667 # LAT = -34.5, -34.33333, -34.16667, -34 ; #Read from anuga.coordinate_transforms.redfearn import redfearn fid = NetCDFFile(self.test_MOST_file + '_ha.nc') first_value = fid.variables['HA'][:][0, 0, 0] fourth_value = fid.variables['HA'][:][0, 0, 3] fid.close() #Call conversion (with zero origin) #ferret2sww('small', verbose=self.verbose, # origin = (56, 0, 0)) try: ferret2sww(self.test_MOST_file, verbose=self.verbose, origin=(56, 0, 0), minlat=-34.5, maxlat=-35) except AssertionError: pass else: self.assertTrue(0 == 1, 'Bad input did not throw exception error!')
def test_ferret2sww_2(self): """Test that georeferencing etc works when converting from ferret format (lat/lon) to sww format (UTM) """ #The test file has # LON = 150.66667, 150.83334, 151, 151.16667 # LAT = -34.5, -34.33333, -34.16667, -34 ; # TIME = 0, 0.1, 0.6, 1.1, 1.6, 2.1 ; # # First value (index=0) in small_ha.nc is 0.3400644 cm, # Fourth value (index==3) is -6.50198 cm from anuga.coordinate_transforms.redfearn import redfearn #fid = NetCDFFile('small_ha.nc') fid = NetCDFFile(self.test_MOST_file + '_ha.nc') #Pick a coordinate and a value time_index = 1 lat_index = 0 lon_index = 2 test_value = fid.variables['HA'][:][time_index, lat_index, lon_index] test_time = fid.variables['TIME'][:][time_index] test_lat = fid.variables['LAT'][:][lat_index] test_lon = fid.variables['LON'][:][lon_index] linear_point_index = lat_index*4 + lon_index fid.close() #Call conversion (with zero origin) ferret2sww(self.test_MOST_file, verbose=self.verbose, origin = (56, 0, 0)) #Work out the UTM coordinates for test point zone, e, n = redfearn(test_lat, test_lon) #Read output file 'small.sww' fid = NetCDFFile(self.test_MOST_file + '.sww') x = fid.variables['x'][:] y = fid.variables['y'][:] #Check that test coordinate is correctly represented assert num.allclose(x[linear_point_index], e) assert num.allclose(y[linear_point_index], n) #Check test value stage = fid.variables['stage'][:] assert num.allclose(stage[time_index, linear_point_index], test_value/100) fid.close() #Cleanup import os os.remove(self.test_MOST_file + '.sww')
def test_ferret2sww_2(self): """Test that georeferencing etc works when converting from ferret format (lat/lon) to sww format (UTM) """ #The test file has # LON = 150.66667, 150.83334, 151, 151.16667 # LAT = -34.5, -34.33333, -34.16667, -34 ; # TIME = 0, 0.1, 0.6, 1.1, 1.6, 2.1 ; # # First value (index=0) in small_ha.nc is 0.3400644 cm, # Fourth value (index==3) is -6.50198 cm from anuga.coordinate_transforms.redfearn import redfearn #fid = NetCDFFile('small_ha.nc') fid = NetCDFFile(self.test_MOST_file + '_ha.nc') #Pick a coordinate and a value time_index = 1 lat_index = 0 lon_index = 2 test_value = fid.variables['HA'][:][time_index, lat_index, lon_index] test_time = fid.variables['TIME'][:][time_index] test_lat = fid.variables['LAT'][:][lat_index] test_lon = fid.variables['LON'][:][lon_index] linear_point_index = lat_index * 4 + lon_index fid.close() #Call conversion (with zero origin) ferret2sww(self.test_MOST_file, verbose=self.verbose, origin=(56, 0, 0)) #Work out the UTM coordinates for test point zone, e, n = redfearn(test_lat, test_lon) #Read output file 'small.sww' fid = NetCDFFile(self.test_MOST_file + '.sww') x = fid.variables['x'][:] y = fid.variables['y'][:] #Check that test coordinate is correctly represented assert num.allclose(x[linear_point_index], e) assert num.allclose(y[linear_point_index], n) #Check test value stage = fid.variables['stage'][:] assert num.allclose(stage[time_index, linear_point_index], old_div(test_value, 100)) fid.close() #Cleanup import os os.remove(self.test_MOST_file + '.sww')
def test_ferret2sww_nz_origin(self): from anuga.coordinate_transforms.redfearn import redfearn #Call conversion (with nonzero origin) ferret2sww(self.test_MOST_file, verbose=self.verbose, origin = (56, 100000, 200000)) #Work out the UTM coordinates for first point zone, e, n = redfearn(-34.5, 150.66667) #Read output file 'small.sww' #fid = NetCDFFile('small.sww', netcdf_mode_r) fid = NetCDFFile(self.test_MOST_file + '.sww') x = fid.variables['x'][:] y = fid.variables['y'][:] #Check that first coordinate is correctly represented assert num.allclose(x[0], e-100000) assert num.allclose(y[0], n-200000) fid.close() #Cleanup os.remove(self.test_MOST_file + '.sww')
def test_ferret2sww_nz_origin(self): from anuga.coordinate_transforms.redfearn import redfearn #Call conversion (with nonzero origin) ferret2sww(self.test_MOST_file, verbose=self.verbose, origin=(56, 100000, 200000)) #Work out the UTM coordinates for first point zone, e, n = redfearn(-34.5, 150.66667) #Read output file 'small.sww' #fid = NetCDFFile('small.sww', netcdf_mode_r) fid = NetCDFFile(self.test_MOST_file + '.sww') x = fid.variables['x'][:] y = fid.variables['y'][:] #Check that first coordinate is correctly represented assert num.allclose(x[0], e - 100000) assert num.allclose(y[0], n - 200000) fid.close() #Cleanup os.remove(self.test_MOST_file + '.sww')
def test_sww_header(self): """Test that constant sww information can be written correctly (non smooth) """ self.domain.set_name('datatest' + str(id(self))) self.domain.format = 'sww' #Remove?? self.domain.smooth = False sww = SWW_file(self.domain) sww.store_connectivity() # Check contents # Get NetCDF fid = NetCDFFile(sww.filename, netcdf_mode_r) # Open existing file for append # Get the variables sww_revision = fid.revision_number try: revision_number = get_revision_number() except: revision_number = None assert str(revision_number) == sww_revision fid.close() #print "sww.filename", sww.filename os.remove(sww.filename)
def test_sww_constant(self): """Test that constant sww information can be written correctly (non smooth) """ self.domain.set_name('datatest' + str(id(self))) self.domain.format = 'sww' #Remove?? self.domain.smooth = False sww = SWW_file(self.domain) sww.store_connectivity() fid = NetCDFFile(sww.filename, netcdf_mode_r) # Open existing file for append # Get the variables x = fid.variables['x'] y = fid.variables['y'] z = fid.variables['elevation'] V = fid.variables['volumes'] assert num.allclose (x[:], self.X.flatten()) assert num.allclose (y[:], self.Y.flatten()) assert num.allclose (z[:], self.F.flatten()) P = len(self.domain) for k in range(P): assert V[k, 0] == 3*k assert V[k, 1] == 3*k+1 assert V[k, 2] == 3*k+2 fid.close() os.remove(sww.filename)
def sww_merge_parallel(domain_global_name, np, verbose=False, delete_old=False): output = domain_global_name + ".sww" swwfiles = [ domain_global_name + "_P" + str(np) + "_" + str(v) + ".sww" for v in range(np) ] fid = NetCDFFile(swwfiles[0], netcdf_mode_r) try: # works with netcdf4 number_of_volumes = len(fid.dimensions['number_of_volumes']) number_of_points = len(fid.dimensions['number_of_points']) except: # works with scientific.io.netcdf number_of_volumes = int(fid.dimensions['number_of_volumes']) number_of_points = int(fid.dimensions['number_of_points']) fid.close() if 3 * number_of_volumes == number_of_points: _sww_merge_parallel_non_smooth(swwfiles, output, verbose, delete_old) else: _sww_merge_parallel_smooth(swwfiles, output, verbose, delete_old)
def test_boundary_timeII_1_5(self): """ test_boundary_timeII(self): Test that starttime can be set in the middle of a boundary condition """ boundary_starttime = 0 boundary_filename = self.create_sww_boundary(boundary_starttime) # print "boundary_filename",boundary_filename filename = tempfile.mktemp(".sww") # print "filename",filename dir, base = os.path.split(filename) senario_name = base[:-4] mesh = Mesh() mesh.add_region_from_polygon([[10, 10], [90, 10], [90, 90], [10, 90]]) mesh.generate_mesh(verbose=False) domain = pmesh_to_domain_instance(mesh, anuga.Domain) domain.set_name(senario_name) domain.set_datadir(dir) domain.set_flow_algorithm("1_5") new_starttime = 0.0 domain.set_starttime(new_starttime) # Setup initial conditions domain.set_quantity("elevation", 0.0) domain.set_quantity("stage", 0.0) Bf = anuga.File_boundary(boundary_filename, domain, use_cache=False, verbose=False) # Setup boundary conditions domain.set_boundary({"exterior": Bf}) for t in domain.evolve(yieldstep=5, finaltime=9.0): pass # print domain.boundary_statistics() # domain.write_time() # print "domain.time", domain.time # do an assertion on the time of the produced sww file fid = NetCDFFile(filename, netcdf_mode_r) # Open existing file for read times = fid.variables["time"][:] stage = fid.variables["stage"][:] # print stage # print "times", times # print "fid.starttime", fid.starttime assert num.allclose(fid.starttime, new_starttime) fid.close() # print "stage[2,0]", stage[2,0] msg = "This test is a bit hand crafted, based on the output file. " msg += "Not logic. " msg += "It's testing that starttime is working" assert num.allclose(stage[2, 0], 4.88601), msg # clean up os.remove(boundary_filename) os.remove(filename)
def setup_grid(self): fin = NetCDFFile(self.source, 'r') self.vtk_cells = vtkCellArray() N_tri = fin.variables['volumes'].shape[0] for v in range(N_tri): self.vtk_cells.InsertNextCell(3) for i in range(3): self.vtk_cells.InsertCellPoint(fin.variables['volumes'][v][i]) fin.close()
def test_georef_types(self): '''Ensure that attributes of a georeference are of correct type. zone int false_easting int false_northing int xllcorner float yllcorner float ''' from anuga.file.netcdf import NetCDFFile # ensure that basic instance attributes are correct g = Geo_reference(56, 1.8, 1.8) self.assertTrue(isinstance(g.zone, int), "geo_ref .zone should be 'int' type, " "was '%s' type" % type(g.zone)) self.assertTrue(isinstance(g.false_easting, int), "geo_ref .false_easting should be int type, " "was '%s' type" % type(g.false_easting)) self.assertTrue(isinstance(g.false_northing, int), "geo_ref .false_northing should be int type, " "was '%s' type" % type(g.false_northing)) self.assertTrue(isinstance(g.xllcorner, float), "geo_ref .xllcorner should be float type, " "was '%s' type" % type(g.xllcorner)) self.assertTrue(isinstance(g.yllcorner, float), "geo_ref .yllcorner should be float type, " "was '%s' type" % type(g.yllcorner)) # now write fikle, read back and check types again file_name = tempfile.mktemp(".geo_referenceTest") out_file = NetCDFFile(file_name, netcdf_mode_w) g.write_NetCDF(out_file) out_file.close() in_file = NetCDFFile(file_name, netcdf_mode_r) new_g = Geo_reference(NetCDFObject=in_file) in_file.close() os.remove(file_name) self.assertTrue(isinstance(new_g.zone, int), "geo_ref .zone should be 'int' type, " "was '%s' type" % type(new_g.zone)) self.assertTrue(isinstance(new_g.false_easting, int), "geo_ref .false_easting should be int type, " "was '%s' type" % type(new_g.false_easting)) self.assertTrue(isinstance(new_g.false_northing, int), "geo_ref .false_northing should be int type, " "was '%s' type" % type(new_g.false_northing)) self.assertTrue(isinstance(new_g.xllcorner, float), "geo_ref .xllcorner should be float type, " "was '%s' type" % type(new_g.xllcorner)) self.assertTrue(isinstance(new_g.yllcorner, float), "geo_ref .yllcorner should be float type, " "was '%s' type" % type(new_g.yllcorner))
def helper_read_msh_file(self, filename): fid = NetCDFFile(filename, netcdf_mode_r) mesh = {} # Get the 'strings' variable strings = fid.variables['strings'][:] fid.close() return char_to_string(strings)
def build_quantity_dict(self): quantities = {} fin = NetCDFFile(self.source, 'r') for q in filter(lambda n:n != 'x' and n != 'y' and n != 'z' and n != 'time' and n != 'volumes', fin.variables.keys()): if len(fin.variables[q].shape) == 1: # Not a time-varying quantity quantities[q] = num.ravel(num.array(fin.variables[q], num.float)) else: # Time-varying, get the current timestep data quantities[q] = num.array(fin.variables[q][self.frameNumber], num.float) fin.close() return quantities
def get_matrix_A(fn, gauge_name): # points to read information from point_reader = reader(file(gauge_name)) points = [] point_name = [] for i, row in enumerate(point_reader): if i == 0: for j, value in enumerate(row): if value.strip() == 'easting': easting = j if value.strip() == 'northing': northing = j if value.strip() == 'name': name = j if value.strip() == 'elevation': elevation = j else: #points.append([float(row[easting]),float(row[northing])]) points.append([float(row[easting]), float(row[northing])]) point_name.append(row[name]) points_array = np.array(points, np.float) dim_gauge = int(np.sqrt(points_array.shape[0])) interpolation_points = ensure_absolute(points_array) # read the sww file to extract something fid = NetCDFFile(fn, netcdf_mode_r) xllcorner = fid.xllcorner yllcorner = fid.yllcorner zone = fid.zone x = fid.variables['x'][:] y = fid.variables['y'][:] triangles = fid.variables['volumes'][:] x = np.reshape(x, (len(x), 1)) y = np.reshape(y, (len(y), 1)) vertex_coordinates = np.concatenate((x, y), axis=1) ele = fid.variables['elevation'][:] fid.close() vertex_coordinates = ensure_absolute(vertex_coordinates) triangles = ensure_numeric(triangles) interpolation_points = ensure_numeric(interpolation_points) interpolation_points[:, 0] -= xllcorner interpolation_points[:, 1] -= yllcorner mesh = Mesh(vertex_coordinates, triangles) mesh_boundary_polygon = mesh.get_boundary_polygon() indices = outside_polygon(interpolation_points, mesh_boundary_polygon) interp = Interpolate(vertex_coordinates, triangles) matrix_A, inside_poly_indices, outside_poly_indices, centroids = interp._build_interpolation_matrix_A( interpolation_points, output_centroids=False, verbose=False) ele = matrix_A * ele ele = np.asarray(ele) ele = ele.reshape((100, 100)) return ele, matrix_A
def test_sww_variable(self): """Test that sww information can be written correctly """ self.domain.set_name('datatest' + str(id(self))) self.domain.format = 'sww' self.domain.smooth = True self.domain.reduction = mean sww = SWW_file(self.domain) sww.store_connectivity() sww.store_timestep() # Check contents # Get NetCDF fid = NetCDFFile(sww.filename, netcdf_mode_r) # Open existing file for append # Get the variables time = fid.variables['time'] stage = fid.variables['stage'] Q = self.domain.quantities['stage'] Q0 = Q.vertex_values[:, 0] Q1 = Q.vertex_values[:, 1] Q2 = Q.vertex_values[:, 2] A = stage[0, :] # print stage[0,:] # print A[0], (Q2[0] + Q1[1])/2 # print A[1], (Q0[1] + Q1[3] + Q2[2])/3 # print A[2], Q0[3] # print A[3], (Q0[0] + Q1[5] + Q2[4])/3 assert num.allclose(A[0], old_div((Q2[0] + Q1[1]), 2), rtol=1.0e-5, atol=1.0e-5) assert num.allclose(A[1], old_div((Q0[1] + Q1[3] + Q2[2]), 3), rtol=1.0e-5, atol=1.0e-5) assert num.allclose(A[2], Q0[3]) assert num.allclose(A[3], old_div((Q0[0] + Q1[5] + Q2[4]), 3), rtol=1.0e-5, atol=1.0e-5) #Center point assert num.allclose(A[4], old_div((Q1[0] + Q2[1] + Q0[2] +\ Q0[5] + Q2[6] + Q1[7]),6), rtol=1.0e-5, atol=1.0e-5) fid.close() os.remove(sww.filename)
def getQuantityDict(self): quantities = {} fin = NetCDFFile(self.vis_source, 'r') names = [ k for k in fin.variables.keys() if k != 'x' and k != 'y' and k != 'z' and k != 'time' and k != 'volumes' ] argss = [(name, len(fin.variables[name].shape) != 1) for name in names] fin.close() for args in argss: quantities[name] = self.getQuantityPoints(*args) return quantities
def test_sww_range(self): """Test that constant sww information can be written correctly Use non-smooth to be able to compare to quantity values. """ self.domain.set_name('datatest' + str(id(self))) self.domain.format = 'sww' self.domain.set_store_vertices_uniquely(True) sww = SWW_file(self.domain) dqs = self.domain.get_quantity('stage') dqx = self.domain.get_quantity('xmomentum') dqy = self.domain.get_quantity('ymomentum') xmom_min = ymom_min = stage_min = sys.maxint xmom_max = ymom_max = stage_max = -stage_min for t in self.domain.evolve(yieldstep = 1, finaltime = 1): wmax = max(dqs.get_values().flatten()) if wmax > stage_max: stage_max = wmax wmin = min(dqs.get_values().flatten()) if wmin < stage_min: stage_min = wmin uhmax = max(dqx.get_values().flatten()) if uhmax > xmom_max: xmom_max = uhmax uhmin = min(dqx.get_values().flatten()) if uhmin < xmom_min: xmom_min = uhmin vhmax = max(dqy.get_values().flatten()) if vhmax > ymom_max: ymom_max = vhmax vhmin = min(dqy.get_values().flatten()) if vhmin < ymom_min: ymom_min = vhmin # Get NetCDF fid = NetCDFFile(sww.filename, netcdf_mode_r) # Open existing file for append # Get the variables range = fid.variables['stage_range'][:] assert num.allclose(range,[stage_min, stage_max]) range = fid.variables['xmomentum_range'][:] #print range assert num.allclose(range, [xmom_min, xmom_max]) range = fid.variables['ymomentum_range'][:] #print range assert num.allclose(range, [ymom_min, ymom_max]) fid.close() os.remove(sww.filename)
def setupGrid(self): fin = NetCDFFile(self.vis_source, 'r') nTri = fin.variables['volumes'].shape[0] insertNextCell = vtkCellArray.InsertNextCell insertCellPoint = vtkCellArray.InsertCellPoint for v in range(nTri): insertNextCell(self.vtk_cells, 3) for i in range(3): insertCellPoint(self.vtk_cells, fin.variables['volumes'][v][i]) fin.close()
def prepare_timeboundary(filename, verbose = False): """Convert benchmark 2 time series to NetCDF tms file. This is a 'throw-away' code taylor made for files like 'Benchmark_2_input.txt' from the LWRU2 benchmark """ from anuga.file.netcdf import NetCDFFile if verbose: print 'Creating', filename # Read the ascii (.txt) version of this file fid = open(filename[:-4] + '.txt') # Skip first line line = fid.readline() # Read remaining lines lines = fid.readlines() fid.close() N = len(lines) T = num.zeros(N, num.float) #Time Q = num.zeros(N, num.float) #Values for i, line in enumerate(lines): fields = line.split() T[i] = float(fields[0]) Q[i] = float(fields[1]) # Create tms NetCDF file fid = NetCDFFile(filename, 'w') fid.institution = 'Geoscience Australia' fid.description = 'Input wave for Benchmark 2' fid.starttime = 0.0 fid.createDimension('number_of_timesteps', len(T)) fid.createVariable('time', netcdf_float, ('number_of_timesteps',)) fid.variables['time'][:] = T fid.createVariable('stage', netcdf_float, ('number_of_timesteps',)) fid.variables['stage'][:] = Q[:] fid.createVariable('xmomentum', netcdf_float, ('number_of_timesteps',)) fid.variables['xmomentum'][:] = 0.0 fid.createVariable('ymomentum', netcdf_float, ('number_of_timesteps',)) fid.variables['ymomentum'][:] = 0.0 fid.close()
def test_sww_variable2(self): """Test that sww information can be written correctly multiple timesteps. Use average as reduction operator """ import time, os self.domain.set_name('datatest' + str(id(self))) self.domain.format = 'sww' self.domain.smooth = True self.domain.reduction = mean sww = SWW_file(self.domain) sww.store_connectivity() sww.store_timestep() #self.domain.tight_slope_limiters = 1 self.domain.evolve_to_end(finaltime = 0.01) sww.store_timestep() # Check contents # Get NetCDF fid = NetCDFFile(sww.filename, netcdf_mode_r) # Get the variables x = fid.variables['x'] y = fid.variables['y'] z = fid.variables['elevation'] time = fid.variables['time'] stage = fid.variables['stage'] #Check values Q = self.domain.quantities['stage'] Q0 = Q.vertex_values[:,0] Q1 = Q.vertex_values[:,1] Q2 = Q.vertex_values[:,2] A = stage[1,:] assert num.allclose(A[0], (Q2[0] + Q1[1])/2, rtol=1.0e-5, atol=1.0e-5) assert num.allclose(A[1], (Q0[1] + Q1[3] + Q2[2])/3, rtol=1.0e-5, atol=1.0e-5) assert num.allclose(A[2], Q0[3], rtol=1.0e-5, atol=1.0e-5) assert num.allclose(A[3], (Q0[0] + Q1[5] + Q2[4])/3, rtol=1.0e-5, atol=1.0e-5) #Center point assert num.allclose(A[4], (Q1[0] + Q2[1] + Q0[2] +\ Q0[5] + Q2[6] + Q1[7])/6, rtol=1.0e-5, atol=1.0e-5) fid.close() #Cleanup os.remove(sww.filename)
def test_sww_minimum_storable_height(self): """Test that sww information can be written correctly multiple timesteps using a different reduction operator (min) """ import time, os self.domain.set_name('datatest' + str(id(self))) self.domain.format = 'sww' self.domain.smooth = True self.domain.reduction = min self.domain.minimum_storable_height = 100 sww = SWW_file(self.domain) sww.store_connectivity() sww.store_timestep() #self.domain.tight_slope_limiters = 1 self.domain.evolve_to_end(finaltime = 0.01) sww.store_timestep() #Check contents #Get NetCDF fid = NetCDFFile(sww.filename, netcdf_mode_r) # Get the variables x = fid.variables['x'] y = fid.variables['y'] z = fid.variables['elevation'] time = fid.variables['time'] stage = fid.variables['stage'] xmomentum = fid.variables['xmomentum'] ymomentum = fid.variables['ymomentum'] #Check values Q = self.domain.quantities['stage'] Q0 = Q.vertex_values[:,0] Q1 = Q.vertex_values[:,1] Q2 = Q.vertex_values[:,2] A = stage[1,:] assert num.allclose(stage[1,:], z[:]) assert num.allclose(xmomentum, 0.0) assert num.allclose(ymomentum, 0.0) fid.close() #Cleanup os.remove(sww.filename)
def test_sync(self): """test_sync - Test info stored at each timestep is as expected (incl initial condition) """ import time, os self.domain.set_name('synctest') self.domain.format = 'sww' self.domain.smooth = False self.domain.store = True self.domain.tight_slope_limiters = True self.domain.use_centroid_velocities = True # In this case tight_slope_limiters as default # in conjunction with protection # against isolated degenerate timesteps works. #self.domain.tight_slope_limiters = 1 #self.domain.protect_against_isolated_degenerate_timesteps = True #print 'tight_sl', self.domain.tight_slope_limiters #Evolution for t in self.domain.evolve(yieldstep=1.0, finaltime=4.0): #########self.domain.write_time(track_speeds=True) stage = self.domain.quantities['stage'].vertex_values #Get NetCDF fid = NetCDFFile(self.domain.writer.filename, netcdf_mode_r) stage_file = fid.variables['stage'] if t == 0.0: assert num.allclose(stage, self.initial_stage, rtol=1.0e-5, atol=1.0e-5) assert num.allclose(stage_file[:], stage.flatten(), rtol=1.0e-5, atol=1.0e-5) else: assert not num.allclose( stage, self.initial_stage, rtol=1.0e-5, atol=1.0e-5) assert not num.allclose( stage_file[:], stage.flatten(), rtol=1.0e-5, atol=1.0e-5) fid.close() os.remove(self.domain.writer.filename)
def prepare_timeboundary(filename, verbose=False): """Convert benchmark 2 time series to NetCDF tms file. This is a 'throw-away' code taylor made for files like 'Benchmark_2_input.txt' from the LWRU2 benchmark """ from anuga.file.netcdf import NetCDFFile if verbose: print 'Creating', filename # Read the ascii (.txt) version of this file fid = open(filename[:-4] + '.txt') # Skip first line line = fid.readline() # Read remaining lines lines = fid.readlines() fid.close() N = len(lines) T = num.zeros(N, num.float) #Time Q = num.zeros(N, num.float) #Values for i, line in enumerate(lines): fields = line.split() T[i] = float(fields[0]) Q[i] = float(fields[1]) # Create tms NetCDF file fid = NetCDFFile(filename, 'w') fid.institution = 'Geoscience Australia' fid.description = 'Input wave for Benchmark 2' fid.starttime = 0.0 fid.createDimension('number_of_timesteps', len(T)) fid.createVariable('time', netcdf_float, ('number_of_timesteps', )) fid.variables['time'][:] = T fid.createVariable('stage', netcdf_float, ('number_of_timesteps', )) fid.variables['stage'][:] = Q[:] fid.createVariable('xmomentum', netcdf_float, ('number_of_timesteps', )) fid.variables['xmomentum'][:] = 0.0 fid.createVariable('ymomentum', netcdf_float, ('number_of_timesteps', )) fid.variables['ymomentum'][:] = 0.0 fid.close()
def test_urs_ungridded_hole (self): #Zone: 50 #Easting: 240992.578 Northing: 7620442.472 #Latitude: -21 30 ' 0.00000 '' Longitude: 114 30 ' 0.00000 '' lat_long = [[-20.5, 114.5], [-20.6, 114.6], [-20.5, 115.], [-20.6, 115.], [-20.5, 115.5], [-20.6, 115.4], [-21., 114.5], [-21., 114.6], [-21., 115.5], [-21., 115.4], [-21.5, 114.5], [-21.4, 114.6], [-21.5, 115.], [-21.4, 115.], [-21.5, 115.5], [-21.4, 115.4] ] time_step_count = 6 time_step = 100 tide = 9000000 base_name, files = self.write_mux(lat_long, time_step_count, time_step) #Easting: 292110.784 Northing: 7676551.710 #Latitude: -21 0 ' 0.00000 '' Longitude: 115 0 ' 0.00000 '' urs_ungridded2sww(base_name, mean_stage=-240992.0, hole_points_UTM=[ 292110.784, 7676551.710 ]) # now I want to check the sww file ... sww_file = base_name + '.sww' #Let's interigate the sww file # Note, the sww info is not gridded. It is point data. fid = NetCDFFile(sww_file) number_of_volumes = fid.variables['volumes'] #print "number_of_volumes",len(number_of_volumes) assert num.allclose(16, len(number_of_volumes)) fid.close() self.delete_mux(files) #print "sww_file", sww_file os.remove(sww_file)
def test_boundary_time(self): """ test_boundary_time(self): test that the starttime of a boundary condition is carried thru to the output sww file. """ boundary_starttime = 0 boundary_filename = self.create_sww_boundary(boundary_starttime) filename = tempfile.mktemp(".sww") dir, base = os.path.split(filename) senario_name = base[:-4] mesh = Mesh() ###mesh.add_region_from_polygon([[10,10], [90,10], [90,90], [10,90]]) mesh.add_region_from_polygon([[0, 0], [100, 0], [100, 100], [0, 100]]) mesh.generate_mesh(verbose=False) domain = pmesh_to_domain_instance(mesh, anuga.Domain) domain.set_name(senario_name) domain.set_datadir(dir) # Setup initial conditions domain.set_quantity('elevation', 0.0) domain.set_quantity('stage', 0.0) Bf = anuga.File_boundary(boundary_filename, domain, use_cache=False, verbose=False) # Setup boundary conditions domain.set_boundary({'exterior': Bf}) for t in domain.evolve(yieldstep=5.0, finaltime=10.0): pass #print domain.write_time() #print "domain.time", domain.time # do an assertion on the time of the produced sww file fid = NetCDFFile(filename, netcdf_mode_r) #Open existing file for read times = fid.variables['time'][:] #print "times", times #print "fid.starttime", fid.starttime assert num.allclose(fid.starttime, boundary_starttime) fid.close() # clean up os.remove(boundary_filename) os.remove(filename)
def getQuantityDict(self): quantities = {} fin = NetCDFFile(self.vis_source, 'r') names = [ k for k in fin.variables.keys() if k != 'x' and k != 'y' and k != 'z' and k != 'time' and k != 'volumes' ] argss = [ (name, len(fin.variables[name].shape) != 1) for name in names ] fin.close() for args in argss: quantities[name] = self.getQuantityPoints(*args) return quantities
def build_quantity_dict(self): quantities = {} fin = NetCDFFile(self.source, 'r') for q in filter( lambda n: n != 'x' and n != 'y' and n != 'z' and n != 'time' and n != 'volumes', fin.variables.keys()): if len(fin.variables[q].shape) == 1: # Not a time-varying quantity quantities[q] = num.ravel( num.array(fin.variables[q], num.float)) else: # Time-varying, get the current timestep data quantities[q] = num.array(fin.variables[q][self.frameNumber], num.float) fin.close() return quantities
def test_read_write_NetCDF(self): from anuga.file.netcdf import NetCDFFile g = Geo_reference(56, 1.9, 1.9) file_name = tempfile.mktemp(".geo_referenceTest") out_file = NetCDFFile(file_name, netcdf_mode_w) g.write_NetCDF(out_file) out_file.close() in_file = NetCDFFile(file_name, netcdf_mode_r) new_g = Geo_reference(NetCDFObject=in_file) in_file.close() os.remove(file_name) self.assertTrue(g == new_g, 'test_read_write_NetCDF failed')
def test_read_write_NetCDF(self): from anuga.file.netcdf import NetCDFFile g = Geo_reference(56,1.9,1.9) file_name = tempfile.mktemp(".geo_referenceTest") out_file = NetCDFFile(file_name, netcdf_mode_w) g.write_NetCDF(out_file) out_file.close() in_file = NetCDFFile(file_name, netcdf_mode_r) new_g = Geo_reference(NetCDFObject=in_file) in_file.close() os.remove(file_name) self.assertTrue(g == new_g, 'test_read_write_NetCDF failed')
def test_urs_ungridded_holeII(self): # Check that if using a hole that returns no triangles, # urs_ungridded2sww removes the hole label. lat_long = [[-20.5, 114.5], [-20.6, 114.6], [-20.5, 115.5], [-20.6, 115.4], [-21.5, 114.5], [-21.4, 114.6], [-21.5, 115.5], [-21.4, 115.4] ] time_step_count = 6 time_step = 100 tide = 9000000 base_name, files = self.write_mux(lat_long, time_step_count, time_step) #Easting: 292110.784 Northing: 7676551.710 #Latitude: -21 0 ' 0.00000 '' Longitude: 115 0 ' 0.00000 '' urs_ungridded2sww(base_name, mean_stage=-240992.0, hole_points_UTM=[ 292110.784, 7676551.710 ]) # now I want to check the sww file ... sww_file = base_name + '.sww' fid = NetCDFFile(sww_file) volumes = fid.variables['volumes'][:] #print "number_of_volumes",len(volumes) fid.close() os.remove(sww_file) urs_ungridded2sww(base_name, mean_stage=-240992.0) # now I want to check the sww file ... sww_file = base_name + '.sww' fid = NetCDFFile(sww_file) volumes_again = fid.variables['volumes'][:] #print "number_of_volumes",len(volumes_again) assert num.allclose(len(volumes_again), len(volumes)) fid.close() os.remove(sww_file) self.delete_mux(files)
def test_boundary_time(self): """ test_boundary_time(self): test that the starttime of a boundary condition is carried thru to the output sww file. """ boundary_starttime = 0 boundary_filename = self.create_sww_boundary(boundary_starttime) filename = tempfile.mktemp(".sww") dir, base = os.path.split(filename) senario_name = base[:-4] mesh = Mesh() ###mesh.add_region_from_polygon([[10,10], [90,10], [90,90], [10,90]]) mesh.add_region_from_polygon([[0, 0], [100, 0], [100, 100], [0, 100]]) mesh.generate_mesh(verbose=False) domain = pmesh_to_domain_instance(mesh, anuga.Domain) domain.set_name(senario_name) domain.set_datadir(dir) # Setup initial conditions domain.set_quantity("elevation", 0.0) domain.set_quantity("stage", 0.0) Bf = anuga.File_boundary(boundary_filename, domain, use_cache=False, verbose=False) # Setup boundary conditions domain.set_boundary({"exterior": Bf}) for t in domain.evolve(yieldstep=5.0, finaltime=10.0): pass # print domain.write_time() # print "domain.time", domain.time # do an assertion on the time of the produced sww file fid = NetCDFFile(filename, netcdf_mode_r) # Open existing file for read times = fid.variables["time"][:] # print "times", times # print "fid.starttime", fid.starttime assert num.allclose(fid.starttime, boundary_starttime) fid.close() # clean up os.remove(boundary_filename) os.remove(filename)
def helper_write_msh_file(self, filename, l): # open the NetCDF file fd = NetCDFFile(filename, netcdf_mode_w) fd.description = 'Test file - string arrays' # convert list of strings to num.array al = num.array(string_to_char(l), num.character) # write the list fd.createDimension('num_of_strings', al.shape[0]) fd.createDimension('size_of_strings', al.shape[1]) var = fd.createVariable('strings', netcdf_char, ('num_of_strings', 'size_of_strings')) var[:] = al fd.close()
def test_triangulation_2_geo_refs(self): # # filename = tempfile.mktemp("_data_manager.sww") outfile = NetCDFFile(filename, netcdf_mode_w) points_utm = num.array([[0., 0.], [1., 1.], [0., 1.]]) volumes = [[0, 1, 2]] elevation = [0, 1, 2] new_origin = Geo_reference(56, 1, 1) points_georeference = Geo_reference(56, 0, 0) points_utm = points_georeference.change_points_geo_ref(points_utm) times = [0, 10] number_of_volumes = len(volumes) number_of_points = len(points_utm) sww = Write_sww(['elevation'], ['stage', 'xmomentum', 'ymomentum']) sww.store_header(outfile, times, number_of_volumes, number_of_points, description='fully sick testing', verbose=self.verbose, sww_precision=netcdf_float) sww.store_triangulation(outfile, points_utm, volumes, elevation, new_origin=new_origin, points_georeference=points_georeference, verbose=self.verbose) outfile.close() fid = NetCDFFile(filename) x = fid.variables['x'][:] y = fid.variables['y'][:] results_georef = Geo_reference() results_georef.read_NetCDF(fid) assert results_georef == new_origin fid.close() absolute = Geo_reference(56, 0, 0) assert num.allclose( num.array( absolute.change_points_geo_ref(map(None, x, y), new_origin)), points_utm) os.remove(filename)
def test_small_nxn(self): most2nc(input_file=FN,output_file='test.nc'\ ,inverted_bathymetry = False,verbose = False) fid = NetCDFFile('test.nc') elevation = fid.variables['ELEVATION'][:] fid.close() z=[[-13., -14., -15., -16.]\ ,[-9., -10., -11., -12.]\ ,[-5., -6., -7., -8.]\ ,[-1., -2., -3., -4.]] z = num.asarray(z) assert num.allclose(z, elevation) import os os.remove('test.nc')
def test_small_nxn(self): most2nc(input_file=FN,output_file='test.nc'\ ,inverted_bathymetry = False,verbose = False) fid = NetCDFFile('test.nc') elevation = fid.variables['ELEVATION'][:] fid.close() z=[[-13., -14., -15., -16.]\ ,[-9., -10., -11., -12.]\ ,[-5., -6., -7., -8.]\ ,[-1., -2., -3., -4.]] z = num.asarray(z) assert num.allclose(z,elevation) import os os.remove('test.nc')
def test_sww_variable(self): """Test that sww information can be written correctly """ self.domain.set_name('datatest' + str(id(self))) self.domain.format = 'sww' self.domain.smooth = True self.domain.reduction = mean sww = SWW_file(self.domain) sww.store_connectivity() sww.store_timestep() # Check contents # Get NetCDF fid = NetCDFFile(sww.filename, netcdf_mode_r) # Open existing file for append # Get the variables time = fid.variables['time'] stage = fid.variables['stage'] Q = self.domain.quantities['stage'] Q0 = Q.vertex_values[:,0] Q1 = Q.vertex_values[:,1] Q2 = Q.vertex_values[:,2] A = stage[0,:] # print stage[0,:] # print A[0], (Q2[0] + Q1[1])/2 # print A[1], (Q0[1] + Q1[3] + Q2[2])/3 # print A[2], Q0[3] # print A[3], (Q0[0] + Q1[5] + Q2[4])/3 assert num.allclose(A[0], (Q2[0] + Q1[1])/2, rtol=1.0e-5, atol=1.0e-5) assert num.allclose(A[1], (Q0[1] + Q1[3] + Q2[2])/3, rtol=1.0e-5, atol=1.0e-5) assert num.allclose(A[2], Q0[3]) assert num.allclose(A[3], (Q0[0] + Q1[5] + Q2[4])/3, rtol=1.0e-5, atol=1.0e-5) #Center point assert num.allclose(A[4], (Q1[0] + Q2[1] + Q0[2] +\ Q0[5] + Q2[6] + Q1[7])/6, rtol=1.0e-5, atol=1.0e-5) fid.close() os.remove(sww.filename)
def test_read_NetCDFI(self): # test if read_NetCDF from anuga.file.netcdf import NetCDFFile g = Geo_reference(56,1.9,1.9) file_name = tempfile.mktemp(".geo_referenceTest") outfile = NetCDFFile(file_name, netcdf_mode_w) outfile.xllcorner = g.get_xllcorner() outfile.yllcorner = g.get_yllcorner() outfile.zone = g.get_zone() outfile.close() in_file = NetCDFFile(file_name, netcdf_mode_r) new_g = Geo_reference(NetCDFObject=in_file) in_file.close() os.remove(file_name) self.assertTrue(g == new_g, ' failed')
def getQuantityPoints(self, quantityName, dynamic=False): try: if dynamic: q = self.quantityCache[quantityName][self.vis_frame] else: q = self.quantityCache[quantityName] except KeyError: fin = NetCDFFile(self.vis_source, 'r') if dynamic: if not self.quantityCache.has_key(quantityName): self.quantityCache[quantityName] = {} q = array(fin.variables[quantityName][self.vis_frame], Float) self.quantityCache[quantityName][self.vis_frame] = q else: q = array(fin.variables[quantityName], Float) self.quantityCache[quantityName] = q fin.close() return q
def getQuantityPoints(self, quantityName, dynamic=False): try: if dynamic: q = self.quantityCache[quantityName][self.vis_frame] else: q = self.quantityCache[quantityName] except KeyError: fin = NetCDFFile(self.vis_source, 'r') if dynamic: if quantityName not in self.quantityCache: self.quantityCache[quantityName] = {} q = array(fin.variables[quantityName][self.vis_frame], Float) self.quantityCache[quantityName][self.vis_frame] = q else: q = array(fin.variables[quantityName], Float) self.quantityCache[quantityName] = q fin.close() return q
def test_sync(self): """test_sync - Test info stored at each timestep is as expected (incl initial condition) """ import time, os self.domain.set_name('synctest') self.domain.format = 'sww' self.domain.smooth = False self.domain.store = True self.domain.tight_slope_limiters = True self.domain.use_centroid_velocities = True # In this case tight_slope_limiters as default # in conjunction with protection # against isolated degenerate timesteps works. #self.domain.tight_slope_limiters = 1 #self.domain.protect_against_isolated_degenerate_timesteps = True #print 'tight_sl', self.domain.tight_slope_limiters #Evolution for t in self.domain.evolve(yieldstep = 1.0, finaltime = 4.0): #########self.domain.write_time(track_speeds=True) stage = self.domain.quantities['stage'].vertex_values #Get NetCDF fid = NetCDFFile(self.domain.writer.filename, netcdf_mode_r) stage_file = fid.variables['stage'] if t == 0.0: assert num.allclose(stage, self.initial_stage, rtol=1.0e-5, atol=1.0e-5) assert num.allclose(stage_file[:], stage.flatten(),rtol=1.0e-5, atol=1.0e-5) else: assert not num.allclose(stage, self.initial_stage, rtol=1.0e-5, atol=1.0e-5) assert not num.allclose(stage_file[:], stage.flatten(), rtol=1.0e-5, atol=1.0e-5) fid.close() os.remove(self.domain.writer.filename)
def test_urs_ungridded2sww_mint_maxtII (self): #Zone: 50 #Easting: 240992.578 Northing: 7620442.472 #Latitude: -21 30 ' 0.00000 '' Longitude: 114 30 ' 0.00000 '' lat_long = [[-21.5,114.5],[-21,114.5],[-21,115]] time_step_count = 6 time_step = 100 tide = 9000000 base_name, files = self.write_mux(lat_long, time_step_count, time_step) urs_ungridded2sww(base_name, mean_stage=tide, origin =(50,23432,4343), mint=0, maxt=100000) # now I want to check the sww file ... sww_file = base_name + '.sww' #Let's interigate the sww file # Note, the sww info is not gridded. It is point data. fid = NetCDFFile(sww_file) # Make x and y absolute geo_reference = Geo_reference(NetCDFObject=fid) points = geo_reference.get_absolute(map(None, fid.variables['x'][:], fid.variables['y'][:])) points = ensure_numeric(points) x = points[:,0] #Check the time vector times = fid.variables['time'][:] times_actual = [0,100,200,300,400,500] assert num.allclose(ensure_numeric(times), ensure_numeric(times_actual)) #Check first value stage = fid.variables['stage'][:] assert num.allclose(stage[0], x +tide) fid.close() self.delete_mux(files) os.remove(sww_file)