def test_add_units_existing_field(at):
grid = RasterModelGrid((4, 4))
grid.add_empty("x", at=at, units="NONE")
assert grid.field_units(at, "x") == "NONE"
values = grid[at]["x"].copy()
units(grid, "x", at=at, units="m")
assert grid.field_units(at, "x") == "m"
assert_array_equal(grid[at]["x"], values)
def test_add_ones_zeros_empty_to_at_grid():
"""Test different add methods for keyword at='grid'"""
grid = RasterModelGrid((4, 5))
with pytest.raises(ValueError):
grid.add_zeros('value', at='grid')
with pytest.raises(ValueError):
grid.add_empty('value', at='grid')
with pytest.raises(ValueError):
grid.add_ones('value', at='grid')
def test_field_keys_is_list(at):
grid = RasterModelGrid((4, 5))
expected = []
assert getattr(grid, "at_{0}".format(at)).keys() == expected
for name in ["temperature", "elevation"]:
grid.add_empty(name, at=at)
expected.append(name)
assert sorted(getattr(grid,
"at_{0}".format(at)).keys()) == sorted(expected)
def test_add_ones_zeros_empty_to_at_grid():
"""Test different add methods for keyword at='grid'"""
grid = RasterModelGrid((4, 5))
with pytest.raises(ValueError):
grid.add_zeros("value", at="grid")
with pytest.raises(ValueError):
grid.add_empty("value", at="grid")
with pytest.raises(ValueError):
grid.add_ones("value", at="grid")
def test_cell(self):
rmg = RasterModelGrid(4, 5, 1.)
rmg.add_empty('node', 'values')
node_values = rmg.at_node['values']
node_values[:] = np.arange(rmg.number_of_nodes)
cell_values = maps.map_node_to_cell(rmg, 'values')
assert_array_equal(np.array([6., 7., 8., 11., 12., 13.]), cell_values)
def test_cell(self):
rmg = RasterModelGrid(4, 5, 1.)
rmg.add_empty('node', 'values')
node_values = rmg.at_node['values']
node_values[:] = np.arange(rmg.number_of_nodes)
cell_values = maps.map_node_to_cell(rmg, 'values')
assert_array_equal(np.array([6., 7., 8., 11., 12., 13.]), cell_values)
def test_cell(self):
rmg = RasterModelGrid((4, 5))
rmg.add_empty("node", "values")
node_values = rmg.at_node["values"]
node_values[:] = np.arange(rmg.number_of_nodes)
cell_values = maps.map_node_to_cell(rmg, "values")
assert_array_equal(np.array([6., 7., 8., 11., 12., 13.]), cell_values)
def test_get_node_fields_ignore_non_node_fields():
grid = RasterModelGrid((3, 4))
grid.add_empty("foo", at="node")
grid.add_empty("bar", at="node")
grid.add_empty("baz", at="link")
network = ChannelSegmentConnector([0, 5], [5, 6, 7], [5, 9])
fields = get_node_fields(network.root, grid, include="*")
assert sorted(list(fields)) == ["bar", "foo"]
def test_include_keyword_is_empty(tmpdir, format, include):
grid = RasterModelGrid((4, 3),
xy_spacing=(2, 5),
xy_of_lower_left=(-2.0, 10.0))
grid.add_ones("elev", at="node")
grid.add_zeros("elev", at="link")
grid.add_empty("temp", at="node")
with tmpdir.as_cwd():
to_netcdf(grid, "test.nc", format=format)
actual = from_netcdf("test.nc", include=include)
assert len(actual.at_node) == 0
assert len(actual.at_link) == 0
def test_to_node(self):
rmg = RasterModelGrid((4, 5), xy_spacing=(1., 1.))
rmg.add_empty("node", "values")
node_values = rmg.at_node["values"]
node_values[:] = np.arange(rmg.number_of_nodes)
link_values = maps.map_link_tail_node_to_link(rmg, "values")
assert_array_equal(
link_values,
np.array(
[
0,
1,
2,
3,
0,
1,
2,
3,
4,
5,
6,
7,
8,
5,
6,
7,
8,
9,
10,
11,
12,
13,
10,
11,
12,
13,
14,
15,
16,
17,
18,
]
),
)
out = np.empty_like(link_values)
rtn = maps.map_link_tail_node_to_link(rmg, "values", out=out)
assert_array_equal(out, link_values)
assert rtn is out
def test_get_node_fields_exclude():
grid = RasterModelGrid((3, 4))
grid.add_empty("foo", at="node")
grid.add_empty("bar", at="node")
grid.add_empty("baz", at="node")
network = ChannelSegmentConnector([0, 5], [5, 6, 7], [5, 9])
expected = get_node_fields(network.root, grid, include="at_node:b*")
actual = get_node_fields(network.root, grid, exclude="at_node:f*")
assert actual.keys() == expected.keys()
for name in actual:
assert_array_equal(actual[name], expected[name])
def test_min(self):
rmg = RasterModelGrid(4, 5)
rmg.add_empty('node', 'values')
node_values = rmg.at_node['values']
node_values[:] = np.arange(rmg.number_of_nodes)
values_at_links = maps.map_min_of_link_nodes_to_link(rmg, 'values')
assert_array_equal(
values_at_links,
np.array([
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 0, 1, 2, 3,
5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 17, 18
]))
def test_max(self):
rmg = RasterModelGrid(4, 5)
rmg.add_empty('node', 'values')
node_values = rmg.at_node['values']
node_values[:] = np.arange(rmg.number_of_nodes)
values_at_links = maps.map_max_of_link_nodes_to_link(rmg, 'values')
assert_array_equal(
values_at_links,
np.array([
1, 2, 3, 4, 5, 6, 7, 8, 9, 6, 7, 8, 9, 10, 11, 12, 13, 14, 11,
12, 13, 14, 15, 16, 17, 18, 19, 16, 17, 18, 19
]))
def test_from_node(self):
rmg = RasterModelGrid((4, 5))
rmg.add_empty("node", "values")
node_values = rmg.at_node["values"]
node_values[:] = np.arange(rmg.number_of_nodes)
link_values = maps.map_link_head_node_to_link(rmg, "values")
# link_values = rmg.at_link['values']
assert_array_equal(
link_values,
np.array(
[
1,
2,
3,
4,
5,
6,
7,
8,
9,
6,
7,
8,
9,
10,
11,
12,
13,
14,
11,
12,
13,
14,
15,
16,
17,
18,
19,
16,
17,
18,
19,
]
),
)
def test_mean_node(self):
rmg = RasterModelGrid(4, 5, 1.)
rmg.add_empty('node', 'values')
node_values = rmg.at_node['values']
node_values[:] = np.arange(rmg.number_of_nodes)
link_values = maps.map_mean_of_link_nodes_to_link(rmg, 'values')
assert_array_equal(
link_values,
np.array([
2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5, 10.5, 11.5, 12.5, 13.5,
14.5, 15.5, 16.5, 0.5, 1.5, 2.5, 3.5, 5.5, 6.5, 7.5, 8.5, 10.5,
11.5, 12.5, 13.5, 15.5, 16.5, 17.5, 18.5
]))
def test_mean_node(self):
rmg = RasterModelGrid(4, 5, 1.)
rmg.add_empty('node', 'values')
node_values = rmg.at_node['values']
node_values[:] = np.arange(rmg.number_of_nodes)
link_values = maps.map_mean_of_link_nodes_to_link(rmg, 'values')
assert_array_equal(
link_values,
np.array([
0.5, 1.5, 2.5, 3.5, 2.5, 3.5, 4.5, 5.5, 6.5, 5.5, 6.5, 7.5,
8.5, 7.5, 8.5, 9.5, 10.5, 11.5, 10.5, 11.5, 12.5, 13.5, 12.5,
13.5, 14.5, 15.5, 16.5, 15.5, 16.5, 17.5, 18.5
]))
def test_from_node(self):
rmg = RasterModelGrid(4, 5, 1.)
rmg.add_empty('node', 'values')
node_values = rmg.at_node['values']
node_values[:] = np.arange(rmg.number_of_nodes)
link_values = maps.map_link_head_node_to_link(rmg, 'values')
#link_values = rmg.at_link['values']
assert_array_equal(
link_values,
np.array([
5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 1, 2, 3,
4, 6, 7, 8, 9, 11, 12, 13, 14, 16, 17, 18, 19
]))
def test_mean_node(self):
rmg = RasterModelGrid((4, 5))
rmg.add_empty("node", "values")
node_values = rmg.at_node["values"]
node_values[:] = np.arange(rmg.number_of_nodes)
link_values = maps.map_mean_of_link_nodes_to_link(rmg, "values")
assert_array_equal(
link_values,
np.array(
[
0.5,
1.5,
2.5,
3.5,
2.5,
3.5,
4.5,
5.5,
6.5,
5.5,
6.5,
7.5,
8.5,
7.5,
8.5,
9.5,
10.5,
11.5,
10.5,
11.5,
12.5,
13.5,
12.5,
13.5,
14.5,
15.5,
16.5,
15.5,
16.5,
17.5,
18.5,
]
),
)
def test_max(self):
rmg = RasterModelGrid(4, 5)
rmg.add_empty('node', 'values')
node_values = rmg.at_node['values']
node_values[:] = np.arange(rmg.number_of_nodes)
maps.map_link_end_node_max_value_to_link(rmg, 'values')
assert_array_equal(
rmg.at_link['values'],
np.array([ 5, 6, 7, 8, 9,
10, 11, 12, 13, 14,
15, 16, 17, 18, 19,
1, 2, 3, 4,
6, 7, 8, 9,
11, 12, 13, 14,
16, 17, 18, 19]))
def test_max(self):
rmg = RasterModelGrid(4, 5)
rmg.add_empty("node", "values")
node_values = rmg.at_node["values"]
node_values[:] = np.arange(rmg.number_of_nodes)
values_at_links = maps.map_max_of_link_nodes_to_link(rmg, "values")
assert_array_equal(
values_at_links,
np.array(
[
1,
2,
3,
4,
5,
6,
7,
8,
9,
6,
7,
8,
9,
10,
11,
12,
13,
14,
11,
12,
13,
14,
15,
16,
17,
18,
19,
16,
17,
18,
19,
]
),
)
def test_min(self):
rmg = RasterModelGrid(4, 5)
rmg.add_empty('node', 'values')
node_values = rmg.at_node['values']
node_values[:] = np.arange(rmg.number_of_nodes)
maps.map_link_end_node_min_value_to_link(rmg, 'values')
assert_array_equal(
rmg.at_link['values'],
np.array([ 0, 1, 2, 3, 4,
5, 6, 7, 8, 9,
10, 11, 12, 13, 14,
0, 1, 2, 3,
5, 6, 7, 8,
10, 11, 12, 13,
15, 16, 17, 18]))
def test_min(self):
rmg = RasterModelGrid(4, 5)
rmg.add_empty("node", "values")
node_values = rmg.at_node["values"]
node_values[:] = np.arange(rmg.number_of_nodes)
values_at_links = maps.map_min_of_link_nodes_to_link(rmg, "values")
assert_array_equal(
values_at_links,
np.array(
[
0,
1,
2,
3,
0,
1,
2,
3,
4,
5,
6,
7,
8,
5,
6,
7,
8,
9,
10,
11,
12,
13,
10,
11,
12,
13,
14,
15,
16,
17,
18,
]
),
)
def test_mean_node(self):
rmg = RasterModelGrid((4, 5))
rmg.add_empty("values", at="node")
node_values = rmg.at_node["values"]
node_values[:] = np.arange(rmg.number_of_nodes)
link_values = maps.map_mean_of_link_nodes_to_link(rmg, "values")
assert_array_equal(
link_values,
np.array([
0.5,
1.5,
2.5,
3.5,
2.5,
3.5,
4.5,
5.5,
6.5,
5.5,
6.5,
7.5,
8.5,
7.5,
8.5,
9.5,
10.5,
11.5,
10.5,
11.5,
12.5,
13.5,
12.5,
13.5,
14.5,
15.5,
16.5,
15.5,
16.5,
17.5,
18.5,
]),
)
def test_to_node(self):
rmg = RasterModelGrid(num_rows=4, num_cols=5, dx=1.)
rmg.add_empty('node', 'values')
node_values = rmg.at_node['values']
node_values[:] = np.arange(rmg.number_of_nodes)
maps.map_values_from_link_tail_node_to_link(rmg, 'values')
link_values = rmg.at_link['values']
assert_array_equal(link_values,
np.array([ 5, 6, 7, 8, 9,
10, 11, 12, 13, 14,
15, 16, 17, 18, 19,
1, 2, 3, 4,
6, 7, 8, 9,
11, 12, 13, 14,
16, 17, 18, 19]))
def test_to_node(self):
rmg = RasterModelGrid(num_rows=4, num_cols=5, dx=1.)
rmg.add_empty('node', 'values')
node_values = rmg.at_node['values']
node_values[:] = np.arange(rmg.number_of_nodes)
link_values = maps.map_link_tail_node_to_link(rmg, 'values')
assert_array_equal(
link_values,
np.array([
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 0, 1, 2, 3,
5, 6, 7, 8, 10, 11, 12, 13, 15, 16, 17, 18
]))
out = np.empty_like(link_values)
rtn = maps.map_link_tail_node_to_link(rmg, 'values', out=out)
assert_array_equal(out, link_values)
assert_is(rtn, out)
def test_to_node(self):
rmg = RasterModelGrid((4, 5), spacing=(1., 1.))
rmg.add_empty('node', 'values')
node_values = rmg.at_node['values']
node_values[:] = np.arange(rmg.number_of_nodes)
link_values = maps.map_link_tail_node_to_link(rmg, 'values')
assert_array_equal(
link_values,
np.array([
0, 1, 2, 3, 0, 1, 2, 3, 4, 5, 6, 7, 8, 5, 6, 7, 8, 9, 10, 11,
12, 13, 10, 11, 12, 13, 14, 15, 16, 17, 18
]))
out = np.empty_like(link_values)
rtn = maps.map_link_tail_node_to_link(rmg, 'values', out=out)
assert_array_equal(out, link_values)
assert_is(rtn, out)
def main():
# INITIALIZE
# User-defined parameter values
rows = 20 # number of rows in the grid
cols = 30 # number of columns in the grid
dx = 10.0 # grid cell spacing
k = 0.01 # diffusivity coefficient, in m2/yr
num_time_steps = 10000 # number of time steps in run
Rho_r = 2700 # rock density kg/m3
Rho_s = 1600 # soil density kg/m3
kappa = 0.003 # m^2/yr
k = kappa * Rho_s # efficientcy
max_elev = 1000 # m
wdotnaught = 0.005 # m/yr
Hstar = 0.4 # m
hill_slope = 0.5
# Derived parameters
dt = 0.1 * dx ** 2 / k # time-step size set by CFL condition
# Create and initialize a raster model grid
mg = RasterModelGrid(rows, cols, dx)
# Set the boundary conditions
mg.set_closed_boundaries_at_grid_edges(False, False, True, True)
# Set up scalar values
zb = mg.add_zeros("node", "Elevation")
H = mg.add_zeros("node", "regolith_thickness")
z_H = mg.add_empty("node", "regolith_elevation")
dzda = mg.add_zeros("link", "surface_slope")
zb[:] = max_elev - mg.node_x * hill_slope # bedrock height
z_H[:] = zb + H # bedrock + regolith
# Get a list of the core cells
core_nodes = mg.core_nodes
# Display a message, and record the current clock time
print("Running diffusion_with_model_grid.py")
print("Time-step size has been set to " + str(dt) + " years.")
start_time = time.time()
# RUN
# Main loop
for i in range(0, num_time_steps):
# Calculate the weathering rate
wdot = wdotnaught * np.exp(-H / Hstar)
# slope
dzda = mg.calculate_gradients_at_active_links(z_H)
# Flux
Q = -k * dzda
# flux gradient
dqds = mg.calculate_flux_divergence_at_nodes(Q)
# rate of regolith thickness change
dHdt = ((Rho_r / Rho_s) * wdot) - ((1 / Rho_s) * dqds)
# regolith thickness
H = H + (dHdt * dt)
# bedrock
zb = zb - (wdot * dt)
# Don't know syntax for placing channel boundary conditions...
# zb(2:end-1) = zb(2:end-1)-(wdot(2:end-1)*dt); % change of bedrock due to weathering
# zb(1)=zb(1)-(edot*dt); % fixed boundary condition channel erosion
# zb(end)=zb(end)-(edot*dt); % fixed boundary condition channel erosion
# Update the elevations
z_H[core_nodes] = zb[core_nodes] + H[core_nodes]
# FINALIZE
# Get a 2D array version of the elevations
zr = mg.node_vector_to_raster(H)
# Create a shaded image
pylab.close() # clear any pre-existing plot
im = pylab.imshow(zr, cmap=pylab.cm.RdBu, extent=[0, cols * dx, 0, rows * dx], origin="lower")
# add contour lines with labels
cset = pylab.contour(zr, extent=[0, cols * dx, rows * dx, 0], hold="on", origin="image")
pylab.clabel(cset, inline=True, fmt="%1.1f", fontsize=10)
# add a color bar on the side
cb = pylab.colorbar(im)
cb.set_label("Thickness in meters")
# add a title and axis labels
pylab.title("Regolith thickness")
pylab.xlabel("Distance (m)")
pylab.ylabel("Distance (m)")
# Display the plot
pylab.show()
print("Run time = " + str(time.time() - start_time) + " seconds")
# Get a 2D array version of the elevations
zr = mg.node_vector_to_raster(z_H)
# Create a shaded image
pylab.close() # clear any pre-existing plot
im = pylab.imshow(zr, cmap=pylab.cm.RdBu, extent=[0, cols * dx, 0, rows * dx], origin="lower")
# add contour lines with labels
cset = pylab.contour(zr, extent=[0, cols * dx, rows * dx, 0], hold="on", origin="image")
pylab.clabel(cset, inline=True, fmt="%1.1f", fontsize=10)
# add a color bar on the side
cb = pylab.colorbar(im)
cb.set_label("Elevation in meters")
# add a title and axis labels
pylab.title("Simulated topography")
pylab.xlabel("Distance (m)")
pylab.ylabel("Distance (m)")
# Display the plot
pylab.show()
print("Run time = " + str(time.time() - start_time) + " seconds")
def test_add_field_with_units(at):
grid = RasterModelGrid((4, 5))
grid.add_empty("temperature", at=at, units="C")
assert getattr(grid, "at_{0}".format(at)).units["temperature"] == "C"
def _test():
rmg = RasterModelGrid(4, 5)
number_of_elements = rmg.number_of_elements(element)
rtn_values = rmg.add_empty(element, 'name')
assert_is(rtn_values, rmg.field_values(element, 'name'))
assert_array_equal(rtn_values.size, number_of_elements)
def test_add_empty(graph_element):
grid = RasterModelGrid((4, 5))
rtn_values = grid.add_empty("name", at=graph_element, dtype=field_dtype)
assert rtn_values is grid.field_values(graph_element, "name")
elapsed_time = 0.0 # total time in simulation
report_interval = 2 # interval to report progress (minutes)
next_report = time.time()+report_interval # next time to report progress
n = 0.1 # for Manning eq
R = 0.6 # rainfall
I = 0.005 # infiltration
C = R-I # constant for loop
# Create Grid
mg = RasterModelGrid(num_rows, num_cols, dx)
core_nodes = mg.core_nodes
zr = mg.add_empty('node', 'land_surface_elevation')
zw = mg.add_empty('node','water_surface')
H = mg.add_zeros('node','water_height')
Q = mg.add_zeros('node','flux')
zr[:] = Zmax - m*mg.node_x
zr += m * np.abs(mg.node_y - mg.dx * ((num_rows - 1) / 2.0))
zw[:] = zr+H
# Display a message
print( 'Running ...' )
start_time = time.time()
# RUN
def _test():
rmg = RasterModelGrid(4, 5)
number_of_elements = rmg.number_of_elements(element)
rtn_values = rmg.add_empty(element, 'name')
assert_is(rtn_values, rmg.field_values(element, 'name'))
assert_array_equal(rtn_values.size, number_of_elements)
def _test():
rmg = RasterModelGrid((4, 5))
number_of_elements = rmg.number_of_elements(element)
rtn_values = rmg.add_empty(element, "name")
assert rtn_values is rmg.field_values(element, "name")
assert_array_equal(rtn_values.size, number_of_elements)
P = 2000 # period of the ELA osillations [=] years
# create a grid manually:
num_rows = 10
num_cols = 10
mg = RasterModelGrid(num_rows, num_cols, dx)
# imshow_node_grid(mg, name='elevation')
"""
# alternativley, you can based it on a DEM with something like this...
(mg, z) = read_esri_ascii('upper_arkansas_10m.asc', name='elevation')
"""
# create data fields
z = mg.add_empty('node', 'elevation')
H = mg.add_zeros('node', 'ice_thickness')
z_ice = mg.add_empty('node', 'ice_elevation')
dZicedx = mg.add_zeros('link', 'ice_surface_slope')
# initialize 2-D elevations (simple, open book)
z[:] = z_max - mg.node_x * S
z += side_S * np.abs(mg.node_y - mg.dx * ((num_rows - 1) / 2.0))
mg.set_closed_boundaries_at_grid_edges(True, True, True, True)
core_nodes = mg.core_nodes
# setting up ice thickness
z_ice[:] = z + H
##--Grid Parameters
dx = 10 #spacing between grid cells (1 m^2 grid cell)
num_rows = 12 #10 grid rows
num_cols = 12 #10 grid columns
##--2D Grid Dimensions
mg = RasterModelGrid(num_cols, num_rows, dx) #make 2D grid
##--Initialize Overland Flow Model Data Fields
zs = mg.add_zeros('node', 'land_surface_elevation') #bedrock elevation (m)
hh = mg.add_zeros('node', 'water_thickness') #thickness of water (m)
zw = mg.add_empty('node', 'water_elevation') #water+bedrock elevation (m)
w_slope = mg.add_zeros(
'link',
'water_slope') #slope of water surface; make all links have zero slope
wsub_slope = mg.add_zeros('link', 'soil_moisture_slope')
q = mg.add_zeros('link', 'water_flux') #flux of water (ms-1)
sat_zone_thickness = mg.add_zeros(
'link', 'saturated_zone_thickness_at_link') #soil water thickness at links
thickness_node = mg.add_zeros(
'node', 'saturated_zone_thickness_at_node') #soil water thickness at nodes
subwater_height_node = mg.add_zeros(
'node',
'subwater_height_at_node') #total height of soil water (thickness+bedrock)
##--Initialize Randomized Elevation
t_min = 0 #s
t_max = 18000 #s
dt = 0.3 #s
timearray = np.arange(t_min, t_max + dt, dt)
time_interval = [
timearray[i:i + int((round(len(timearray) / 4)))]
for i in range(0, len(timearray), int(round(len(timearray) / 4)))
]
#2D grid dimensions
x_ncells = num_cols
y_ncells = num_rows
mg = RasterModelGrid(x_ncells, y_ncells, dx) #make 2D grid
#Create data fields
zb = mg.add_empty('node', 'land_surface_elevation')
h = mg.add_zeros('node', 'water_thickness')
zw = mg.add_empty('node', 'water_elevation')
w_slope = mg.add_zeros('link', 'water_slope') #make all links have zero slope
q = mg.add_zeros('link', 'flux')
#Initialize elevation
zb[:] = zmax - valley_s * mg.node_x
zb += side_s * np.abs(mg.node_y - mg.dx * ((num_rows - 1) / 2.0))
zw[:] = zb + h
#Define constants
n = 0.045 #roughness of bed surface
r = mg.add_ones('node', 'rain_rate')
inf = mg.add_ones('node', 'infiltration_rate')
t = np.arange(0,tmax,dt)
nsteps = int(len(t)/dt)
tplot = 100 # time between plots
nplots = tmax/tplot # number of plots
usl = 0.1 # sliding velocity, m/yr
A = 2.1*10**-16 # yr^-1*Pa^-3
icedens = 850 # kg/m^3
g =9.81 # m/s^2
# Create grid
mg = RasterModelGrid(num_rows, num_cols, dx)
# Create data fields
z = mg.add_empty('node', 'elevation')
H = mg.add_zeros('node', 'ice_thickness')
z_ice = mg.add_empty('node', 'ice_elevation')
dZicedx = mg.add_zeros('link', 'ice_surface_slope')
# Initialize elevation ("open book" shape)
# (Note: using "z[:] =" instead of "z =" means you are using the same block of
# memory instead of making a new copy)
z[:] = max_elev - mg.node_x * valley_slope
z += side_slope * np.abs(mg.node_y - mg.dx * ((num_rows - 1) / 2.0))
z_ice[:] = z + H
mg.set_closed_boundaries_at_grid_edges(True, True, True, True)
core_nodes = mg.core_nodes
def _test():
rmg = RasterModelGrid((4, 5))
number_of_elements = rmg.number_of_elements(element)
rtn_values = rmg.add_empty(element, "name")
assert rtn_values is rmg.field_values(element, "name")
assert_array_equal(rtn_values.size, number_of_elements)
num_cols = 100 # number of columns
dx = 10 # grid spacing
mx = 0.05 # slope of rock in x
my = 0.05# slope of rock in y
topomax = 100 # maximum elevation
dt = 0.1 # minutes
n = 0.05 # manning coefficient
R = 0.0003 # rainfall
I = 0 # infiltration
#Make the Grid
mg = RasterModelGrid(num_rows, num_cols, dx)
core_nodes = mg.core_nodes
# Create Variable Arrays
ground_elevation = mg.add_empty('node', 'land_surface_elevation')
water_elevation = mg.add_empty('node','water_surface_elevation')
H = mg.add_zeros('node','water_height')
Q = mg.add_zeros('link','flux')
dQdA = np.zeros(mg.number_of_links)
# Set Elevations
ground_elevation[:] = topomax - mx*mg.node_x
ground_elevation += my * np.abs(mg.node_y - mg.dx * ((num_rows - 1) / 2.0))
water_elevation[:] = ground_elevation+H
#Boundary Conditions - only open at downslope side
mg.set_closed_boundaries_at_grid_edges(False, True, True, True)
#Calculate Surface Slopes
