def open_new_cs_file(self, file_name, info=None, var_name='X', long_name='Unknown', units_name='None', dtype='float32', time_units='minutes', nx=None, ny=None, dx=None, dy=None): #--------------------------- # Was grid info provided ? #--------------------------- if (info is not None): info.file_name = file_name info.data_type = rti_files.get_rti_data_type(dtype) if (nx is not None): info.ncols = nx if (ny is not None): info.nrows = ny if (dx is not None): info.xres = dx if (dy is not None): info.yres = dy else: if (nx is not None) and (ny is not None) and \ (dx is not None) and (dy is not None): info = rti_files.make_info(file_name, nx, ny, dx, dy) else: print 'ERROR during open_new_cs_file().' print ' Grid info not provided.' print ' ' ## return -1 #-------------------------------------------- # Open new netCDF file to write curbe stacks # using var_name to build variable names #-------------------------------------------- try: nccs_unit_str = "self." + var_name + "_nccs_unit" nccs_file_str = "self." + var_name + "_nccs_file" cs_file_str = "self." + var_name + "_cs_file" exec(nccs_file_str + "= file_utils.replace_extension(" + cs_file_str + ", '.nc')") exec(nccs_unit_str + "=" + "nccs_files.nccs_file()") exec(nccs_unit_str + ".open_new_file(" + nccs_file_str + ", self.rti, var_name, long_name, units_name, " + "dtype=dtype, " + ## (11/5/13) "time_units=time_units)") MAKE_RT3 = False except: print 'ERROR: Unable to open new netCDF file:' exec("print ' ', self." + var_name + "_nccs_file") print ' ' print 'Will write cube stack in generic RT3 format.' print ' ' MAKE_RT3 = True
def open_new_cs_file(self, file_name, info=None, var_name='X', long_name='Unknown', units_name='None', dtype='float32', time_units='minutes', nx=None, ny=None, dx=None, dy=None): #--------------------------- # Was grid info provided ? #--------------------------- if (info != None): info.file_name = file_name info.data_type = rti_files.get_rti_data_type( dtype ) if (nx != None): info.ncols = nx if (ny != None): info.nrows = ny if (dx != None): info.xres = dx if (dy != None): info.yres = dy else: if (nx != None) and (ny != None) and \ (dx != None) and (dy != None): info = rti_files.make_info( file_name, nx, ny, dx, dy ) else: print 'ERROR during open_new_cs_file().' print ' Grid info not provided.' print ' ' ## return -1 #-------------------------------------------- # Open new netCDF file to write curbe stacks # using var_name to build variable names #-------------------------------------------- try: nccs_unit_str = "self." + var_name + "_nccs_unit" nccs_file_str = "self." + var_name + "_nccs_file" cs_file_str = "self." + var_name + "_cs_file" exec( nccs_file_str + "= file_utils.replace_extension(" + cs_file_str + ", '.nc')" ) exec( nccs_unit_str + "=" + "nccs_files.nccs_file()" ) exec( nccs_unit_str + ".open_new_file(" + nccs_file_str + ", self.rti, var_name, long_name, units_name, " + "dtype=dtype, " + ## (11/5/13) "time_units=time_units)" ) MAKE_RT3 = False except: print 'ERROR: Unable to open new netCDF file:' exec( "print ' ', self." + var_name + "_nccs_file" ) print ' ' print 'Will write cube stack in generic RT3 format.' print ' ' MAKE_RT3 = True
def open_new_gs_file(self, file_name, info=None, var_name='X', long_name='Unknown', units_name='None', dtype='float32', time_units='minutes', nx=None, ny=None, dx=None, dy=None): #--------------------------- # Was grid info provided ? #--------------------------- if (info != None): info.file_name = file_name info.data_type = rti_files.get_rti_data_type( dtype ) if (nx != None): info.ncols = nx if (ny != None): info.nrows = ny if (dx != None): info.xres = dx if (dy != None): info.yres = dy else: if (nx != None) and (ny != None) and \ (dx != None) and (dy != None): info = rti_files.make_info( file_name, nx, ny, dx, dy ) else: print 'ERROR during open_new_gs_file().' print ' Grid info not provided.' print ' ' ## return -1 #--------------------------------------------- # Get long_name and units_name from var_name #--------------------------------------------- # long_name = self.get_var_long_name( var_name ) # units_name = self.get_var_units( var_name ) # dtype = self.get_var_type( var_name ) #--------------------------------- # Build strings to be used below #--------------------------------- ncgs_unit_str = "self." + var_name + "_ncgs_unit" ncgs_file_str = "self." + var_name + "_ncgs_file" gs_file_str = "self." + var_name + "_gs_file" #------------------- # For testing only #------------------- # print 'ncgs_unit_str =', ncgs_unit_str # print 'ncgs_file_str =', ncgs_file_str # print 'gs_file_str =', gs_file_str # print 'var_name =', var_name # print 'long_name =', long_name # print 'units_name =', units_name # print 'time_units =', time_units # print ' ' #-------------------------------------------- # Open new netCDF file to write grid stacks # using var_name to build variable names #-------------------------------------------- # Note that "dtype" was not included in the # last TopoFlow version (always float32), # but Erode needs other types. #-------------------------------------------- try: exec( ncgs_file_str + "= file_utils.replace_extension(" + gs_file_str + ", '.nc')" ) exec( ncgs_unit_str + "=" + "ncgs_files.ncgs_file()" ) exec( ncgs_unit_str + ".open_new_file(" + ncgs_file_str + ", self.rti, var_name, long_name, units_name, " + "dtype=dtype, " + "time_units=time_units)" ) MAKE_RTS = False except: print 'ERROR: Unable to open new netCDF file:' exec( "print ' '," + ncgs_file_str ) print ' ' print 'Will write grid stack in generic RTS format.' print ' ' MAKE_RTS = True #------------------------------------------- # Always save grid stacks in an RTS file ? #-------------------------------------------------- # Note that if PyNIO is missing, we don't get # an exception above and MAKE_RTS is still False. #-------------------------------------------------- MAKE_RTS = True ##### ## print '#################################' ## print 'MAKE_RTS =', MAKE_RTS ## print '#################################' #--------------------------------- # Build strings to be used below #--------------------------------- rts_unit_str = "self." + var_name + "_rts_unit" rts_file_str = "self." + var_name + "_rts_file" gs_file_str = "self." + var_name + "_gs_file" #------------------------------------------ # Open new RTS files to write grid stacks #------------------------------------------ if (MAKE_RTS): try: exec( rts_file_str + "= file_utils.replace_extension(" + gs_file_str + ", '.rts')" ) exec( rts_unit_str + " = rts_files.rts_file()" ) exec( rts_unit_str + ".open_new_file(" + rts_file_str + ", self.rti, var_name, " + "dtype=dtype, " + "MAKE_BOV=True)" ) except: print 'ERROR: Unable to open new RTS file:' exec( "print ' '," + rts_file_str ) # exec( "print ' ', self." + var_name + "_rts_file" ) print ' '
def unit_test(nx=4, ny=5, VERBOSE=False, file_name="TEST_FILE.rtg"): print 'Running unit_test()...' #------------------------------------ # Make instance of rtg_file() class #------------------------------------ rtg = rtg_file() dx = 100 dy = 100 #--------------------------------- # These are unused for RTG files #--------------------------------- ## grid_name = "depth" ## long_name = "depth of water" ## units_name = "meters" info = rti_files.make_info( file_name, nx, ny, dx, dy ) OK = rtg.open_new_file( file_name, info, ADD_INDEX=True ) #---------------------------------------------- # This also works if RTI file already exists. #---------------------------------------------- # OK = rtg.open_new_file( file_name ) if not(OK): print 'ERROR during open_new_file().' return grid = numpy.arange(nx * ny, dtype='Float32') grid = grid.reshape( (ny, nx) ) ### print 'AT START: (nx, ny) =', nx, ny #--------------------------- # Write a grid to the file #--------------------------- rtg.write_grid( grid, VERBOSE=True ) #------------------------------------- # Re-open the file and read the grid #----------------------------------------------------------- # The file_name of the file we created is not "file_name", # but now includes a time index. It was saved in rtg, so # call rtg.open_file() with no argument to use that name. #----------------------------------------------------------- OK = rtg.open_file() ## print 'NOW: (nx, ny) =', rtg.nx, rtg.ny if not(OK): return print 'rtg.byte_swap_needed() =', rtg.byte_swap_needed() print ' ' grid = rtg.read_grid( VERBOSE=True ) print 'grid = ' print grid #------------------------------------------- # Write another grid, with next time index #------------------------------------------- OK = rtg.open_new_file( file_name, info, ADD_INDEX=True) rtg.write_grid( grid + 1, VERBOSE=True)
def save_matlab_dem_as_rtg(self, prefix='Animas_200'): import scipy.io import rti_files print 'Saving MatLab file DEM to RTG file...' mat_file = (prefix + '.mat') rtg_file = (prefix + '_DEM.rtg') vars = scipy.io.loadmat(mat_file) cellsize = np.float64(vars['cellsize']) easting = np.float64(vars['easting']) northing = np.float64(vars['northing']) topo = np.float64(vars['topo']) ny, nx = topo.shape dx = cellsize dy = cellsize print ' (nx, ny) =', nx, ny print ' (dx, dy) =', dx, dy file_unit = open(rtg_file, 'wb') topo = np.float32(topo) data_type = 'FLOAT' ## topo = np.float64(topo) ## data_type = 'DOUBLE' topo.tofile(file_unit) file_unit.close() ## class info: ## grid_file = rtg_file ## data_source = 'Converted from Animas_200.mat, M. Kessler' ## ncols = nx ## nrows = ny ## data_type = 'FLOAT' ## byte_order = 'LSB' ## pixel_geom = 1 # (ASSUMES fixed-length, e.g. UTM) ## xres = dx # [meters] ## yres = dy # [meters] ## zres = 1.0 ####################### CHECK THIS ## z_units = 'METERS' ## y_south_edge = northing.min() ## y_north_edge = y_south_edge + (ny * dy) ## x_west_edge = easting.min() ## x_east_edge = x_west_edge + (nx * dx) ## box_units = 'METERS' ## gmin = topo.min() ## gmax = topo.max() ## UTM_zone = 'UNKNOWN' #------------------------------------ # Create an RTI file with grid info #------------------------------------ rti_files.make_info( rtg_file, ncols=nx, nrows=ny, xres=dx, yres=dy, data_source='Converted from Animas_200.mat, M. Kessler', y_south_edge=northing.min(), x_west_edge=easting.min(), gmin=topo.min(), gmax=topo.max()) ### box_units='METERS', z_units='METERS') RTI_filename = (prefix + '.rti') rti_files.write_info(RTI_filename, info) print 'Finished.' print ' '
def make_fractal_surface(n_levels, H=1.5, RTG_file=None, sigma=float64(1), scale=float64(1), seed=168993, X_WRAP=False, Y_WRAP=False, SILENT=False): #--------------------------------------------------------- # Notes: Can apply SCALE at very end. A value of about # 0.01 should give results similar to Howard's # MATRIX_2D with ERROR=0.02. # H is a fractal exponent of some kind. # Set the X_WRAP or Y_WRAP keywords in order to # impose periodic boundaries on the left & right # or top & bottom, respectively. # If n_levels = 7, nx = 129 # If n_levels = 8, nx = 257 # If n_levels = 9, nx = 513 # If n_levels = 10, nx = 1025 # If n_levels = 11, nx = 2049 #---------------------------------------------------------- if (n_levels > 11): print '********************************************' print ' ERROR: Max number of levels is 11,' print ' which gives a grid size of 2049 x 2049.' print '********************************************' print ' ' return if not (SILENT): print 'Creating a fractal surface...' #------------------ # Initialize vars #------------------ factor = float64(1) / sqrt(float64(2)**H) ############# nx = (int32(2)**n_levels) + 1 ny = nx step = nx - 1 if not (SILENT): print 'nx, ny =', nx, ',', ny #---------------------------------------------- x_vec = numpy.arange(nx, dtype='Int16') y_vec = numpy.arange(ny, dtype='Int16') cols, rows = numpy.meshgrid(x_vec, y_vec) ## rows = reshape(repeat(y_vec, nx), (ny, nx)) ## cols = rot90(rows) # (will work if nx=ny) sum_grid = (cols + rows) #---------------------------------------------- DONE = zeros([ny, nx], dtype='UInt8') DONE[0, 0] = 1 DONE[0, nx - 1] = 1 DONE[ny - 1, 0] = 1 DONE[ny - 1, nx - 1] = 1 #---------------------------------------------- EDGE = zeros([ny, nx], dtype='UInt8') EDGE[:, 0] = 1 EDGE[:, nx - 1] = 1 EDGE[0, :] = 1 EDGE[ny - 1, :] = 1 #------------------------------ # Initialize grid of z-values #------------------------------ numpy.random.seed(seed) v = random.normal(loc=0.0, scale=1.0, size=(2, 2)) z = zeros([ny, nx], dtype='Float64') z[0, 0] = v[0, 0] z[0, nx - 1] = v[0, 1] z[ny - 1, 0] = v[1, 0] z[ny - 1, nx - 1] = v[1, 1] #------------------------------------ if (X_WRAP): z[0, nx - 1] = z[0, 0] z[ny - 1, nx - 1] = z[ny - 1, 0] if (Y_WRAP): z[ny - 1, 0] = z[0, 0] z[ny - 1, nx - 1] = z[0, nx - 1] #------------------------------------ zF = z.flat ## (an iterator to allow 1D indexing) ########## for k in xrange(1, (n_levels + 1)): if not (SILENT): print 'Working on level', k step = (step / 2) #--------------------------------------- # Get midpoint locations of this level #--------------------------------------- w = where(logical_and(logical_and(logical_and(((cols.flat % step) == 0), \ ((rows.flat % step) == 0)), logical_not(DONE.flat)), logical_not(EDGE.flat))) n_mid = size(w[0]) ######################### # Need this !! ######################### w = w[0] #----------------------------------------- # Break these into two groups, w1 and w2 #----------------------------------------- a1 = where((sum_grid.flat[w] % (2 * step)) == 0) # (1D array) n1 = size(a1[0]) a2 = where((sum_grid.flat[w] % (2 * step)) != 0) # (1D array) n2 = size(a2[0]) if (n1 != 0): w1 = w[a1[0]] if (n2 != 0): w2 = w[a2[0]] #--------------------------------------------- # Compute midpoint elevations as the average # of the diagonal neighbor elevations plus # a rescaled Gaussian random variable #--------------------------------------------- UL = w1 - step * (nx + 1) UR = w1 - step * (nx - 1) LL = w1 + step * (nx - 1) LR = w1 + step * (nx + 1) #--------------------------- ### numpy.random.seed(seed) ran = factor * sigma * random.normal(loc=0.0, scale=1.0, size=n1) zF[w1] = ((zF[UL] + zF[UR] + zF[LL] + zF[LR]) / float64(4)) + ran DONE.flat[w1] = 1 #---------------------------------------------- # Compute midpoint elevations of remaining # pixels at this scale as the average of the # nearest neighbor elevations plus a rescaled # Gaussian random variable. n2=0 at start. #---------------------------------------------- if (n2 != 0): T = w2 - (step * nx) B = w2 + (step * nx) R = w2 + step L = w2 - step #---------------------------- ### numpy.random.seed(seed) ran = factor * sigma * random.normal(loc=0.0, scale=1.0, size=n2) zF[w2] = ((zF[T] + zF[B] + zF[L] + zF[R]) / float64(4)) + ran DONE.flat[w2] = 1 #-------------------------------------------- # Compute elevations of edge pixels at this # scale as average of 3 nearest neighbors # plus a rescaled Gaussian random variable. #-------------------------------------------- jump = (step * nx) #---------------------------- L = where(logical_and(logical_and((cols.flat == 0), \ ((rows.flat % step) == 0)), \ logical_not(DONE.flat))) nL = size(L[0]) T = L - jump B = L + jump R = L + step ### numpy.random.seed(seed) ran = factor * sigma * random.normal(loc=0.0, scale=1.0, size=nL) zF[L] = ((zF[T] + zF[B] + zF[R]) / float64(3)) + ran DONE.flat[L] = 1 #----------------------------------------------------------------------------- R = where(logical_and(logical_and((cols.flat == (nx - 1)), \ ((rows.flat % step) == 0)), \ logical_not(DONE.flat))) nR = size(R[0]) if not (X_WRAP): L = R - step T = R - jump B = R + jump ### numpy.random.seed(seed) ran = factor * sigma * random.normal(loc=0.0, scale=1.0, size=nR) zF[R] = ((zF[L] + zF[T] + zF[B]) / float64(3)) + ran else: zF[R] = zF[L] DONE.flat[R] = 1 #----------------------------------------------------------------------------- T = where(logical_and(logical_and((rows.flat == 0), \ ((cols.flat % step) == 0)), \ logical_not(DONE.flat))) nT = size(T[0]) L = T - step R = T + step B = T + jump ### numpy.random.seed(seed) ran = factor * sigma * random.normal(loc=0.0, scale=1.0, size=nT) zF[T] = ((zF[L] + zF[R] + zF[B]) / float64(3)) + ran DONE.flat[T] = 1 #----------------------------------------------------------------------------- B = where(logical_and(logical_and((rows.flat == (ny - 1)), \ ((cols.flat % step) == 0)), \ logical_not(DONE.flat))) nB = size(B[0]) if not (Y_WRAP): L = B - step R = B + step T = B - jump ### numpy.random.seed(seed) ran = factor * sigma * random.normal(loc=0.0, scale=1.0, size=nB) zF[B] = ((zF[L] + zF[R] + zF[T]) / float64(3)) + ran else: zF[B] = zF[T] DONE.flat[B] = 1 #----------------------------------------------------------------------------- #----------------------- # Rescale the values ? #----------------------- if (scale != 1.0): z = (z * scale) #------------------------------------------- # Option to save to RTG file with RTI file #------------------------------------------- if (RTG_file is not None): ############################### # CHECK FOR OVERWRITE HERE ! ############################### ############################### info = rti_files.make_info(RTG_file, nx, ny, xres=100.0, yres=100.0, gmin=z.min(), gmax=z.max(), data_source="Midpoint displacement method") rti_files.write_info(RTG_file, info) RTG_type = 'FLOAT' ## RTG_type = 'DOUBLE' rtg_files.write_grid(z, RTG_file, info, RTG_type=RTG_type) #---------------------- # Print final message #---------------------- if not (SILENT): print 'Finished.' print ' ' return z
def open_new_gs_file(self, file_name, info=None, var_name='X', long_name='Unknown', units_name='None', dtype='float32', time_units='minutes', nx=None, ny=None, dx=None, dy=None): #--------------------------- # Was grid info provided ? #--------------------------- if (info is not None): info.file_name = file_name info.data_type = rti_files.get_rti_data_type(dtype) if (nx is not None): info.ncols = nx if (ny is not None): info.nrows = ny if (dx is not None): info.xres = dx if (dy is not None): info.yres = dy else: if (nx is not None) and (ny is not None) and \ (dx is not None) and (dy is not None): info = rti_files.make_info(file_name, nx, ny, dx, dy) else: print 'ERROR during open_new_gs_file().' print ' Grid info not provided.' print ' ' ## return -1 #--------------------------------------------- # Get long_name and units_name from var_name #--------------------------------------------- # long_name = self.get_var_long_name( var_name ) # units_name = self.get_var_units( var_name ) # dtype = self.get_var_type( var_name ) #--------------------------------- # Build strings to be used below #--------------------------------- ncgs_unit_str = "self." + var_name + "_ncgs_unit" ncgs_file_str = "self." + var_name + "_ncgs_file" gs_file_str = "self." + var_name + "_gs_file" #------------------- # For testing only #------------------- # print 'ncgs_unit_str =', ncgs_unit_str # print 'ncgs_file_str =', ncgs_file_str # print 'gs_file_str =', gs_file_str # print 'var_name =', var_name # print 'long_name =', long_name # print 'units_name =', units_name # print 'time_units =', time_units # print ' ' #-------------------------------------------- # Open new netCDF file to write grid stacks # using var_name to build variable names #-------------------------------------------- # Note that "dtype" was not included in the # last TopoFlow version (always float32), # but Erode needs other types. #-------------------------------------------- try: # gs_filename = getattr( self, (var_name + '_gs_file') ) # setattr( self, (var_name + '_ncgs_file'), # file_utils.replace_extension( gs_filename, '.nc') ) # setattr( self, (var_name + '_ncgs_unit'), ncgs_files.ncgs_file() ) # setattr( self, (var_name + '_ncgs_unit'), # # exec( ncgs_unit_str + ".open_new_file(" + ncgs_file_str + # ", self.rti, var_name, long_name, units_name, " + # "dtype=dtype, " + # "time_units=time_units)" ) #-------------------------------------------------------------- exec(ncgs_file_str + "= file_utils.replace_extension(" + gs_file_str + ", '.nc')") exec(ncgs_unit_str + "=" + "ncgs_files.ncgs_file()") exec(ncgs_unit_str + ".open_new_file(" + ncgs_file_str + ", self.rti, var_name, long_name, units_name, " + "dtype=dtype, " + "time_units=time_units)") MAKE_RTS = False except: print 'ERROR: Unable to open new netCDF file:' exec("print ' '," + ncgs_file_str) print ' ' print 'Will write grid stack in generic RTS format.' print ' ' MAKE_RTS = True #------------------------------------------- # Always save grid stacks in an RTS file ? #-------------------------------------------------- # Note that if PyNIO is missing, we don't get # an exception above and MAKE_RTS is still False. #-------------------------------------------------- MAKE_RTS = True ##### ## print '#################################' ## print 'MAKE_RTS =', MAKE_RTS ## print '#################################' #--------------------------------- # Build strings to be used below #--------------------------------- rts_unit_str = "self." + var_name + "_rts_unit" rts_file_str = "self." + var_name + "_rts_file" gs_file_str = "self." + var_name + "_gs_file" #------------------------------------------ # Open new RTS files to write grid stacks #------------------------------------------ if (MAKE_RTS): try: exec(rts_file_str + "= file_utils.replace_extension(" + gs_file_str + ", '.rts')") exec(rts_unit_str + " = rts_files.rts_file()") exec(rts_unit_str + ".open_new_file(" + rts_file_str + ", self.rti, var_name, " + "dtype=dtype, " + "MAKE_BOV=True)") except: print 'ERROR: Unable to open new RTS file:' exec("print ' '," + rts_file_str) # exec( "print ' ', self." + var_name + "_rts_file" ) print ' '
def unit_test(nx=4, ny=5, VERBOSE=False, file_name="TEST_FILE.rtg"): print 'Running unit_test()...' #------------------------------------ # Make instance of rtg_file() class #------------------------------------ rtg = rtg_file() dx = 100 dy = 100 #--------------------------------- # These are unused for RTG files #--------------------------------- ## grid_name = "depth" ## long_name = "depth of water" ## units_name = "meters" info = rti_files.make_info(file_name, nx, ny, dx, dy) OK = rtg.open_new_file(file_name, info, ADD_INDEX=True) #---------------------------------------------- # This also works if RTI file already exists. #---------------------------------------------- # OK = rtg.open_new_file( file_name ) if not (OK): print 'ERROR during open_new_file().' return grid = numpy.arange(nx * ny, dtype='Float32') grid = grid.reshape((ny, nx)) ### print 'AT START: (nx, ny) =', nx, ny #--------------------------- # Write a grid to the file #--------------------------- rtg.write_grid(grid, VERBOSE=True) #------------------------------------- # Re-open the file and read the grid #----------------------------------------------------------- # The file_name of the file we created is not "file_name", # but now includes a time index. It was saved in rtg, so # call rtg.open_file() with no argument to use that name. #----------------------------------------------------------- OK = rtg.open_file() ## print 'NOW: (nx, ny) =', rtg.nx, rtg.ny if not (OK): return print 'rtg.byte_swap_needed() =', rtg.byte_swap_needed() print ' ' grid = rtg.read_grid(VERBOSE=True) print 'grid = ' print grid #------------------------------------------- # Write another grid, with next time index #------------------------------------------- OK = rtg.open_new_file(file_name, info, ADD_INDEX=True) rtg.write_grid(grid + 1, VERBOSE=True)
def unit_test(nx=4, ny=5, n_grids=6, VERBOSE=False, file_name="NCGS_Grid_Test.nc"): print 'Running unit_test()...' #------------------------------------- # Make instance of ncgs_file() class #------------------------------------- ncgs = ncgs_file() dx = 100 dy = 100 var_name = "depth" info = rti_files.make_info(file_name, nx, ny, dx, dy) OK = ncgs.open_new_file(file_name, info, dtype='float32', var_name=var_name, long_name="depth of water", units_name="meters", comment="Created by TopoFlow 3.0.") if not (OK): print 'ERROR during open_new_file().' return grid = np.arange(nx * ny, dtype='Float32') grid = grid.reshape((ny, nx)) #----------------------------------------------- # (6/10/10) Can use this to test new ability # of add_grid() to convert from scalar to grid #----------------------------------------------- # grid = np.float32(0) #---------------------------------- # Add some test grids to the file #---------------------------------- print 'Writing grids to NCGS file...' for time_index in xrange(n_grids): ncgs.add_grid(grid, var_name) ## ncgs.add_grid( grid, var_name, time_index ) grid = (grid + 1) if (VERBOSE): print self.ncgs_unit # (print a summary) ncgs.close_file() print 'Finished writing NCGS file: ' + file_name print ' ' #--------------------------------------------- # Re-open the file and read grids one-by-one #--------------------------------------------- OK = ncgs.open_file(file_name) if not (OK): return print 'Reading grids from NCGS file: ' for time_index in xrange(n_grids): grid = ncgs.get_grid(var_name, time_index) print 'grid[' + str(time_index) + '] = ' print grid print '-----------------------------------------------' ncgs.close_file() print 'Finished reading NCGS file: ' + file_name print ' '
def make_fractal_surface(n_levels, H=1.5, RTG_file=None, sigma=float64(1), scale=float64(1), seed=168993, X_WRAP=False, Y_WRAP=False, SILENT=False): #--------------------------------------------------------- # Notes: Can apply SCALE at very end. A value of about # 0.01 should give results similar to Howard's # MATRIX_2D with ERROR=0.02. # H is a fractal exponent of some kind. # Set the X_WRAP or Y_WRAP keywords in order to # impose periodic boundaries on the left & right # or top & bottom, respectively. # If n_levels = 7, nx = 129 # If n_levels = 8, nx = 257 # If n_levels = 9, nx = 513 # If n_levels = 10, nx = 1025 # If n_levels = 11, nx = 2049 #---------------------------------------------------------- if (n_levels > 11): print '********************************************' print ' ERROR: Max number of levels is 11,' print ' which gives a grid size of 2049 x 2049.' print '********************************************' print ' ' return if not(SILENT): print 'Creating a fractal surface...' #------------------ # Initialize vars #------------------ factor = float64(1) / sqrt(float64(2) ** H) ############# nx = (int32(2) ** n_levels) + 1 ny = nx step = nx - 1 if not(SILENT): print 'nx, ny =', nx, ',', ny #---------------------------------------------- x_vec = numpy.arange(nx, dtype='Int16') y_vec = numpy.arange(ny, dtype='Int16') cols, rows = numpy.meshgrid( x_vec, y_vec ) ## rows = reshape(repeat(y_vec, nx), (ny, nx)) ## cols = rot90(rows) # (will work if nx=ny) sum_grid = (cols + rows) #---------------------------------------------- DONE = zeros([ny, nx], dtype='UInt8') DONE[0,0] = 1 DONE[0,nx - 1] = 1 DONE[ny - 1,0] = 1 DONE[ny - 1,nx - 1] = 1 #---------------------------------------------- EDGE = zeros([ny, nx], dtype='UInt8') EDGE[:,0] = 1 EDGE[:,nx - 1] = 1 EDGE[0,:] = 1 EDGE[ny - 1,:] = 1 #------------------------------ # Initialize grid of z-values #------------------------------ numpy.random.seed(seed) v = random.normal(loc=0.0, scale=1.0, size=(2, 2)) z = zeros([ny, nx], dtype='Float64') z[0,0] = v[0,0] z[0,nx - 1] = v[0,1] z[ny - 1,0] = v[1,0] z[ny - 1,nx - 1] = v[1,1] #------------------------------------ if (X_WRAP): z[0,nx - 1] = z[0,0] z[ny - 1,nx - 1] = z[ny - 1,0] if (Y_WRAP): z[ny - 1,0] = z[0,0] z[ny - 1,nx - 1] = z[0,nx - 1] #------------------------------------ zF = z.flat ## (an iterator to allow 1D indexing) ########## for k in xrange( 1, (n_levels + 1) ): if not(SILENT): print 'Working on level', k step = (step / 2) #--------------------------------------- # Get midpoint locations of this level #--------------------------------------- w = where(logical_and(logical_and(logical_and(((cols.flat % step) == 0), \ ((rows.flat % step) == 0)), logical_not(DONE.flat)), logical_not(EDGE.flat))) n_mid = size(w[0]) ######################### # Need this !! ######################### w = w[0] #----------------------------------------- # Break these into two groups, w1 and w2 #----------------------------------------- a1 = where((sum_grid.flat[w] % (2 * step)) == 0) # (1D array) n1 = size(a1[0]) a2 = where((sum_grid.flat[w] % (2 * step)) != 0) # (1D array) n2 = size(a2[0]) if (n1 != 0): w1 = w[a1[0]] if (n2 != 0): w2 = w[a2[0]] #--------------------------------------------- # Compute midpoint elevations as the average # of the diagonal neighbor elevations plus # a rescaled Gaussian random variable #--------------------------------------------- UL = w1 - step * (nx + 1) UR = w1 - step * (nx - 1) LL = w1 + step * (nx - 1) LR = w1 + step * (nx + 1) #--------------------------- ### numpy.random.seed(seed) ran = factor * sigma * random.normal(loc=0.0, scale=1.0, size=n1) zF[w1] = ((zF[UL] + zF[UR] + zF[LL] + zF[LR]) / float64(4)) + ran DONE.flat[w1] = 1 #---------------------------------------------- # Compute midpoint elevations of remaining # pixels at this scale as the average of the # nearest neighbor elevations plus a rescaled # Gaussian random variable. n2=0 at start. #---------------------------------------------- if (n2 != 0): T = w2 - (step * nx) B = w2 + (step * nx) R = w2 + step L = w2 - step #---------------------------- ### numpy.random.seed(seed) ran = factor * sigma * random.normal(loc=0.0, scale=1.0, size=n2) zF[w2] = ((zF[T] + zF[B] + zF[L] + zF[R]) / float64(4)) + ran DONE.flat[w2] = 1 #-------------------------------------------- # Compute elevations of edge pixels at this # scale as average of 3 nearest neighbors # plus a rescaled Gaussian random variable. #-------------------------------------------- jump = (step * nx) #---------------------------- L = where(logical_and(logical_and((cols.flat == 0), \ ((rows.flat % step) == 0)), \ logical_not(DONE.flat))) nL = size(L[0]) T = L - jump B = L + jump R = L + step ### numpy.random.seed(seed) ran = factor * sigma * random.normal(loc=0.0, scale=1.0, size=nL) zF[L] = ((zF[T] + zF[B] + zF[R]) / float64(3)) + ran DONE.flat[L] = 1 #----------------------------------------------------------------------------- R = where(logical_and(logical_and((cols.flat == (nx - 1)), \ ((rows.flat % step) == 0)), \ logical_not(DONE.flat))) nR = size(R[0]) if not(X_WRAP): L = R - step T = R - jump B = R + jump ### numpy.random.seed(seed) ran = factor * sigma * random.normal(loc=0.0, scale=1.0, size=nR) zF[R] = ((zF[L] + zF[T] + zF[B]) / float64(3)) + ran else: zF[R] = zF[L] DONE.flat[R] = 1 #----------------------------------------------------------------------------- T = where(logical_and(logical_and((rows.flat == 0), \ ((cols.flat % step) == 0)), \ logical_not(DONE.flat))) nT = size(T[0]) L = T - step R = T + step B = T + jump ### numpy.random.seed(seed) ran = factor * sigma * random.normal(loc=0.0, scale=1.0, size=nT) zF[T] = ((zF[L] + zF[R] + zF[B]) / float64(3)) + ran DONE.flat[T] = 1 #----------------------------------------------------------------------------- B = where(logical_and(logical_and((rows.flat == (ny - 1)), \ ((cols.flat % step) == 0)), \ logical_not(DONE.flat))) nB = size(B[0]) if not(Y_WRAP): L = B - step R = B + step T = B - jump ### numpy.random.seed(seed) ran = factor * sigma * random.normal(loc=0.0, scale=1.0, size=nB) zF[B] = ((zF[L] + zF[R] + zF[T]) / float64(3)) + ran else: zF[B] = zF[T] DONE.flat[B] = 1 #----------------------------------------------------------------------------- #----------------------- # Rescale the values ? #----------------------- if (scale != 1.0): z = (z * scale) #------------------------------------------- # Option to save to RTG file with RTI file #------------------------------------------- if (RTG_file != None): ############################### # CHECK FOR OVERWRITE HERE ! ############################### ############################### info = rti_files.make_info( RTG_file, nx, ny, xres=100.0, yres=100.0, gmin=z.min(), gmax=z.max(), data_source="Midpoint displacement method" ) rti_files.write_info(RTG_file, info) RTG_type = 'FLOAT' ## RTG_type = 'DOUBLE' rtg_files.write_grid( z, RTG_file, info, RTG_type=RTG_type) #---------------------- # Print final message #---------------------- if not(SILENT): print 'Finished.' print ' ' return z
def unit_test(nx=4, ny=5, n_grids=6, VERBOSE=False, file_name="TEST_FILE.rts"): print 'Running unit_test()...' #------------------------------------ # Make instance of rts_file() class #------------------------------------ rts = rts_file() dx = 100 dy = 100 #--------------------------------- # These are unused for RTS files #--------------------------------- ## grid_name = "depth" ## long_name = "depth of water" ## units_name = "meters" info = rti_files.make_info(file_name, nx, ny, dx, dy) OK = rts.open_new_file(file_name, info) if not (OK): print 'ERROR during open_new_file().' return grid = numpy.arange(nx * ny, dtype='Float32') grid = grid.reshape((ny, nx)) #---------------------------------- # Add some test grids to the file #---------------------------------- for time_index in xrange(n_grids): rts.add_grid(grid) grid = (grid + 1) rts.close_file() print 'Finished writing file: ' + file_name print ' ' #--------------------------------------------- # Re-open the file and read grids one-by-one #--------------------------------------------- OK = rts.open_file(file_name) if not (OK): return n_grids = rts.number_of_grids() print 'Reading grids from RTS file: ' print 'rts.number_of_grids() =', n_grids print 'rts.byte_swap_needed() =', rts.byte_swap_needed() print ' ' for time_index in xrange(n_grids): grid = rts.get_grid(time_index) print 'grid[' + str(time_index) + '] = ' print grid print '-----------------------------------------------' #---------------------------- # Go back and read 2nd grid #---------------------------- grid = rts.get_grid(1) print ' ' print 'Reading second grid again...' print 'Second grid =' print grid print '-----------------------------------------------' rts.close_file() print 'Finished reading file: ' + file_name print ' ' #--------------------------------------- # Re-open the file and change one grid #--------------------------------------- print 'Updating RTS file:', file_name grid = numpy.ones((ny, nx), dtype='Float32') OK = rts.open_file(file_name, UPDATE=True) if not (OK): return rts.add_grid(grid, time_index=0) rts.close_file() print 'Finished updating RTS file.' print ' ' #--------------------------------------------- # Re-open the file and read grids one-by-one #--------------------------------------------- OK = rts.open_file(file_name) if not (OK): return n_grids = rts.number_of_grids() print 'Reading grids from RTS file: ' print 'rts.number_of_grids() =', n_grids print 'rts.byte_swap_needed() =', rts.byte_swap_needed() print ' ' for time_index in xrange(n_grids): grid = rts.get_grid(time_index) print 'grid[' + str(time_index) + '] = ' print grid print '-----------------------------------------------' rts.close_file() print 'Finished reading file: ' + file_name print ' '
def unit_test(nx=4, ny=5, n_grids=6, VERBOSE=False, file_name="TEST_FILE.rts"): print 'Running unit_test()...' #------------------------------------ # Make instance of rts_file() class #------------------------------------ rts = rts_file() dx = 100 dy = 100 #--------------------------------- # These are unused for RTS files #--------------------------------- ## grid_name = "depth" ## long_name = "depth of water" ## units_name = "meters" info = rti_files.make_info( file_name, nx, ny, dx, dy ) OK = rts.open_new_file( file_name, info ) if not(OK): print 'ERROR during open_new_file().' return grid = numpy.arange(nx * ny, dtype='Float32') grid = grid.reshape( (ny, nx) ) #---------------------------------- # Add some test grids to the file #---------------------------------- for time_index in xrange(n_grids): rts.add_grid( grid ) grid = (grid + 1) rts.close_file() print 'Finished writing file: ' + file_name print ' ' #--------------------------------------------- # Re-open the file and read grids one-by-one #--------------------------------------------- OK = rts.open_file( file_name ) if not(OK): return n_grids = rts.number_of_grids() print 'Reading grids from RTS file: ' print 'rts.number_of_grids() =', n_grids print 'rts.byte_swap_needed() =', rts.byte_swap_needed() print ' ' for time_index in xrange(n_grids): grid = rts.get_grid( time_index ) print 'grid[' + str(time_index) + '] = ' print grid print '-----------------------------------------------' #---------------------------- # Go back and read 2nd grid #---------------------------- grid = rts.get_grid( 1 ) print ' ' print 'Reading second grid again...' print 'Second grid =' print grid print '-----------------------------------------------' rts.close_file() print 'Finished reading file: ' + file_name print ' ' #--------------------------------------- # Re-open the file and change one grid #--------------------------------------- print 'Updating RTS file:', file_name grid = numpy.ones( (ny, nx), dtype='Float32' ) OK = rts.open_file( file_name, UPDATE=True ) if not(OK): return rts.add_grid( grid, time_index=0 ) rts.close_file() print 'Finished updating RTS file.' print ' ' #--------------------------------------------- # Re-open the file and read grids one-by-one #--------------------------------------------- OK = rts.open_file( file_name ) if not(OK): return n_grids = rts.number_of_grids() print 'Reading grids from RTS file: ' print 'rts.number_of_grids() =', n_grids print 'rts.byte_swap_needed() =', rts.byte_swap_needed() print ' ' for time_index in xrange(n_grids): grid = rts.get_grid( time_index ) print 'grid[' + str(time_index) + '] = ' print grid print '-----------------------------------------------' rts.close_file() print 'Finished reading file: ' + file_name print ' '
def save_matlab_dem_as_rtg(self, prefix='Animas_200'): import scipy.io import rti_files print 'Saving MatLab file DEM to RTG file...' mat_file = (prefix + '.mat') rtg_file = (prefix + '_DEM.rtg') vars = scipy.io.loadmat( mat_file ) cellsize = np.float64(vars['cellsize']) easting = np.float64(vars['easting']) northing = np.float64(vars['northing']) topo = np.float64(vars['topo']) ny, nx = topo.shape dx = cellsize dy = cellsize print ' (nx, ny) =', nx, ny print ' (dx, dy) =', dx, dy file_unit = open(rtg_file, 'wb') topo = np.float32(topo) data_type = 'FLOAT' ## topo = np.float64(topo) ## data_type = 'DOUBLE' topo.tofile(file_unit) file_unit.close() ## class info: ## grid_file = rtg_file ## data_source = 'Converted from Animas_200.mat, M. Kessler' ## ncols = nx ## nrows = ny ## data_type = 'FLOAT' ## byte_order = 'LSB' ## pixel_geom = 1 # (ASSUMES fixed-length, e.g. UTM) ## xres = dx # [meters] ## yres = dy # [meters] ## zres = 1.0 ####################### CHECK THIS ## z_units = 'METERS' ## y_south_edge = northing.min() ## y_north_edge = y_south_edge + (ny * dy) ## x_west_edge = easting.min() ## x_east_edge = x_west_edge + (nx * dx) ## box_units = 'METERS' ## gmin = topo.min() ## gmax = topo.max() ## UTM_zone = 'UNKNOWN' #------------------------------------ # Create an RTI file with grid info #------------------------------------ rti_files.make_info( rtg_file, ncols=nx, nrows=ny, xres=dx, yres=dy, data_source= 'Converted from Animas_200.mat, M. Kessler', y_south_edge=northing.min(), x_west_edge=easting.min(), gmin=topo.min(), gmax=topo.max()) ### box_units='METERS', z_units='METERS') RTI_filename = (prefix + '.rti') rti_files.write_info( RTI_filename, info ) print 'Finished.' print ' '
def unit_test(nx=4, ny=5, n_grids=6, VERBOSE=False, file_name="NCGS_Grid_Test.nc"): print 'Running unit_test()...' #------------------------------------- # Make instance of ncgs_file() class #------------------------------------- ncgs = ncgs_file() dx = 100 dy = 100 var_name = "depth" info = rti_files.make_info( file_name, nx, ny, dx, dy ) OK = ncgs.open_new_file( file_name, info, dtype='float32', var_name=var_name, long_name="depth of water", units_name="meters", comment="Created by TopoFlow 3.0.") if not(OK): print 'ERROR during open_new_file().' return grid = numpy.arange(nx * ny, dtype='Float32') grid = grid.reshape( (ny, nx) ) #----------------------------------------------- # (6/10/10) Can use this to test new ability # of add_grid() to convert from scalar to grid #----------------------------------------------- # grid = numpy.float32(0) #---------------------------------- # Add some test grids to the file #---------------------------------- print 'Writing grids to NCGS file...' for time_index in xrange(n_grids): ncgs.add_grid( grid, var_name ) ## ncgs.add_grid( grid, var_name, time_index ) grid = (grid + 1) if (VERBOSE): print self.ncgs_unit # (print a summary) ncgs.close_file() print 'Finished writing NCGS file: ' + file_name print ' ' #--------------------------------------------- # Re-open the file and read grids one-by-one #--------------------------------------------- OK = ncgs.open_file( file_name ) if not(OK): return print 'Reading grids from NCGS file: ' for time_index in xrange(n_grids): grid = ncgs.get_grid(var_name, time_index) print 'grid[' + str(time_index) + '] = ' print grid print '-----------------------------------------------' ncgs.close_file() print 'Finished reading NCGS file: ' + file_name print ' '
def open_new_gs_file(self, file_name, info=None, var_name='X', long_name='Unknown', units_name='None', dtype='float32', time_units='minutes', nx=None, ny=None, dx=None, dy=None): #--------------------------- # Was grid info provided ? #--------------------------- if (info != None): info.file_name = file_name info.data_type = rti_files.get_rti_data_type(dtype) if (nx != None): info.ncols = nx if (ny != None): info.nrows = ny if (dx != None): info.xres = dx if (dy != None): info.yres = dy else: if (nx != None) and (ny != None) and \ (dx != None) and (dy != None): info = rti_files.make_info(file_name, nx, ny, dx, dy) else: print 'ERROR during open_new_gs_file().' print ' Grid info not provided.' print ' ' ## return -1 #-------------------------------------------- # Open new netCDF file to write grid stacks # using var_name to build variable names #-------------------------------------------- try: ncgs_unit_str = "self." + var_name + "_ncgs_unit" ncgs_file_str = "self." + var_name + "_ncgs_file" gs_file_str = "self." + var_name + "_gs_file" exec(ncgs_file_str + "= file_utils.replace_extension(" + gs_file_str + ", '.nc')") exec(ncgs_unit_str + "=" + "ncgs_files.ncgs_file()") exec(ncgs_unit_str + ".open_new_file(" + ncgs_file_str + ", self.rti, var_name, long_name, units_name, " + "time_units=time_units)") MAKE_RTS = False except: print 'ERROR: Unable to open new netCDF file:' exec("print ' ', self." + var_name + "_ncgs_file") print ' ' print 'Will write grid stack in generic RTS format.' print ' ' MAKE_RTS = True #------------------------------------------- # Always save grid stacks in an RTS file ? #------------------------------------------- MAKE_RTS = True ##### #------------------------------------------ # Open new RTS files to write grid stacks #------------------------------------------ if (MAKE_RTS): try: rts_unit_str = "self." + var_name + "_rts_unit" rts_file_str = "self." + var_name + "_rts_file" gs_file_str = "self." + var_name + "_gs_file" exec(rts_file_str + "= file_utils.replace_extension(" + gs_file_str + ", '.rts')") exec(rts_unit_str + " = rts_files.rts_file()") exec(rts_unit_str + ".open_new_file(" + rts_file_str + ", self.rti, var_name, MAKE_BOV=True)") except: print 'ERROR: Unable to open new RTS file:' exec("print ' ', self." + var_name + "_rts_file") print ' '
def open_new_gs_file(self, file_name, info=None, var_name='X', long_name='Unknown', units_name='None', dtype='float32', time_units='minutes', nx=None, ny=None, dx=None, dy=None): #--------------------------- # Was grid info provided ? #--------------------------- if (info is not None): info.file_name = file_name info.data_type = rti_files.get_rti_data_type( dtype ) if (nx is not None): info.ncols = nx if (ny is not None): info.nrows = ny if (dx is not None): info.xres = dx if (dy is not None): info.yres = dy else: if (nx is not None) and (ny is not None) and \ (dx is not None) and (dy is not None): info = rti_files.make_info( file_name, nx, ny, dx, dy ) else: print 'ERROR during open_new_gs_file().' print ' Grid info not provided.' print ' ' ## return -1 #-------------------------------------------- # Open new netCDF file to write grid stacks # using var_name to build variable names #-------------------------------------------- try: ncgs_unit_str = "self." + var_name + "_ncgs_unit" ncgs_file_str = "self." + var_name + "_ncgs_file" gs_file_str = "self." + var_name + "_gs_file" exec( ncgs_file_str + "= file_utils.replace_extension(" + gs_file_str + ", '.nc')" ) exec( ncgs_unit_str + "=" + "ncgs_files.ncgs_file()" ) exec( ncgs_unit_str + ".open_new_file(" + ncgs_file_str + ", self.rti, var_name, long_name, units_name, " + "time_units=time_units)" ) MAKE_RTS = False except: print 'ERROR: Unable to open new netCDF file:' exec( "print ' ', self." + var_name + "_ncgs_file" ) print ' ' print 'Will write grid stack in generic RTS format.' print ' ' MAKE_RTS = True #------------------------------------------- # Always save grid stacks in an RTS file ? #------------------------------------------- MAKE_RTS = True ##### #------------------------------------------ # Open new RTS files to write grid stacks #------------------------------------------ if (MAKE_RTS): try: rts_unit_str = "self." + var_name + "_rts_unit" rts_file_str = "self." + var_name + "_rts_file" gs_file_str = "self." + var_name + "_gs_file" exec( rts_file_str + "= file_utils.replace_extension(" + gs_file_str + ", '.rts')" ) exec( rts_unit_str + " = rts_files.rts_file()" ) exec( rts_unit_str + ".open_new_file(" + rts_file_str + ", self.rti, var_name, MAKE_BOV=True)" ) except: print 'ERROR: Unable to open new RTS file:' exec( "print ' ', self." + var_name + "_rts_file" ) print ' '