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)) 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 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
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