def main(): """ This driver takes in a DEM of a subwatershed from the Chiricahua Mountains, Arizona and routes a storm across it using the default input file (overland_flow_input.txt). This has two ways to look at the data: at one point (generating a hydrograph and looking for temporal changes in water depth, etc...) and across the grid for spatial patterns. """ # This provides us with an initial time. At the end, it gives us total # model run time in seconds. start_time = time.time() # This is the DEM of the subwatershed from the Chiricahua Mountains, Arizona dem_name = 'chiri.asc' # Now we can create and initialize a raster model grid by reading a DEM # First, this looks for the DEM in the overland_flow folder in Landlab DATA_FILE = os.path.join(os.path.dirname(__file__), dem_name) # This print statement verifies that we are opening the data file. print('Reading data from "'+str(DATA_FILE)+'"') # Now the ASCII is read, assuming that it it standard ESRI format. (rg, z) = read_esri_ascii(DATA_FILE) # Whatever the NODATA value is in the DEM is needed here to set bounary condition. nodata_val=-9999 # Modify the grid DEM to set all NODATA nodes to inactive boundaries rg.set_nodata_nodes_to_inactive(z, nodata_val) # This prints standard grid characteristics (rows, columns and cell size) print('DEM has ' + str(rg.number_of_node_rows) + ' rows, ' + str(rg.number_of_node_columns) + ' columns, and cell size ' + str(rg.dx)) # Right now, the outlet must be explicitly set for boundary conditions # using the row and column from the DEM. the_outlet_row = 152 the_outlet_column = 230 # This converts the grid row and column into coordinates that the raster grid will recognize the_outlet_node = rg.grid_coords_to_node_id(the_outlet_row, the_outlet_column) # The outlet node is set as a fixed value boundary rg.set_fixed_value_boundaries(the_outlet_node) # To plot the grid, we can call the plot_topography() function plot_topography(rg, z) # Now we will initialize the Overland Flow component. of=OverlandFlow(rg) # First, the flow_at_one_node() method will be covered here. # When using the flow_at_one_node() method, a study node is needed to sample at. # This should not be a boundary node! study_row = 122 study_column = 140 # This takes the study row and study column grid coordinates and converts it # to a node ID that the raster grid will recognize. study_node = rg.grid_coords_to_node_id(study_row, study_column) # Because this function reads in data using the Model Parameter Dictionary # from the default input file, the only arguments needed to run the flow_at_one_node() # method is the RasterModelGrid instance, the initial elevations and the study node # coordinates. # This is the standard way to call the flow_at_one_node method using the input file. of.flow_at_one_node(rg, z, study_node) # Once run, we can plot the output of.plot_at_one_node() # If you did not want to use the input file and instead define the total model run time of # rainfall intensity and storm duration, the commented function call below demonstrates this with # the following parameters: # Total model run time: 6000 seconds # Storm intensity: (9.2177*(10**-6)) meters per second. # Storm duration: 5868 seconds #of.flow_at_one_node(rg, z, study_node, 6000, (9.2177*(10**-6)),5868) # Now the flow_across_grid() method will be discussed. The commands needed to # run this method are triple-commented ('###') for convenience. All flow_at_one_node() # methods calls *should* be commented out to run this driver quicker. # Again, this function reads in data using the ModelParameterDictionary and the default # input file. The only required arguments for this method are the RasterModelGrid instance # and the the initial elevations. # This is the standard call to the flow_across_grid() method ###of.flow_across_grid(rg,z) # And these are the calls to plot the rasters ###of.plot_water_depths(rg) ###of.plot_discharge(rg) ###of.plot_shear_stress_grid(rg) ###of.plot_slopes(rg) # To forgo the call to the input file and define model run time, rainfall # intensity and storm duration in the function call itself, the following command # can be used with the following parameters: # Total model run time: 6000 seconds # Storm intensity: (9.2177*(10**-6)) meters per second. # Storm duration: 5868 seconds ###of.flow_across_grid(rg, z, 6000, (9.2177*(10**-6)), 5868) endtime = time.time() print endtime - start_time, "seconds" #If you call the plot_topography method... plt.show()
str(rg.number_of_node_columns) + ' columns, and cell size ' + str(rg.dx))) # Right now, the outlet must be explicitly set for boundary conditions # using the row and column from the DEM. the_outlet_row = 1 the_outlet_column = 29 # This converts the grid row and column into coordinates that the raster grid will recognize the_outlet_node = rg.grid_coords_to_node_id(the_outlet_row, the_outlet_column) # The outlet node is set as a fixed value boundary rg.set_fixed_value_boundaries(the_outlet_node) # Now we will initialize the Overland Flow component. of=OverlandFlow(rg) # First, the flow_at_one_node() method will be covered here. # When using the flow_at_one_node() method, a study node is needed to sample at. # This should not be a boundary node! # To use the flow_at_one_node() method, uncomment out every line with ('##') ##study_row = 5 ##study_column = 26 # This takes the study row and study column grid coordinates and converts it # to a node ID that the raster grid will recognize. ##study_node = rg.grid_coords_to_node_id(study_row, study_column)
print('DEM has ' + str(rg.number_of_node_rows) + ' rows, ' + str(rg.number_of_node_columns) + ' columns, and cell size ' + str(rg.dx)) # Right now, the outlet must be explicitly set for boundary conditions # using the row and column from the DEM. the_outlet_row = 1 the_outlet_column = 29 # This converts the grid row and column into coordinates that the raster grid will recognize the_outlet_node = rg.grid_coords_to_node_id(the_outlet_row, the_outlet_column) # The outlet node is set as a fixed value boundary rg.set_fixed_value_boundaries(the_outlet_node) # Now we will initialize the Overland Flow component. of = OverlandFlow(rg) # First, the flow_at_one_node() method will be covered here. # When using the flow_at_one_node() method, a study node is needed to sample at. # This should not be a boundary node! # To use the flow_at_one_node() method, uncomment out every line with ('##') ##study_row = 5 ##study_column = 26 # This takes the study row and study column grid coordinates and converts it # to a node ID that the raster grid will recognize. ##study_node = rg.grid_coords_to_node_id(study_row, study_column)
def main(): """ This driver takes in a DEM of a subwatershed from the Chiricahua Mountains, Arizona and routes a storm across it using the default input file (overland_flow_input.txt). This has two ways to look at the data: at one point (generating a hydrograph and looking for temporal changes in water depth, etc...) and across the grid for spatial patterns. """ # This provides us with an initial time. At the end, it gives us total # model run time in seconds. start_time = time.time() # This is the DEM of the subwatershed from the Chiricahua Mountains, Arizona dem_name = 'chiri.asc' # Now we can create and initialize a raster model grid by reading a DEM # First, this looks for the DEM in the overland_flow folder in Landlab DATA_FILE = os.path.join(os.path.dirname(__file__), dem_name) # This print statement verifies that we are opening the data file. print('Reading data from "' + str(DATA_FILE) + '"') # Now the ASCII is read, assuming that it it standard ESRI format. (rg, z) = read_esri_ascii(DATA_FILE) # Whatever the NODATA value is in the DEM is needed here to set bounary condition. nodata_val = -9999 # Modify the grid DEM to set all NODATA nodes to inactive boundaries rg.set_nodata_nodes_to_inactive(z, nodata_val) # This prints standard grid characteristics (rows, columns and cell size) print('DEM has ' + str(rg.number_of_node_rows) + ' rows, ' + str(rg.number_of_node_columns) + ' columns, and cell size ' + str(rg.dx)) # Right now, the outlet must be explicitly set for boundary conditions # using the row and column from the DEM. the_outlet_row = 152 the_outlet_column = 230 # This converts the grid row and column into coordinates that the raster grid will recognize the_outlet_node = rg.grid_coords_to_node_id(the_outlet_row, the_outlet_column) # The outlet node is set as a fixed value boundary rg.set_fixed_value_boundaries(the_outlet_node) # To plot the grid, we can call the plot_topography() function plot_topography(rg, z) # Now we will initialize the Overland Flow component. of = OverlandFlow(rg) # First, the flow_at_one_node() method will be covered here. # When using the flow_at_one_node() method, a study node is needed to sample at. # This should not be a boundary node! study_row = 122 study_column = 140 # This takes the study row and study column grid coordinates and converts it # to a node ID that the raster grid will recognize. study_node = rg.grid_coords_to_node_id(study_row, study_column) # Because this function reads in data using the Model Parameter Dictionary # from the default input file, the only arguments needed to run the flow_at_one_node() # method is the RasterModelGrid instance, the initial elevations and the study node # coordinates. # This is the standard way to call the flow_at_one_node method using the input file. of.flow_at_one_node(rg, z, study_node) # Once run, we can plot the output of.plot_at_one_node() # If you did not want to use the input file and instead define the total model run time of # rainfall intensity and storm duration, the commented function call below demonstrates this with # the following parameters: # Total model run time: 6000 seconds # Storm intensity: (9.2177*(10**-6)) meters per second. # Storm duration: 5868 seconds #of.flow_at_one_node(rg, z, study_node, 6000, (9.2177*(10**-6)),5868) # Now the flow_across_grid() method will be discussed. The commands needed to # run this method are triple-commented ('###') for convenience. All flow_at_one_node() # methods calls *should* be commented out to run this driver quicker. # Again, this function reads in data using the ModelParameterDictionary and the default # input file. The only required arguments for this method are the RasterModelGrid instance # and the the initial elevations. # This is the standard call to the flow_across_grid() method ###of.flow_across_grid(rg,z) # And these are the calls to plot the rasters ###of.plot_water_depths(rg) ###of.plot_discharge(rg) ###of.plot_shear_stress_grid(rg) ###of.plot_slopes(rg) # To forgo the call to the input file and define model run time, rainfall # intensity and storm duration in the function call itself, the following command # can be used with the following parameters: # Total model run time: 6000 seconds # Storm intensity: (9.2177*(10**-6)) meters per second. # Storm duration: 5868 seconds ###of.flow_across_grid(rg, z, 6000, (9.2177*(10**-6)), 5868) endtime = time.time() print endtime - start_time, "seconds" #If you call the plot_topography method... plt.show()
def main(): """ initialize DEM Get storm info Generate hydrograph """ start_time = time.time() dem_name = 'HalfFork.asc' input_file = 'input_data.txt' IT_FILE = os.path.join(os.path.dirname(__file__), input_file) # Create and initialize a raster model grid by reading a DEM DATA_FILE = os.path.join(os.path.dirname(__file__), dem_name) print('Reading data from "' + str(DATA_FILE) + '"') (rg, z) = read_esri_ascii(DATA_FILE) nodata_val = -9999 # Modify the grid DEM to set all nodata nodes to inactive boundaries rg.set_nodata_nodes_to_inactive( z, nodata_val) # set nodata nodes to inactive bounds print('DEM has ' + str(rg.number_of_node_rows) + ' rows, ' + str(rg.number_of_node_columns) + ' columns, and cell size ' + str(rg.dx)) # Select point to sample at. #study_row = 110 #study_column = 150 # #study_node = rg.grid_coords_to_node_id(study_row, study_column) ## Set outlet point to set boundary conditions. the_outlet_row = 240 the_outlet_column = 215 the_outlet_node = rg.grid_coords_to_node_id(the_outlet_row, the_outlet_column) rg.set_fixed_value_boundaries(the_outlet_node) # Get a 2D array version of the elevations for plotting purposes elev_raster = rg.node_vector_to_raster(z, True) # Everything below plots the topography and sampling points # levels = [] # x_up = 1990 # while x_up !=2200: # levels.append(x_up) # x_up+=1 # plt.figure('Topography') # plt.contourf(elev_raster, levels, colors='k')#('r','g','b')) # plt.set_cmap('bone') # plt.colorbar() # # plt.plot([150],[109],'cs', label= 'Study Node') # plt.plot([215],[9], 'wo', label= 'Outlet') # plt.legend(loc=3) pd = PrecipitationDistribution() pd.initialize() duration_hrs = pd.storm_duration intensity_mmhr = pd.intensity duration_secs = duration_hrs * 60.0 * 60.0 intensity_ms = ((intensity_mmhr / 1000.0) / 3600.0) total_duration_secs = 1.25 * duration_secs #print 'total_duration_secs: ', total_duration_secs of = OverlandFlow() #IT_FILE,rg,0) of.initialize(rg) ## (-,-,-,-,how long we route overland flow, intensity in m/s, duration of storm) ## ## Trial 1, 10 year storm ## #of.flow_at_one_node(rg,z,study_node,900,(7.167*(10**-6)), 2916) #of.flow_at_one_node(rg, z, study_node,9000, (1.384*(10**-5)), 2916) #of.flow_at_one_node(rg, z, study_node,900, (7.06*(10**-6)), 900) #of.plot_at_one_node() of.flow_across_grid(rg, z, 5800, (9.2177 * (10**-6)), 5868) #of.flow_at_one_node(rg,z,study_node,150,(9.2177*(10**-6)),5868) of.plot_water_depths(rg) of.plot_discharge(rg) of.plot_shear_stress_grid(rg) of.plot_slopes(rg) #rg.display_grid() endtime = time.time() print endtime - start_time, "seconds" plt.show() plt.show() plt.show()
def main(): """ initialize DEM Get storm info Generate hydrograph """ start_time = time.time() dem_name = 'HalfFork.asc' input_file = 'input_data.txt' IT_FILE = os.path.join(os.path.dirname(__file__), input_file) # Create and initialize a raster model grid by reading a DEM DATA_FILE = os.path.join(os.path.dirname(__file__), dem_name) print('Reading data from "'+str(DATA_FILE)+'"') (rg, z) = read_esri_ascii(DATA_FILE) nodata_val=-9999 # Modify the grid DEM to set all nodata nodes to inactive boundaries rg.set_nodata_nodes_to_inactive(z, nodata_val) # set nodata nodes to inactive bounds print('DEM has ' + str(rg.number_of_node_rows) + ' rows, ' + str(rg.number_of_node_columns) + ' columns, and cell size ' + str(rg.dx)) # Select point to sample at. study_row = 110 study_column = 150 study_node = rg.grid_coords_to_node_id(study_row, study_column) ## Set outlet point to set boundary conditions. the_outlet_row = 240 the_outlet_column = 215 the_outlet_node = rg.grid_coords_to_node_id(the_outlet_row, the_outlet_column) rg.set_fixed_value_boundaries(the_outlet_node) # Get a 2D array version of the elevations for plotting purposes elev_raster = rg.node_vector_to_raster(z,True) # Everything below plots the topography and sampling points levels = [] x_up = 1990 while x_up !=2200: levels.append(x_up) x_up+=1 s = plt.contourf(elev_raster, levels, colors='k')#('r','g','b')) plt.set_cmap('bone') cb = plt.colorbar() plt.plot([150],[109],'cs', label= 'Study Node') plt.plot([215],[9], 'wo', label= 'Outlet') plt.legend(loc=3) of=OverlandFlow()#IT_FILE,rg,0) of.initialize(rg) ## (-,-,-,-,how long we route overland flow, intensity in m/s, duration of storm) ## ## Trial 1, 10 year storm ## of.calculate_flow_at_one_point(rg,z,study_node,90,(7.167*(10**-6)), 2916) plt.show()
def main(): """ initialize DEM Get storm info Generate hydrograph """ start_time = time.time() dem_name = 'HalfFork.asc' input_file = 'input_data.txt' IT_FILE = os.path.join(os.path.dirname(__file__), input_file) # Create and initialize a raster model grid by reading a DEM DATA_FILE = os.path.join(os.path.dirname(__file__), dem_name) print('Reading data from "' + str(DATA_FILE) + '"') (rg, z) = read_esri_ascii(DATA_FILE) nodata_val = -9999 # Modify the grid DEM to set all nodata nodes to inactive boundaries rg.set_nodata_nodes_to_inactive( z, nodata_val) # set nodata nodes to inactive bounds print('DEM has ' + str(rg.number_of_node_rows) + ' rows, ' + str(rg.number_of_node_columns) + ' columns, and cell size ' + str(rg.dx)) # Select point to sample at. study_row = 110 study_column = 150 study_node = rg.grid_coords_to_node_id(study_row, study_column) ## Set outlet point to set boundary conditions. the_outlet_row = 240 the_outlet_column = 215 the_outlet_node = rg.grid_coords_to_node_id(the_outlet_row, the_outlet_column) rg.set_fixed_value_boundaries(the_outlet_node) # Get a 2D array version of the elevations for plotting purposes elev_raster = rg.node_vector_to_raster(z, True) # Everything below plots the topography and sampling points levels = [] x_up = 1990 while x_up != 2200: levels.append(x_up) x_up += 1 s = plt.contourf(elev_raster, levels, colors='k') #('r','g','b')) plt.set_cmap('bone') cb = plt.colorbar() plt.plot([150], [109], 'cs', label='Study Node') plt.plot([215], [9], 'wo', label='Outlet') plt.legend(loc=3) of = OverlandFlow() #IT_FILE,rg,0) of.initialize(rg) ## (-,-,-,-,how long we route overland flow, intensity in m/s, duration of storm) ## ## Trial 1, 10 year storm ## of.calculate_flow_at_one_point(rg, z, study_node, 90, (7.167 * (10**-6)), 2916) plt.show()
def main(): """ initialize DEM Get storm info Generate hydrograph """ start_time = time.time() dem_name = 'HalfFork.asc' input_file = 'input_data.txt' IT_FILE = os.path.join(os.path.dirname(__file__), input_file) # Create and initialize a raster model grid by reading a DEM DATA_FILE = os.path.join(os.path.dirname(__file__), dem_name) print('Reading data from "'+str(DATA_FILE)+'"') (rg, z) = read_esri_ascii(DATA_FILE) nodata_val=-9999 # Modify the grid DEM to set all nodata nodes to inactive boundaries rg.set_nodata_nodes_to_inactive(z, nodata_val) # set nodata nodes to inactive bounds print('DEM has ' + str(rg.number_of_node_rows) + ' rows, ' + str(rg.number_of_node_columns) + ' columns, and cell size ' + str(rg.dx)) # Select point to sample at. #study_row = 110 #study_column = 150 # #study_node = rg.grid_coords_to_node_id(study_row, study_column) ## Set outlet point to set boundary conditions. the_outlet_row = 240 the_outlet_column = 215 the_outlet_node = rg.grid_coords_to_node_id(the_outlet_row, the_outlet_column) rg.set_fixed_value_boundaries(the_outlet_node) # Get a 2D array version of the elevations for plotting purposes elev_raster = rg.node_vector_to_raster(z,True) # Everything below plots the topography and sampling points # levels = [] # x_up = 1990 # while x_up !=2200: # levels.append(x_up) # x_up+=1 # plt.figure('Topography') # plt.contourf(elev_raster, levels, colors='k')#('r','g','b')) # plt.set_cmap('bone') # plt.colorbar() # # plt.plot([150],[109],'cs', label= 'Study Node') # plt.plot([215],[9], 'wo', label= 'Outlet') # plt.legend(loc=3) pd = PrecipitationDistribution() pd.initialize() duration_hrs = pd.storm_duration intensity_mmhr = pd.intensity duration_secs = duration_hrs*60.0*60.0 intensity_ms = ((intensity_mmhr/1000.0)/3600.0) total_duration_secs = 1.25 * duration_secs #print 'total_duration_secs: ', total_duration_secs of=OverlandFlow()#IT_FILE,rg,0) of.initialize(rg) ## (-,-,-,-,how long we route overland flow, intensity in m/s, duration of storm) ## ## Trial 1, 10 year storm ## #of.flow_at_one_node(rg,z,study_node,900,(7.167*(10**-6)), 2916) #of.flow_at_one_node(rg, z, study_node,9000, (1.384*(10**-5)), 2916) #of.flow_at_one_node(rg, z, study_node,900, (7.06*(10**-6)), 900) #of.plot_at_one_node() of.flow_across_grid(rg, z, 5800, (9.2177*(10**-6)), 5868) #of.flow_at_one_node(rg,z,study_node,150,(9.2177*(10**-6)),5868) of.plot_water_depths(rg) of.plot_discharge(rg) of.plot_shear_stress_grid(rg) of.plot_slopes(rg) #rg.display_grid() endtime = time.time() print endtime - start_time, "seconds" plt.show() plt.show() plt.show()