Landlab component that simulates overland flow.
This component simulates overland flow using the 2D numerical model of shallowwater flow over topography using the de Almeida et al., 2012 algorithm for storagecell inundation modeling.
Code author: Jordan Adams
>>> import numpy as np
>>> from landlab import RasterModelGrid
>>> from landlab.components.overland_flow import OverlandFlow
Create a grid on which to calculate overland flow.
>>> grid = RasterModelGrid((4, 5))
The grid will need some data to provide the overland flow component. To check the names of the fields that provide input to the overland flow component use the input_var_names class property.
>>> OverlandFlow.input_var_names
('surface_water__depth', 'topographic__elevation')
Create fields of data for each of these input variables.
>>> grid.at_node['topographic__elevation'] = np.array([
... 0., 0., 0., 0., 0.,
... 1., 1., 1., 1., 1.,
... 2., 2., 2., 2., 2.,
... 3., 3., 3., 3., 3.])
>>> grid.at_node['surface_water__depth'] = np.array([
... 0. , 0. , 0. , 0. , 0. ,
... 0. , 0. , 0. , 0. , 0. ,
... 0. , 0. , 0. , 0. , 0. ,
... 0.1, 0.1, 0.1, 0.1, 0.1])
Instantiate the OverlandFlow component to work on this grid, and run it.
>>> of = OverlandFlow(grid, steep_slopes=True)
>>> of.run_one_step()
After calculating the overland flow, new fields have been added to the grid. Use the output_var_names property to see the names of the fields that have been changed.
>>> of.output_var_names
('surface_water__depth', 'surface_water__discharge', 'water_surface__gradient')
The surface_water__depth field is defined at nodes.
>>> of.var_loc('surface_water__depth')
'node'
>>> grid.at_node['surface_water__depth']
array([ 1.00000000e05, 1.00000000e05, 1.00000000e05,
1.00000000e05, 1.00000000e05, 1.00000000e05,
1.00000000e05, 1.00000000e05, 1.00000000e05,
1.00000000e05, 1.00000000e05, 2.00100000e02,
2.00100000e02, 2.00100000e02, 1.00000000e05,
1.00010000e01, 1.00010000e01, 1.00010000e01,
1.00010000e01, 1.00010000e01])
The surface_water__discharge field is defined at links. Because our initial topography was a dipping plane, there is no water discharge in the horizontal direction, only toward the bottom of the grid.
>>> of.var_loc('surface_water__discharge')
'link'
>>> q = grid.at_link['surface_water__discharge']
>>> np.all(q[grid.horizontal_links] == 0.)
True
>>> np.all(q[grid.vertical_links] <= 0.)
True
The water_surface__gradient is also defined at links.
>>> of.var_loc('water_surface__gradient')
'link'
>>> grid.at_link['water_surface__gradient']
array([ 0. , 0. , 0. , 0. ,
0. , 1. , 1. , 1. , 0. ,
0. , 0. , 0. , 0. ,
0. , 1. , 1. , 1. , 0. ,
0. , 0. , 0. , 0. ,
0. , 1.1, 1.1, 1.1, 0. ,
0. , 0. , 0. , 0. ])
OverlandFlow
(self, grid, default_fixed_links=False, h_init=1e05, alpha=0.7, mannings_n=0.03, g=9.81, theta=0.8, rainfall_intensity=0.0, steep_slopes=False, **kwds)[source]¶Bases: landlab.core.model_component.Component
Simulate overland flow using de Almeida approximations.
Landlab component that simulates overland flow using the de Almeida et al., 2012 approximations of the 1D shallow water equations to be used for 2D flood inundation modeling.
This component calculates discharge, depth and shear stress after some precipitation event across any raster grid. Default input file is named “overland_flow_input.txt’ and is contained in the landlab.components.overland_flow folder.
The primary method of this class is run_one_step()
.
Create an overland flow component.
Parameters:  grid : RasterModelGrid
h_init : float, optional
alpha : float, optional
mannings_n : float, optional
g : float, optional
theta : float, optional
rainfall_intensity : float, optional


