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
