def test_stupid_shaped_hole(sink_grid4):
"""Tests inclined fill into a surface with a deliberately awkward shape."""
fr = FlowAccumulator(sink_grid4, flow_director="D8")
hf = SinkFiller(sink_grid4, apply_slope=True)
hf.fill_pits()
hole1 = np.array(
[
4.00007692,
4.00015385,
4.00023077,
4.00030769,
4.00038462,
4.00046154,
4.00053846,
4.00061538,
4.00069231,
4.00076923,
4.00084615,
]
)
hole2 = np.array([7.4, 7.2, 7.6])
assert_array_almost_equal(
sink_grid4.at_node["topographic__elevation"][sink_grid4.lake1], hole1
)
assert_array_almost_equal(
sink_grid4.at_node["topographic__elevation"][sink_grid4.lake2], hole2
)
fr.run_one_step()
assert sink_grid4.at_node["flow__sink_flag"][sink_grid4.core_nodes].sum() == 0
def test_filler_inclined2(sink_grid3):
"""
Tests an inclined fill into an inclined surface, with two holes.
"""
fr = FlowAccumulator(sink_grid3, flow_director="D8")
hf = SinkFiller(sink_grid3, apply_slope=True)
hf.fill_pits()
hole1 = np.array(
[
4.00009091,
4.00018182,
4.00027273,
4.00036364,
4.00045455,
4.00054545,
4.00063636,
4.00072727,
4.00081818,
]
)
hole2 = np.array([7.16666667, 7.33333333, 7.5, 7.66666667])
assert_array_almost_equal(
sink_grid3.at_node["topographic__elevation"][sink_grid3.lake1], hole1
)
assert_array_almost_equal(
sink_grid3.at_node["topographic__elevation"][sink_grid3.lake2], hole2
)
fr.run_one_step()
assert sink_grid3.at_node["flow__sink_flag"][sink_grid3.core_nodes].sum() == 0
def test_filler_inclined2(sink_grid3):
"""
Tests an inclined fill into an inclined surface, with two holes.
"""
fr = FlowAccumulator(sink_grid3, flow_director="D8")
hf = SinkFiller(sink_grid3, apply_slope=True)
hf.fill_pits()
hole1 = np.array(
[
4.00009091,
4.00018182,
4.00027273,
4.00036364,
4.00045455,
4.00054545,
4.00063636,
4.00072727,
4.00081818,
]
)
hole2 = np.array([7.16666667, 7.33333333, 7.5, 7.66666667])
assert_array_almost_equal(
sink_grid3.at_node["topographic__elevation"][sink_grid3.lake1], hole1
)
assert_array_almost_equal(
sink_grid3.at_node["topographic__elevation"][sink_grid3.lake2], hole2
)
fr.run_one_step()
assert sink_grid3.at_node["flow__sink_flag"][sink_grid3.core_nodes].sum() == 0
def test_add_slopes(sink_grid1):
z = sink_grid1.at_node["topographic__elevation"]
hf = SinkFiller(sink_grid1)
new_z = z.copy()
outlet_elev = z[sink_grid1.outlet]
hf._elev[sink_grid1.lake] = outlet_elev
rt2 = np.sqrt(2.)
slope_to_add = 0.1
lake_map = np.empty_like(z)
lake_map.fill(XX)
lake_map[sink_grid1.lake] = sink_grid1.lake_code
hf._lf._lake_map = lake_map
hf.lake_nodes_treated = np.array([], dtype=int)
dists = sink_grid1.calc_distances_of_nodes_to_point(
(sink_grid1.node_x[sink_grid1.outlet], sink_grid1.node_y[sink_grid1.outlet])
)
new_z[sink_grid1.lake] = outlet_elev
new_z[sink_grid1.lake] += dists[sink_grid1.lake] * slope_to_add
# test the ones we can do easily analytically separately
straight_north = np.array([23, 16])
off_angle = 24
elevs_out, lake_out = hf._add_slopes(
slope_to_add, sink_grid1.outlet, sink_grid1.lake_code
)
assert_array_equal(
slope_to_add * (np.arange(2.) + 1.) + outlet_elev, elevs_out[straight_north]
)
assert slope_to_add * rt2 + outlet_elev == pytest.approx(elevs_out[off_angle])
assert_array_equal(new_z, elevs_out)
assert_array_equal(sink_grid1.lake, lake_out)
def test_add_slopes(sink_grid1):
z = sink_grid1.at_node["topographic__elevation"]
hf = SinkFiller(sink_grid1)
new_z = z.copy()
outlet_elev = z[sink_grid1.outlet]
hf._elev[sink_grid1.lake] = outlet_elev
rt2 = np.sqrt(2.0)
slope_to_add = 0.1
lake_map = np.empty_like(z)
lake_map.fill(XX)
lake_map[sink_grid1.lake] = sink_grid1.lake_code
hf._lf._lake_map = lake_map
hf.lake_nodes_treated = np.array([], dtype=int)
dists = sink_grid1.calc_distances_of_nodes_to_point(
(sink_grid1.node_x[sink_grid1.outlet], sink_grid1.node_y[sink_grid1.outlet])
)
new_z[sink_grid1.lake] = outlet_elev
new_z[sink_grid1.lake] += dists[sink_grid1.lake] * slope_to_add
# test the ones we can do easily analytically separately
straight_north = np.array([23, 16])
off_angle = 24
elevs_out, lake_out = hf._add_slopes(
slope_to_add, sink_grid1.outlet, sink_grid1.lake_code
)
assert_array_equal(
slope_to_add * (np.arange(2.0) + 1.0) + outlet_elev, elevs_out[straight_north]
)
assert slope_to_add * rt2 + outlet_elev == pytest.approx(elevs_out[off_angle])
assert_array_equal(new_z, elevs_out)
assert_array_equal(sink_grid1.lake, lake_out)
def test_D4_routing(sink_grid5):
"""
Tests inclined fill into a surface with a deliberately awkward shape.
This is testing D4 routing.
"""
fr = FlowAccumulator(sink_grid5, flow_director="D4")
hf = SinkFiller(sink_grid5, routing="D4", apply_slope=True)
hf.fill_pits()
hole1 = np.array(
[
4.00016667,
4.00033333,
4.0005,
4.00008333,
4.00025,
4.00041667,
4.000833,
4.00066667,
4.00058333,
4.00075,
4.334,
]
)
hole2 = np.array([7.6, 7.2, 7.4])
assert_array_almost_equal(
sink_grid5.at_node["topographic__elevation"][sink_grid5.lake1], hole1
)
assert_array_almost_equal(
sink_grid5.at_node["topographic__elevation"][sink_grid5.lake2], hole2
)
fr.run_one_step()
assert sink_grid5.at_node["flow__sink_flag"][sink_grid5.core_nodes].sum() == 0
def test_stupid_shaped_hole(sink_grid4):
"""Tests inclined fill into a surface with a deliberately awkward shape."""
fr = FlowAccumulator(sink_grid4, flow_director="D8")
hf = SinkFiller(sink_grid4, apply_slope=True)
hf.fill_pits()
hole1 = np.array(
[
4.00007692,
4.00015385,
4.00023077,
4.00030769,
4.00038462,
4.00046154,
4.00053846,
4.00061538,
4.00069231,
4.00076923,
4.00084615,
]
)
hole2 = np.array([7.4, 7.2, 7.6])
assert_array_almost_equal(
sink_grid4.at_node["topographic__elevation"][sink_grid4.lake1], hole1
)
assert_array_almost_equal(
sink_grid4.at_node["topographic__elevation"][sink_grid4.lake2], hole2
)
fr.run_one_step()
assert sink_grid4.at_node["flow__sink_flag"][sink_grid4.core_nodes].sum() == 0
def test_D4_routing(sink_grid5):
"""
Tests inclined fill into a surface with a deliberately awkward shape.
This is testing D4 routing.
"""
fr = FlowAccumulator(sink_grid5, flow_director="D4")
hf = SinkFiller(sink_grid5, routing="D4", apply_slope=True)
hf.fill_pits()
hole1 = np.array(
[
4.00016667,
4.00033333,
4.0005,
4.00008333,
4.00025,
4.00041667,
4.000833,
4.00066667,
4.00058333,
4.00075,
4.334,
]
)
hole2 = np.array([7.6, 7.2, 7.4])
assert_array_almost_equal(
sink_grid5.at_node["topographic__elevation"][sink_grid5.lake1], hole1
)
assert_array_almost_equal(
sink_grid5.at_node["topographic__elevation"][sink_grid5.lake2], hole2
)
fr.run_one_step()
assert sink_grid5.at_node["flow__sink_flag"][sink_grid5.core_nodes].sum() == 0
def test_get_lake_ext_margin(sink_grid1):
hf = SinkFiller(sink_grid1)
lake = np.array([16, 17, 23, 24, 25, 30, 31, 32])
ext_margin_returned = hf._get_lake_ext_margin(lake)
ext_margin = np.array(
[8, 9, 10, 11, 15, 18, 19, 22, 26, 29, 33, 36, 37, 38, 39, 40])
assert_array_equal(ext_margin_returned, ext_margin)
def test_get_lake_ext_margin(sink_grid1):
hf = SinkFiller(sink_grid1)
lake = np.array([16, 17, 23, 24, 25, 30, 31, 32])
ext_margin_returned = hf._get_lake_ext_margin(lake)
ext_margin = np.array(
[8, 9, 10, 11, 15, 18, 19, 22, 26, 29, 33, 36, 37, 38, 39, 40]
)
assert_array_equal(ext_margin_returned, ext_margin)
def test_filler_flat(sink_grid2):
"""
Very simple, though possibly degerate, case, filling a 3x3 hole up to
the flat surface surrounding it.
"""
hf = SinkFiller(sink_grid2)
hf.fill_pits()
assert_array_equal(hf._elev[sink_grid2.lake], np.ones(9, dtype=float))
assert_array_equal(
sink_grid2.at_node["topographic__elevation"][sink_grid2.lake],
np.ones(9, dtype=float),
)
def test_filler_flat(sink_grid2):
"""
Very simple, though possibly degerate, case, filling a 3x3 hole up to
the flat surface surrounding it.
"""
hf = SinkFiller(sink_grid2)
hf.fill_pits()
assert_array_equal(hf._elev[sink_grid2.lake], np.ones(9, dtype=float))
assert_array_equal(
sink_grid2.at_node["topographic__elevation"][sink_grid2.lake],
np.ones(9, dtype=float),
)
def __init__(self,
input_file=None,
params=None,
BaselevelHandlerClass=None):
"""Initialize the Basic model."""
# Call ErosionModel's init
super(Basic,
self).__init__(input_file=input_file,
params=params,
BaselevelHandlerClass=BaselevelHandlerClass)
# Get Parameters:
K_sp = self.get_parameter_from_exponent('K_sp', raise_error=False)
K_ss = self.get_parameter_from_exponent('K_ss', raise_error=False)
linear_diffusivity = (
self._length_factor**2.) * self.get_parameter_from_exponent(
'linear_diffusivity') # has units length^2/time
# check that a stream power and a shear stress parameter have not both been given
if K_sp != None and K_ss != None:
raise ValueError('A parameter for both K_sp and K_ss has been'
'provided. Only one of these may be provided')
elif K_sp != None or K_ss != None:
if K_sp != None:
self.K = K_sp
else:
self.K = (self._length_factor**(
1. / 3.)) * K_ss # K_ss has units Lengtg^(1/3) per Time
else:
raise ValueError('A value for K_sp or K_ss must be provided.')
# run the sink filler, only on initiation.
sink_filler = SinkFiller(self.grid, apply_slope=True, fill_slope=1e-3)
sink_filler.run_one_step()
# Instantiate a FlowAccumulator with DepressionFinderAndRouter using D8 method
self.flow_router = FlowAccumulator(
self.grid,
flow_director='D8',
depression_finder=DepressionFinderAndRouter)
# Instantiate a FastscapeEroder component
self.eroder = FastscapeEroder(self.grid,
K_sp=self.K,
m_sp=self.params['m_sp'],
n_sp=self.params['n_sp'])
# Instantiate a LinearDiffuser component
self.diffuser = LinearDiffuser(self.grid,
linear_diffusivity=linear_diffusivity)
def test_filler_inclined(sink_grid3):
"""
Tests a flat fill into an inclined surface, with two holes.
"""
hf = SinkFiller(sink_grid3)
hf.fill_pits()
assert_array_equal(
sink_grid3.at_node["topographic__elevation"][sink_grid3.lake1],
np.ones(9, dtype=float) * 4.0,
)
assert_array_equal(
sink_grid3.at_node["topographic__elevation"][sink_grid3.lake2],
np.ones(4, dtype=float) * 7.0,
)
def test_filler_inclined(sink_grid3):
"""
Tests a flat fill into an inclined surface, with two holes.
"""
hf = SinkFiller(sink_grid3)
hf.fill_pits()
assert_array_equal(
sink_grid3.at_node["topographic__elevation"][sink_grid3.lake1],
np.ones(9, dtype=float) * 4.,
)
assert_array_equal(
sink_grid3.at_node["topographic__elevation"][sink_grid3.lake2],
np.ones(4, dtype=float) * 7.,
)
def test_D4_filling(sink_grid5):
"""
Tests inclined fill into a surface with a deliberately awkward shape.
This is testing D4 without inclining the surface.
"""
hf = SinkFiller(sink_grid5, routing="D4")
hf.fill_pits()
hole1 = 4. * np.ones_like(sink_grid5.lake1, dtype=float)
hole1[-1] += 0.001
hole2 = 7. * np.ones_like(sink_grid5.lake2, dtype=float)
assert_array_almost_equal(
sink_grid5.at_node["topographic__elevation"][sink_grid5.lake1], hole1)
assert_array_almost_equal(
sink_grid5.at_node["topographic__elevation"][sink_grid5.lake2], hole2)
def test_D4_filling(sink_grid5):
"""
Tests inclined fill into a surface with a deliberately awkward shape.
This is testing D4 without inclining the surface.
"""
hf = SinkFiller(sink_grid5, routing="D4")
hf.fill_pits()
hole1 = 4.0 * np.ones_like(sink_grid5.lake1, dtype=float)
hole1[-1] += 0.001
hole2 = 7.0 * np.ones_like(sink_grid5.lake2, dtype=float)
assert_array_almost_equal(
sink_grid5.at_node["topographic__elevation"][sink_grid5.lake1], hole1
)
assert_array_almost_equal(
sink_grid5.at_node["topographic__elevation"][sink_grid5.lake2], hole2
)
def test_route_to_multiple_error_raised():
mg = RasterModelGrid((10, 10))
z = mg.add_zeros("node", "topographic__elevation")
z += mg.x_of_node + mg.y_of_node
fa = FlowAccumulator(mg, flow_director="MFD")
fa.run_one_step()
with pytest.raises(NotImplementedError):
SinkFiller(mg)
def test_drainage_directions_change(sink_grid1):
hf = SinkFiller(sink_grid1)
lake = np.array([22, 23])
old_elevs = np.ones(49, dtype=float)
old_elevs[lake] = 0.0
new_elevs = old_elevs.copy()
new_elevs[40] = 2.0
cond = hf.drainage_directions_change(lake, old_elevs, new_elevs)
assert not cond
new_elevs[23] = 0.5
cond = hf.drainage_directions_change(lake, old_elevs, new_elevs)
assert not cond
new_elevs[23] = 1.0
cond = hf.drainage_directions_change(lake, old_elevs, new_elevs)
assert not cond
new_elevs[23] = 1.2
cond = hf.drainage_directions_change(lake, old_elevs, new_elevs)
assert cond
def test_drainage_directions_change(sink_grid1):
hf = SinkFiller(sink_grid1)
lake = np.array([22, 23])
old_elevs = np.ones(49, dtype=float)
old_elevs[lake] = 0.
new_elevs = old_elevs.copy()
new_elevs[40] = 2.
cond = hf.drainage_directions_change(lake, old_elevs, new_elevs)
assert not cond
new_elevs[23] = 0.5
cond = hf.drainage_directions_change(lake, old_elevs, new_elevs)
assert not cond
new_elevs[23] = 1.
cond = hf.drainage_directions_change(lake, old_elevs, new_elevs)
assert not cond
new_elevs[23] = 1.2
cond = hf.drainage_directions_change(lake, old_elevs, new_elevs)
assert cond
from landlab.plot import channel_profile as prf #functions, not objects
from matplotlib import pyplot as plt
import numpy as np
## Make a grid that is 100 by 100 with dx=dy=100. m
rmg1 = RasterModelGrid((100, 100), 100.)
## Add elevation field to the grid.
z1 = rmg1.add_ones('node', 'topographic__elevation')
## Add noise to initial landscape
z1[rmg1.core_nodes] += np.random.rand(len(rmg1.core_nodes))
## Instantiate process components
ld1 = LinearDiffuser(rmg1, linear_diffusivity=0.1)
fr1 = FlowRouter(rmg1, method='D8')
fse1 = FastscapeEroder(rmg1, K_sp=1e-5, m_sp=0.5, n_sp=1.)
sf1 = SinkFiller(rmg1, routing='D8')
## instantiate helper components
chif = ChiFinder(rmg1)
steepf = SteepnessFinder(rmg1)
## Set some variables
rock_up_rate = 1e-3 #m/yr
dt = 1000 # yr
rock_up_len = dt * rock_up_rate # m
## Time loop where evolution happens
for i in range(500):
z1[rmg1.core_nodes] += rock_up_len #uplift only the core nodes
ld1.run_one_step(dt) #linear diffusion happens.
sf1.run_one_step() #sink filling happens, time step not needed
#Create an uplifted block
blockuplift_nodes = np.where((mg.node_y < 17500) & (mg.node_y > 2500)
& (mg.node_x < 17500) & (mg.node_x > 2500))
z[blockuplift_nodes] += 100.0
z[blockuplift_nodes] += np.random.rand(len(blockuplift_nodes[0])) * 10
pl.figure()
imshow_grid(mg,
'topographic__elevation',
plot_name='Initial Topography of Uplifted block',
allow_colorbar=True)
ld = LinearDiffuser(mg, linear_diffusivity=0.01)
fr = FlowAccumulator(mg, flow_director='D8')
fse = FastscapeEroder(mg, K_sp=5e-5, m_sp=0.5, n_sp=1.)
sf = SinkFiller(mg, routing='D8')
## instantiate helper components
chif = ChiFinder(mg)
steepnessf = SteepnessFinder(mg, reference_concavity=0.5)
## Set some variables
rock_up_rate = 1e-3 #m/yr
dt = 1000 # yr
rock_up_len = dt * rock_up_rate # m
nr_time_steps = 500
## Time loop where evolution happens
for i in range(nr_time_steps):
z[mg.core_nodes] += rock_up_len #uplift only the core nodes
ld.run_one_step(dt) #linear diffusion happens.
sf.run_one_step() #sink filling happens, time step not needed
fg = RasterModelGrid((extend_t.shape[0], extend_t.shape[1]), spacing=(1, 1))
_ = fg.add_field('node', 'topographic__elevation', extend_t)
fg.set_closed_boundaries_at_grid_edges(False, False, False, False)
# Calculate flow fields
fr = FlowRouter(fg)
fg = fr.route_flow()
# Preview the flow field with this plotting func.
# drainage_plot(fg, title='Grid 2 using FlowDirectorD8')
# Fill in Lakes/depressions
fg.at_node['flow__sink_flag'][
fg.core_nodes].sum() # how many depressions do we have?
hf = SinkFiller(fg, apply_slope=True)
hf.run_one_step()
fr.run_one_step()
# drainage_plot(fg, title='Grid 2 using FlowDirectorD8')
# Output is a single vector
flow_rec = fg.at_node['flow__receiver_node']
# Convert to a 'tocell' field
# In land_lad2, directions are defined using the standard D8 method as follows
#
# [32, 64, 128]
# [16, 0, 1]
# [8, 4, 2]
tocell_tmp = np.zeros([flow_rec.shape[0]])
for i in range(flow_rec.shape[0]):
# Assign the outlet and boundary conditions
print("\tSetting Boundary Conditions...")
# If more than one outlet, errors out and show which outlets
# outlet_id = rmg.set_watershed_boundary_condition(z.flatten(), nodata_value=-9999, return_outlet_id=True)
outlet_id = 2615
rmg.set_watershed_boundary_condition_outlet_id(outlet_id, z.flatten())
# Object for managing the simulation
of = OverlandFlow(rmg, mannings_n=0.03, steep_slopes=True)
# Flow Routing
print("\tProcessing DEM for routing...")
sf = SinkFiller(rmg, routing='D4', apply_slope=False, fill_slope=1.e-5)
print("\tFilling pits...")
#sf.fill_pits()
print("\tOutputting topo from Landlab...")
write_netcdf('ll_topo.nc', rmg, names=['topographic__elevation'])
################################# FLOW SIM #####################################
# Show the user whats going on with the progress
print()
bar = pb.ProgressBar(max_value=(model_run_time / 3600) + 1)
pp_t = 0
iteration = 0
