left_is_closed=False, bottom_is_closed=False)
#Create a diagonal fault across the grid
blockuplift_nodes = np.where((mg.node_y < 55) & (mg.node_y > 45)
& (mg.node_x < 55) & (mg.node_x > 45))
z[blockuplift_nodes] += 10.0
# View the initial grid
figure()
imshow_grid(mg,
'topographic__elevation',
cmap='viridis',
grid_units=['m', 'm'])
show()
linear_diffusivity = 0.01 #in m2 per year
ld = LinearDiffuser(grid=mg, linear_diffusivity=linear_diffusivity)
dt = 100.
#Evolve landscape
for i in range(25):
ld.run_one_step(dt)
#Plot new landscape
figure()
imshow_grid(mg,
'topographic__elevation',
cmap='viridis',
grid_units=['m', 'm'])
show()
z = mg.create_node_array_zeros() + leftmost_elev
z += initial_slope * np.amax(mg.node_y) - initial_slope * mg.node_y
#put these values plus roughness into that field
mg.at_node['topographic__elevation'] = z + np.random.rand(len(z)) / 100000.
#set up grid's boundary conditions (bottom, right, top, left is inactive)
mg.set_closed_boundaries_at_grid_edges(False, True, False, True)
# Display a message
print 'Running ...'
#instantiate the components:
fr = FlowRouter(mg)
sp = FastscapeEroder(mg, input_file)
diffuse = PerronNLDiffuse(mg, input_file)
lin_diffuse = LinearDiffuser(grid=mg, input_stream=input_file)
#perform the loops:
for i in xrange(nt):
#note the input arguments here are not totally standardized between modules
#mg = diffuse.diffuse(mg, i*dt)
mg = lin_diffuse.diffuse(dt)
mg = fr.route_flow()
mg = sp.erode(mg, dt)
mg.at_node['topographic__elevation'][mg.core_nodes] += uplift_per_step
##plot long profiles along channels
pylab.figure(6)
profile_IDs = prf.channel_nodes(mg,
mg.at_node['topographic__steepest_slope'],
mg.at_node['drainage_area'],
mg.add_zeros('topographic__elevation', at='node')
# in our case, slope is zero, so the leftmost_elev is the mean elev
z = mg.zeros(at='node') + leftmost_elev
# put these values plus roughness into that field
mg['node']['topographic__elevation'] = z + np.random.rand(len(z)) / 100000.
# set up its boundary conditions (bottom, left, top, right)
# The mechanisms for this are all automated within the grid object
mg.set_fixed_value_boundaries_at_grid_edges(True, True, True, True)
# Display a message
print('Running ...')
# instantiate the components:
diffuse = PerronNLDiffuse(mg, input_file)
lin_diffuse = LinearDiffuser(grid=mg, input_stream=input_file)
# lin_diffuse.initialize(input_file)
# Perform the loops.
# First, we do the nonlinear diffusion:
# We're going to perform a block uplift of the interior of the grid, but
# leave the boundary nodes at their original elevations.
# access this function of the grid, and store the output with a local name
uplifted_nodes = mg.get_core_nodes()
#(Note: Node numbering runs across from the bottom left of the grid.)
# nt is the number of timesteps we calculated above, i.e., loop nt times.
# We never actually use i within the loop, but we could do.
for i in range(nt):
#("range" is a clever memory-saving way of producing consecutive integers to govern a loop)
len(z)
#Create a diagonal fault across the grid
fault_y = 50.0 + 0.25 * mg.node_x
upthrown_nodes = numpy.where(mg.node_y > fault_y)
z[upthrown_nodes] += 10.0 + 0.01 * mg.node_x[upthrown_nodes]
#Illustrate the grid
imshow_node_grid(mg,
'topographic__elevation',
cmap='jet',
grid_units=['m', 'm'])
show()
#Instantiate the diffusion component:
linear_diffuse = LinearDiffuser(grid=mg,
input_stream='./diffusion_input_file.txt')
#Set boundary conditions
mg.set_closed_boundaries_at_grid_edges(False, True, False, True)
#set a model timestep
#(the component will subdivide this as needed to keep things stable)
dt = 2000.
#Evolve landscape
for i in range(25):
linear_diffuse.diffuse(dt)
#Plot new landscape
figure()
imshow_node_grid(mg,
topo=Dataset('topography_wrf_hydro.nc')
topography=topo.variables['TOPOGRAPHY'][:]
topographic__elevation=np.asarray(topography, dtype=float).ravel()
mg.add_field('node', 'topographic__elevation', topographic__elevation) #create the field
#set boundary conditions -- these should match those used in the topography creation driver
for edge in (mg.nodes_at_left_edge, mg.nodes_at_right_edge):
mg.status_at_node[edge] = CLOSED_BOUNDARY
for edge in (mg.nodes_at_top_edge, mg.nodes_at_bottom_edge):
mg.status_at_node[edge] = FIXED_VALUE_BOUNDARY
#instantiate the components
fr = FlowRouter(mg)
sp = StreamPowerEroder(mg, input_file)
lin_diffuse = LinearDiffuser(mg, input_file)
print( 'Running ...' )
time_on = time.time()
#text for discharge file names
streamflow = "streamflow"
nc = ".nc"
elapsed_time = 0. #total time in simulation
#create list of all discharge files to be used, repeat as many times as necessary for run time.
#Example: here we have a total of 20 discharge files -- we need one file for every time step and we have 100 timesteps.
# We will repeat the discharge file namelist 5 times Run Time = 100 yrs dt = 1yr
rep_num = int(5) #depends on how many discharge files/time steps you have
discharge_filename=[streamflow + repr(j) + nc for k in range(rep_num) for j in range(1,21)]
z = mg.create_node_array_zeros() + leftmost_elev
z += initial_slope * np.amax(mg.node_y) - initial_slope * mg.node_y
# put these values plus roughness into that field
mg.at_node['topographic__elevation'] = z + np.random.rand(len(z)) / 100000.
# set up grid's boundary conditions (bottom, right, top, left is inactive)
mg.set_closed_boundaries_at_grid_edges(False, True, False, True)
# Display a message
print('Running ...')
# instantiate the components:
fr = FlowRouter(mg)
sp = SPEroder(mg, input_file)
diffuse = PerronNLDiffuse(mg, input_file)
lin_diffuse = LinearDiffuser(grid=mg, input_stream=input_file)
# perform the loops:
for i in xrange(nt):
# note the input arguments here are not totally standardized between modules
#mg = diffuse.diffuse(mg, i*dt)
mg = lin_diffuse.diffuse(dt)
mg = fr.route_flow()
mg = sp.erode(mg)
mg.at_node['topographic__elevation'][mg.core_nodes] += uplift_per_step
# plot long profiles along channels
pylab.figure(6)
profile_IDs = prf.channel_nodes(mg, mg.at_node['topographic__steepest_slope'],
mg.at_node['drainage_area'], mg.at_node['flow_receiver'])
dists_upstr = prf.get_distances_upstream(mg, len(mg.at_node['topographic__steepest_slope']),
def run_model(input_file=None,
savepath=None,
initial_topo_file=None,
initial_seed_file=None):
from landlab.components.flow_routing.route_flow_dn_JL import FlowRouter
from landlab.components.stream_power.fastscape_stream_power_JL import FastscapeEroder
#from landlab.components.stream_power.stream_power import StreamPowerEroder
from landlab.components.sink_fill.pit_fill_pf import PitFiller
from landlab.components.diffusion.diffusion import LinearDiffuser
from landlab import ModelParameterDictionary
#from landlab.plot import channel_profile as prf
from landlab.plot.imshow import imshow_node_grid
from landlab.io.esri_ascii import write_esri_ascii
from landlab.io.esri_ascii import read_esri_ascii
from landlab import RasterModelGrid
#from analysis_method import analyze_drainage_percentage
#from analysis_method import analyze_drainage_percentage_each_grid
#from analysis_method import analyze_mean_erosion
#from analysis_method import elev_diff_btwn_moraine_upland
#from analysis_method import label_catchment
#from analysis_method import cross_section
#from analysis_method import analyze_node_below_threshold
#from analysis_method import identify_drained_area
#from analysis_method import save_result
from analysis_method import shiftColorMap
import copy
import numpy as np
import matplotlib
import matplotlib.pyplot as plt
import os
import time
import sys
import shutil
sys.setrecursionlimit(5000)
#===============================================================================
#get the needed properties to build the grid:
if input_file is None:
input_file = './coupled_params_sp.txt'
inputs = ModelParameterDictionary(input_file)
nrows = inputs.read_int('nrows')
ncols = inputs.read_int('ncols')
dx = inputs.read_float('dx')
initial_slope = inputs.read_float('initial_slope')
rightmost_elevation = initial_slope * ncols * dx
#rightmost_elevation = inputs.read_float('rightmost_elevation')
uplift_rate = inputs.read_float('uplift_rate')
incision_rate = inputs.read_float('incision_rate')
runtime = inputs.read_float('total_time')
dt = inputs.read_float('dt')
nt = int(runtime // dt)
k_sp = inputs.read_float('K_sp')
m_sp = inputs.read_float('m_sp')
uplift_per_step = uplift_rate * dt
incision_per_step = incision_rate * dt
moraine_height = inputs.read_float('moraine_height')
moraine_width = inputs.read_float('moraine_width')
#valley_width = inputs.read_float('valley_width')
valley_depth = inputs.read_float('valley_depth')
num_outs = inputs.read_int('number_of_outputs')
output_interval = int(nt // num_outs)
diff = inputs.read_float('linear_diffusivity')
#threshold_stream_power = inputs.read_float('threshold_stream_power')
threshold_AS = inputs.read_float('threshold_AS')
#threshold_erosion = dt*threshold_stream_power
gw_coeff = inputs.read_float('gw_coeff')
all_dry = inputs.read_bool('all_dry')
fill_sink_with_water = inputs.read_bool('fill_sink_with_water')
#===============================================================================
#===============================================================================
if initial_topo_file is None:
#instantiate the grid object
mg = RasterModelGrid(nrows, ncols, dx)
##create the elevation field in the grid:
#create the field
#specifically, this field has a triangular ramp
#moraine at the north edge of the domain.
mg.add_zeros('node', 'topographic__elevation', units='m')
z = mg.at_node['topographic__elevation']
moraine_start_y = np.max(mg.node_y) - moraine_width
moraine_ys = np.where(mg.node_y > moraine_start_y)
z[moraine_ys] += (mg.node_y[moraine_ys] - np.min(
mg.node_y[moraine_ys])) * (moraine_height / moraine_width)
#set valley
#valley_start_x = np.min(mg.node_x)+valley_width
#valley_ys = np.where((mg.node_x<valley_start_x)&(mg.node_y<moraine_start_y-valley_width))
#z[valley_ys] -= (np.max(mg.node_x[valley_ys])-mg.node_x[valley_ys])*(valley_depth/valley_width)
#set ramp (towards valley)
upland = np.where(mg.node_y < moraine_start_y)
z[upland] -= (np.max(mg.node_x[upland]) -
mg.node_x[upland]) * (rightmost_elevation / (ncols * dx))
z += rightmost_elevation
#set ramp (away from moraine)
#upland = np.where(mg.node_y<moraine_start_y)
#z[upland] -= (moraine_start_y-mg.node_y[upland])*initial_slope
#put these values plus roughness into that field
if initial_seed_file is None:
z += np.random.rand(len(z)) / 1
else:
(seedgrid,
seed) = read_esri_ascii(initial_seed_file,
name='topographic__elevation_seed')
z += seed
mg.at_node['topographic__elevation'] = z
#set river valley
river_valley, = np.where(
np.logical_and(
mg.node_x == 0,
np.logical_or(mg.status_at_node == 1, mg.status_at_node == 2)))
mg.at_node['topographic__elevation'][river_valley] = -valley_depth
else:
(mg, z) = read_esri_ascii(initial_topo_file,
name='topographic__elevation')
#set river valley
river_valley, = np.where(
np.logical_and(
mg.node_x == 0,
np.logical_or(mg.status_at_node == 1, mg.status_at_node == 2)))
mg.at_node['topographic__elevation'][river_valley] = -valley_depth
#set up grid's boundary conditions (right, top, left, bottom) is inactive
mg.set_closed_boundaries_at_grid_edges(True, True, False, True)
#set up boundary along moraine
#moraine_start_y = np.max(mg.node_y)-moraine_width
#bdy_moraine_ids = np.where((mg.node_y > moraine_start_y) & (mg.node_x == 0))
#mg.status_at_node[bdy_moraine_ids]=4
#mg._update_links_nodes_cells_to_new_BCs()
#===============================================================================
#===============================================================================
#instantiate the components:
fr = FlowRouter(mg)
pf = PitFiller(mg)
sp = FastscapeEroder(mg, input_file, threshold_sp=threshold_AS * k_sp)
#sp = StreamPowerEroder(mg, input_file, threshold_sp=threshold_erosion, use_Q=True)
#diffuse = PerronNLDiffuse(mg, input_file)
#lin_diffuse = LinearDiffuser(mg, input_file, method='on_diagonals')
lin_diffuse = LinearDiffuser(mg, input_file)
#===============================================================================
#===============================================================================
#instantiate plot setting
plt.close('all')
output_time = output_interval
plot_num = 0
mycmap = shiftColorMap(matplotlib.cm.gist_earth, 'mycmap')
#folder name
if savepath is None:
if all_dry:
name_tag = 'All_dry'
elif fill_sink_with_water:
name_tag = 'Not_all_dry_no_sink'
else:
name_tag = 'Not_all_dry_sink'
savepath = 'results/sensitivity_test_threshold_same_seed/'+name_tag+'_dt=' + str(dt) + '_total_time=' + str(runtime) + '_k_sp=' + str(k_sp) + \
'_uplift_rate=' + str(uplift_rate) + '_incision_rate=' + str(incision_rate) + '_initial_slope=' + str(initial_slope) + \
'_threshold=' + str(threshold_stream_power)
if not os.path.isdir(savepath):
os.makedirs(savepath)
#copy params_file
if not os.path.isfile(savepath + '/coupled_params_sp.txt'):
shutil.copy(input_file, savepath + '/coupled_params_sp.txt')
# Display a message
print 'Running ...'
print savepath
#save initial topography
write_esri_ascii(savepath + '/Topography_t=0.0.txt', mg,
'topographic__elevation')
#time
start_time = time.time()
#===============================================================================
#===============================================================================
#perform the loops:
for i in xrange(nt):
#note the input arguments here are not totally standardized between modules
'''
# simulate changing climate
if (((i+1)*dt // 5000.) % 2) == 0.:
all_dry = False
else:
all_dry = True
'''
#sp = FastscapeEroder(mg, input_file, threshold_sp = threshold_stream_power)
#update elevation
mg.at_node['topographic__elevation'][mg.core_nodes] += uplift_per_step
mg.at_node['topographic__elevation'][river_valley] -= incision_per_step
#mg = lin_diffuse.diffuse(dt)
#route and erode
original_topo = mg.at_node['topographic__elevation'].copy()
slope = mg.at_node['topographic__steepest_slope'].copy()
filled_nodes = None
if all_dry or fill_sink_with_water:
mg = pf.pit_fill()
filled_nodes, = np.where(
(mg.at_node['topographic__elevation'] - original_topo) > 0)
mg = fr.route_flow(routing_flat=all_dry)
old_topo = mg.at_node['topographic__elevation'].copy()
#mg, temp_z, temp_sp = sp.erode(mg, dt, Q_if_used='water__volume_flux')
mg = sp.erode(mg, dt, flooded_nodes=filled_nodes)
new_topo = mg.at_node['topographic__elevation'].copy()
mg.at_node[
'topographic__elevation'] = original_topo + new_topo - old_topo
#diffuse
#for j in range(10):
# mg = lin_diffuse.diffuse(dt/10)
mg = lin_diffuse.diffuse(dt)
if i + 1 == output_time:
print 'Saving data...'
plot_num += 1
plt.figure(plot_num)
im = imshow_node_grid(mg, 'topographic__elevation', plot_name='t = '+str(int((i+1)*dt))+' years', \
grid_units = ['m','m'], cmap=mycmap, allow_colorbar=True, \
vmin=0-valley_depth-incision_rate*runtime, vmax=5.+moraine_height+uplift_rate*runtime)
plt.savefig(savepath + '/Topography_t=' + str(
(i + 1) * dt) + '.jpg',
dpi=300)
write_esri_ascii(
savepath + '/Topography_t=' + str((i + 1) * dt) + '.txt', mg,
'topographic__elevation')
output_time += output_interval
plt.close('all')
print("--- %.2f minutes ---" %
((time.time() - start_time) / 60)), 'Completed loop', i + 1
plt.close('all')
print 'Finished simulating.'
#===============================================================================
#===============================================================================
#analyze_drainage_percentage(savepath, True)
#analyze_mean_erosion(savepath, True)
#elev_diff_btwn_moraine_upland(savepath, True)
#label_catchment(savepath)
#cross_section(savepath)
#===============================================================================
print 'Done!'
print '\n'
z = mg.add_zeros('node', 'topographic__elevation')
#Check the size of the array
len(z)
#Create a diagonal fault across the grid
fault_y = 50.0 + 0.25*mg.node_x
upthrown_nodes = numpy.where(mg.node_y>fault_y)
z[upthrown_nodes] += 10.0 + 0.01*mg.node_x[upthrown_nodes]
#Illustrate the grid
imshow_node_grid(mg, 'topographic__elevation', cmap='jet', grid_units=['m','m'])
show()
#Instantiate the diffusion component:
linear_diffuse = LinearDiffuser(grid=mg, input_stream='./diffusion_input_file.txt')
#Set boundary conditions
mg.set_closed_boundaries_at_grid_edges(False, True, False, True)
#set a model timestep
#(the component will subdivide this as needed to keep things stable)
dt = 2000.
#Evolve landscape
for i in range(25):
linear_diffuse.diffuse(dt)
#Plot new landscape
figure()
imshow_node_grid(mg, 'topographic__elevation', cmap='jet', grid_units=['m','m'])
dt = inputs.read_float('dt')
time_to_run = inputs.read_float('run_time')
init_elev = inputs.read_float('init_elev')
uplift_rate = inputs.read_float('uplift_rate')
mg = RasterModelGrid(nrows, ncols, dx)
#create the fields in the grid
mg.create_node_array_zeros('topographic__elevation')
z = mg.create_node_array_zeros() + init_elev
mg['node'][ 'topographic__elevation'] = z + np.random.rand(len(z))/1000.
mg.set_fixed_value_boundaries_at_grid_edges(True, True, True, True)
#instantiate:
dfn = LinearDiffuser(mg, './diffusion_params.txt')
#perform the loop:
elapsed_time = 0. #total time in simulation
while elapsed_time < time_to_run:
print elapsed_time
if elapsed_time+dt>time_to_run:
print "Short step!"
dt = time_to_run - elapsed_time
dfn.diffuse(dt)
mg.at_node['topographic__elevation'][mg.core_nodes] += uplift_rate*dt
elapsed_time += dt
pylab.figure(1)
im = imshow_node_grid(mg, 'topographic__elevation') # display a colored image
dt = inputs.read_float('dt')
time_to_run = inputs.read_float('run_time')
init_elev = inputs.read_float('init_elev')
uplift_rate = inputs.read_float('uplift_rate')
mg = RasterModelGrid(nrows, ncols, dx)
#create the fields in the grid
mg.create_node_array_zeros('topographic__elevation')
z = mg.create_node_array_zeros() + init_elev
mg['node']['topographic__elevation'] = z + np.random.rand(len(z)) / 1000.
mg.set_fixed_value_boundaries_at_grid_edges(True, True, True, True)
#instantiate:
dfn = LinearDiffuser(mg, './diffusion_params.txt')
#perform the loop:
elapsed_time = 0. #total time in simulation
while elapsed_time < time_to_run:
print elapsed_time
if elapsed_time + dt > time_to_run:
print "Short step!"
dt = time_to_run - elapsed_time
dfn.diffuse(dt)
mg.at_node['topographic__elevation'][mg.core_nodes] += uplift_rate * dt
elapsed_time += dt
pylab.figure(1)
im = imshow_node_grid(mg, 'topographic__elevation') # display a colored image
mg = RasterModelGrid((nrows, ncols), dx)
z = mg.add_zeros('node', 'topographic__elevation')
# add some roughness as the initial topography, this lets "natural" channel planforms arise
initial_roughness = np.random.rand(z.size) / 100000.
z += initial_roughness
#set the boundary conditions - here we have closed boundaries at the top/bottom and fixed boundaries at the left/right
for edge in (mg.nodes_at_left_edge, mg.nodes_at_right_edge):
mg.status_at_node[edge] = FIXED_VALUE_BOUNDARY
for edge in (mg.nodes_at_top_edge, mg.nodes_at_bottom_edge):
mg.status_at_node[edge] = CLOSED_BOUNDARY
#instantiate the components
fr = FlowRouter(mg, input_file)
sp = StreamPowerEroder(mg, input_file)
lin_diffuse = LinearDiffuser(mg, input_file)
#run the model
elapsed_time = 0. #total time in simulation
for i in range(nt):
lin_diffuse.run_one_step(dt)
fr.run_one_step(
) # route_flow isn't time sensitive, so it doesn't take dt as input
sp.run_one_step(dt)
mg.at_node['topographic__elevation'][
mg.core_nodes] += uplift_per_step # add the uplift
# if you want to see the evolution of the topogrpahy through time (say to check for steady state) you can output a topography at each time step
#write_netcdf(('topography_output'+ str(elapsed_time) +'.nc'), mg, names='topographic__elevation')
elapsed_time += dt