calc_time_step
()[source]¶Calculate time step.
Adaptive time stepper from Bates et al., 2010 and de Almeida et al., 2012
discharge_mapper
(input_discharge, convert_to_volume=False)[source]¶Maps discharge value from links onto nodes.
This method takes the discharge values on links and determines the links that are flowing INTO a given node. The fluxes moving INTO a given node are summed.
This method ignores all flow moving OUT of a given node.
This takes values from the OverlandFlow component (by default) in units of [L^2/T]. If the convert_to_cms flag is raised as True, this method converts discharge to units [L^3/T]  as of Aug 2016, only operates for square RasterModelGrid instances.
The output array is of length grid.number_of_nodes and can be used with the Landlab imshow_grid plotter.
Returns a numpy array (discharge_vals)
overland_flow
(dt=None)[source]¶Generate overland flow across a grid.
For one time step, this generates ‘overland flow’ across a given grid by calculating discharge at each node.
Using the depth slope product, shear stress is calculated at every node.
Outputs water depth, discharge and shear stress values through time at every point in the input grid.
run_one_step
(dt=None)[source]¶Generate overland flow across a grid.
For one time step, this generates ‘overland flow’ across a given grid by calculating discharge at each node.
Using the depth slope product, shear stress is calculated at every node.
Outputs water depth, discharge and shear stress values through time at every point in the input grid.
find_active_neighbors_for_fixed_links
(grid)[source]¶Find active link neighbors for every fixed link.
Specialized link ID function used to ID the active links that neighbor fixed links in the vertical and horizontal directions.
If the user wants to assign fixed gradients or values to the fixed links dynamically, this function identifies the nearest active_link neighbor.
Each fixed link can either have 0 or 1 active neighbor. This function finds if and where that active neighbor is and stores those IDs in an array.
Parameters:  grid : RasterModelGrid


Returns:  ndarray of int, shape (*, )

Examples
>>> from landlab.grid.structured_quad.links import neighbors_at_link
>>> from landlab import RasterModelGrid
>>> from landlab.components.overland_flow.generate_overland_flow_deAlmeida import find_active_neighbors_for_fixed_links
>>> from landlab import RasterModelGrid, FIXED_GRADIENT_BOUNDARY
>>> grid = RasterModelGrid((4, 5))
>>> grid.status_at_node[:5] = FIXED_GRADIENT_BOUNDARY
>>> grid.status_at_node[::5] = FIXED_GRADIENT_BOUNDARY
>>> grid.status_at_node
array([2, 2, 2, 2, 2,
2, 0, 0, 0, 1,
2, 0, 0, 0, 1,
2, 1, 1, 1, 1], dtype=uint8)
>>> grid.fixed_links
array([ 5, 6, 7, 9, 18])
>>> grid.active_links
array([10, 11, 12, 14, 15, 16, 19, 20, 21, 23, 24, 25])
>>> find_active_neighbors_for_fixed_links(grid)
array([14, 15, 16, 10, 19])
>>> rmg = RasterModelGrid((4, 7))
>>> rmg.at_node['topographic__elevation'] = rmg.zeros(at='node')
>>> rmg.at_link['topographic__slope'] = rmg.zeros(at='link')
>>> rmg.set_fixed_link_boundaries_at_grid_edges(True, True, True, True)
>>> find_active_neighbors_for_fixed_links(rmg)
array([20, 21, 22, 23, 24, 14, 17, 27, 30, 20, 21, 22, 23, 24])
generate_overland_flow.py
This component simulates overland flow using the 2D numerical model of shallowwater flow over topography using the Bates et al. (2010) algorithm for storagecell inundation modeling.
Written by Jordan Adams, based on code written by Greg Tucker.
Last updated: April 21, 2016
OverlandFlowBates
(grid, h_init=1e05, alpha=0.7, mannings_n=0.03, g=9.81, rainfall_intensity=0.0, **kwds)[source]¶Bases: landlab.core.model_component.Component
Simulate overland flow using Bates et al. (2010).
Landlab component that simulates overland flow using the Bates et al., (2010) approximations of the 1D shallow water equations to be used for 2D flood inundation modeling.
This component calculates discharge, depth and shear stress after some precipitation event across any raster grid. Default input file is named “overland_flow_input.txt’ and is contained in the landlab.components.overland_flow folder.
Parameters:  grid : RasterGridModel
input_file : str
h_init : float, optional
g : float, optional
alpha : float, optional
rho : integer, optional
ten_thirds : float, optional


Examples
>>> DEM_name = 'DEM_name.asc'
>>> (rg, z) = read_esri_ascii(DEM_name)
>>> of = OverlandFlowBates(rg)
overland_flow
(dt=None, **kwds)[source]¶For one time step, this generates ‘overland flow’ across a given grid by calculating discharge at each node.
Using the depth slope product, shear stress is calculated at every node.
Outputs water depth, discharge and shear stress values through time at every point in the input grid.
Parameters:  grid : RasterModelGrid
dt : float, optional

