def test_storms(): dt = 500.0 uplift = 0.0001 mean_duration = 100.0 mean_interstorm = 400.0 mean_depth = 5.0 storm_run_time = 3000000.0 delta_t = 500.0 mg = RasterModelGrid((10, 10), xy_spacing=1000.0) mg.add_zeros("topographic__elevation", at="node") z = mg.zeros(at="node") mg["node"]["topographic__elevation"] = z + np.random.rand(len(z)) / 1000.0 mg.add_zeros("water__unit_flux_in", at="node") precip = PrecipitationDistribution( mean_storm_duration=mean_duration, mean_interstorm_duration=mean_interstorm, mean_storm_depth=mean_depth, total_t=storm_run_time, delta_t=delta_t, ) fr = FlowAccumulator(mg, flow_director="D8") sp = StreamPowerEroder( mg, K_sp=0.0001, m_sp=0.5, n_sp=1.0, threshold_sp=1.0, discharge_field="surface_water__discharge", ) for ( interval_duration, rainfall_rate, ) in precip.yield_storm_interstorm_duration_intensity(): if rainfall_rate != 0.0: mg.at_node["water__unit_flux_in"].fill(rainfall_rate) fr.run_one_step() sp.run_one_step(dt) mg.at_node["topographic__elevation"][mg.core_nodes] += ( uplift * interval_duration)
def test_storms(): input_file_string = os.path.join(_THIS_DIR, "drive_sp_params_storms.txt") inputs = ModelParameterDictionary(input_file_string, auto_type=True) nrows = inputs.read_int("nrows") ncols = inputs.read_int("ncols") dx = inputs.read_float("dx") dt = inputs.read_float("dt") uplift = inputs.read_float("uplift_rate") mean_duration = inputs.read_float("mean_storm") mean_interstorm = inputs.read_float("mean_interstorm") mean_depth = inputs.read_float("mean_depth") storm_run_time = inputs.read_float("storm_run_time") delta_t = inputs.read_float("delta_t") mg = RasterModelGrid(nrows, ncols, xy_spacing=dx) mg.add_zeros("topographic__elevation", at="node") z = mg.zeros(at="node") mg["node"]["topographic__elevation"] = z + np.random.rand(len(z)) / 1000. mg.add_zeros("water__unit_flux_in", at="node") precip = PrecipitationDistribution( mean_storm_duration=mean_duration, mean_interstorm_duration=mean_interstorm, mean_storm_depth=mean_depth, total_t=storm_run_time, delta_t=delta_t, ) fr = FlowAccumulator(mg, flow_director="D8") sp = StreamPowerEroder(mg, **inputs) for ( interval_duration, rainfall_rate, ) in precip.yield_storm_interstorm_duration_intensity(): if rainfall_rate != 0.: mg.at_node["water__unit_flux_in"].fill(rainfall_rate) fr.run_one_step() sp.run_one_step(dt) mg.at_node["topographic__elevation"][mg.core_nodes] += ( uplift * interval_duration )
def test_storms(): input_file_string = os.path.join(_THIS_DIR, "drive_sp_params_storms.txt") inputs = ModelParameterDictionary(input_file_string, auto_type=True) nrows = inputs.read_int("nrows") ncols = inputs.read_int("ncols") dx = inputs.read_float("dx") dt = inputs.read_float("dt") uplift = inputs.read_float("uplift_rate") mean_duration = inputs.read_float("mean_storm") mean_interstorm = inputs.read_float("mean_interstorm") mean_depth = inputs.read_float("mean_depth") storm_run_time = inputs.read_float("storm_run_time") delta_t = inputs.read_float("delta_t") mg = RasterModelGrid((nrows, ncols), xy_spacing=dx) mg.add_zeros("topographic__elevation", at="node") z = mg.zeros(at="node") mg["node"]["topographic__elevation"] = z + np.random.rand(len(z)) / 1000.0 mg.add_zeros("water__unit_flux_in", at="node") precip = PrecipitationDistribution( mean_storm_duration=mean_duration, mean_interstorm_duration=mean_interstorm, mean_storm_depth=mean_depth, total_t=storm_run_time, delta_t=delta_t, ) fr = FlowAccumulator(mg, flow_director="D8") sp = StreamPowerEroder(mg, **inputs) for ( interval_duration, rainfall_rate, ) in precip.yield_storm_interstorm_duration_intensity(): if rainfall_rate != 0.0: mg.at_node["water__unit_flux_in"].fill(rainfall_rate) fr.run_one_step() sp.run_one_step(dt) mg.at_node["topographic__elevation"][mg.core_nodes] += ( uplift * interval_duration)
def test_storms(): input_file_string = os.path.join(_THIS_DIR, 'drive_sp_params_storms.txt') inputs = ModelParameterDictionary(input_file_string, auto_type=True) nrows = inputs.read_int('nrows') ncols = inputs.read_int('ncols') dx = inputs.read_float('dx') dt = inputs.read_float('dt') time_to_run = inputs.read_float('run_time') uplift = inputs.read_float('uplift_rate') mean_duration = inputs.read_float('mean_storm') mean_interstorm = inputs.read_float('mean_interstorm') mean_depth = inputs.read_float('mean_depth') storm_run_time = inputs.read_float('storm_run_time') delta_t = inputs.read_float('delta_t') mg = RasterModelGrid(nrows, ncols, dx) mg.add_zeros('topographic__elevation', at='node') z = mg.zeros(at='node') mg['node']['topographic__elevation'] = z + np.random.rand(len(z)) / 1000. mg.add_zeros('water__unit_flux_in', at='node') precip = PrecipitationDistribution( mean_storm_duration=mean_duration, mean_interstorm_duration=mean_interstorm, mean_storm_depth=mean_depth, total_t=storm_run_time, delta_t=delta_t) fr = FlowAccumulator(mg, flow_director='D8') sp = StreamPowerEroder(mg, **inputs) for (interval_duration, rainfall_rate) in \ precip.yield_storm_interstorm_duration_intensity(): if rainfall_rate != 0.: mg.at_node['water__unit_flux_in'].fill(rainfall_rate) fr.run_one_step() sp.run_one_step(dt) mg.at_node['topographic__elevation'][ mg.core_nodes] += uplift * interval_duration
def test_storms(): input_file_string = os.path.join(_THIS_DIR, 'drive_sp_params_storms.txt') inputs = ModelParameterDictionary(input_file_string, auto_type=True) nrows = inputs.read_int('nrows') ncols = inputs.read_int('ncols') dx = inputs.read_float('dx') dt = inputs.read_float('dt') time_to_run = inputs.read_float('run_time') uplift = inputs.read_float('uplift_rate') mean_duration = inputs.read_float('mean_storm') mean_interstorm = inputs.read_float('mean_interstorm') mean_depth = inputs.read_float('mean_depth') storm_run_time = inputs.read_float('storm_run_time') delta_t = inputs.read_float('delta_t') mg = RasterModelGrid(nrows, ncols, dx) mg.add_zeros('topographic__elevation', at='node') z = mg.zeros(at='node') mg['node']['topographic__elevation'] = z + np.random.rand(len(z)) / 1000. mg.add_zeros('water__unit_flux_in', at='node') precip = PrecipitationDistribution(mean_storm_duration = mean_duration, mean_interstorm_duration = mean_interstorm, mean_storm_depth = mean_depth, total_t = storm_run_time, delta_t = delta_t) fr = FlowAccumulator(mg, flow_director='D8') sp = StreamPowerEroder(mg, **inputs) for (interval_duration, rainfall_rate) in \ precip.yield_storm_interstorm_duration_intensity(): if rainfall_rate != 0.: mg.at_node['water__unit_flux_in'].fill(rainfall_rate) fr.run_one_step() sp.run_one_step(dt) mg.at_node['topographic__elevation'][ mg.core_nodes] += uplift * interval_duration
# load the Fastscape module too, to allow direct comparison fsp = FastscapeEroder(mg, input_file_string) try: # raise NameError mg = copy.deepcopy(mg_mature) except NameError: print("building a new grid...") out_interval = 50000. last_trunc = time_to_run # we use this to trigger taking an output plot # run to a steady state: # We're going to cheat by running Fastscape SP for the first part of the solution for ( interval_duration, rainfall_rate, ) in precip.yield_storm_interstorm_duration_intensity(): if rainfall_rate != 0.: mg.at_node["water__unit_flux_in"].fill(rainfall_rate) mg = fr.run_one_step() # print 'Area: ', numpy.max(mg.at_node['drainage_area']) mg, _, _ = sp.erode( mg, interval_duration, Q_if_used="surface_water__discharge", K_if_used="K_values", ) # add uplift mg.at_node["topographic__elevation"][mg.core_nodes] += ( uplift * interval_duration) this_trunc = precip.elapsed_time // out_interval if this_trunc != last_trunc: # a new loop round
#set up its boundary conditions (left, top, right, bottom is inactive) mg.set_closed_boundaries_at_grid_edges(False, True, False, True) # Display initialization message print('Running ...') #instantiate the components: pr = PrecipitationDistribution(input_file) fr = Flow(mg) sp = Fsc(mg, input_file) hd = Diff(mg, input_file) ####################RUN track_uplift = 0 #track cumulative uplift to know top of hard layer last_trunc = runtime for (interval_duration, rainfall_rate) in pr.yield_storm_interstorm_duration_intensity(): if rainfall_rate != 0.: # note diffusion also only happens when it's raining... _ = fr.route_flow() _ = sp.erode(mg, interval_duration, K_if_used='K_values') _ = hd.diffuse(interval_duration) track_uplift += uplift_rate * interval_duration #top of beginning surface mg.at_node['topographic__elevation'][mg.core_nodes] += uplift_rate * interval_duration this_trunc = pr.elapsed_time // t_plot if this_trunc != last_trunc: # time to plot a new profile! print ('Time %d' % (t_plot * this_trunc)) last_trunc = this_trunc else: pass #check where hard rocks and soft rocks are, change k to reflect this
class StochasticDischargeHortonianModel(_ErosionModel): """ A StochasticDischargeHortonianModel generates a random sequency of runoff events across a topographic surface, calculating the resulting water discharge at each node. """ def __init__(self, input_file=None, params=None): """Initialize the StochasticDischargeHortonianModel.""" # Call ErosionModel's init super(StochasticDischargeHortonianModel, self).__init__(input_file=input_file, params=params) # Instantiate components self.flow_router = FlowRouter(self.grid, **self.params) self.lake_filler = DepressionFinderAndRouter(self.grid, **self.params) self.rain_generator = \ PrecipitationDistribution(delta_t=self.params['dt'], total_time=self.params['run_duration'], **self.params) # Add a field for discharge if 'surface_water__discharge' not in self.grid.at_node: self.grid.add_zeros('node', 'surface_water__discharge') self.discharge = self.grid.at_node['surface_water__discharge'] # Get the infiltration-capacity parameter self.infilt = self.params['infiltration_capacity'] # Run flow routing and lake filler (only once, because we are not # not changing topography) self.flow_router.run_one_step() self.lake_filler.map_depressions() def reset_random_seed(self): """Re-set the random number generation sequence.""" try: seed = self.params['random_seed'] except KeyError: seed = 0 self.rain_generator.seed_generator(seedval=seed) def run_one_step(self, dt): """ Advance model for one time-step of duration dt. """ # Calculate discharge field area = self.grid.at_node['drainage_area'] if self.infilt > 0.0: runoff = self.rain_rate - (self.infilt * (1.0 - np.exp(-self.rain_rate / self.infilt))) else: runoff = self.rain_rate self.discharge[:] = runoff * area def run_for(self, dt, runtime): """ Run model without interruption for a specified time period. """ self.rain_generator.delta_t = dt self.rain_generator.run_time = runtime for (tr, p) in self.rain_generator.yield_storm_interstorm_duration_intensity(): self.rain_rate = p self.run_one_step(tr) def write_storm_sequence_to_file(self, filename=None): """ Write event duration and intensity to a formatted text file. """ # Re-seed the random number generator, so we get the same sequence. self.reset_random_seed() # Generate a set of event parameters. This is needed because the # PrecipitationDistribution component automatically generates a # parameter set on initialization. Therefore, to get to the same # starting point that we used in the sequence-through-time, we need # to regenerate these. self.rain_generator.get_precipitation_event_duration() self.rain_generator.get_interstorm_event_duration() self.rain_generator.get_storm_depth() self.rain_generator.get_storm_intensity() # Open a file for writing if filename is None: filename = 'event_sequence.txt' stormfile = open(filename, 'w') # Set the generator's time step and run time to the full duration of # the run. This ensures that we get a sequence that is as long as the # model run, and does not split events by time step (unlike the actual # model run) self.rain_generator.delta_t = self.params['run_duration'] self.rain_generator.run_time = self.params['run_duration'] tt = 0.0 for (tr, p) in self.rain_generator.yield_storm_interstorm_duration_intensity(): runoff = p - self.infilt * (1.0 - np.exp(-p / self.infilt)) stormfile.write(str(tt) + ',' + str(p) + ',' + str(runoff) + '\n') tt += tr stormfile.write(str(tt) + ',' + str(p) + ',' + str(runoff) + '\n') # Close the file stormfile.close()
#fsp = FastscapeEroder(mg, input_file_string) precip = PrecipitationDistribution(input_file=input_file_string) #load the Fastscape module too, to allow direct comparison fsp = FastscapeEroder(mg, input_file_string) try: #raise NameError mg = copy.deepcopy(mg_mature) except NameError: print('building a new grid...') out_interval = 50000. last_trunc = time_to_run #we use this to trigger taking an output plot #run to a steady state: #We're going to cheat by running Fastscape SP for the first part of the solution for (interval_duration, rainfall_rate) in precip.yield_storm_interstorm_duration_intensity(): if rainfall_rate != 0.: mg.at_node['water__unit_flux_in'].fill(rainfall_rate) mg = fr.run_one_step() #print 'Area: ', numpy.max(mg.at_node['drainage_area']) mg,_,_ = sp.erode(mg, interval_duration, Q_if_used='surface_water__discharge', K_if_used='K_values') #add uplift mg.at_node['topographic__elevation'][mg.core_nodes] += uplift*interval_duration this_trunc = precip.elapsed_time//out_interval if this_trunc != last_trunc: #a new loop round print('made it to loop ', out_interval*this_trunc) last_trunc=this_trunc mg_mature = copy.deepcopy(mg) else:
# load the Fastscape module too, to allow direct comparison fsp = FastscapeEroder(mg, input_file_string) try: # raise NameError mg = copy.deepcopy(mg_mature) except NameError: print("building a new grid...") out_interval = 50000. last_trunc = time_to_run # we use this to trigger taking an output plot # run to a steady state: # We're going to cheat by running Fastscape SP for the first part of the solution for ( interval_duration, rainfall_rate, ) in precip.yield_storm_interstorm_duration_intensity(): if rainfall_rate != 0.: mg.at_node["water__unit_flux_in"].fill(rainfall_rate) mg = fr.run_one_step() # print 'Area: ', numpy.max(mg.at_node['drainage_area']) mg, _, _ = sp.erode( mg, interval_duration, Q_if_used="surface_water__discharge", K_if_used="K_values", ) # add uplift mg.at_node["topographic__elevation"][mg.core_nodes] += ( uplift * interval_duration ) this_trunc = precip.elapsed_time // out_interval