r.accumulate - GRASS GIS manual

NAME

r.accumulate - Calculates weighted flow accumulation, stream networks, and the longest flow path using a flow direction map.

KEYWORDS

raster, hydrology, watershed

SYNOPSIS

r.accumulate

r.accumulate --help

r.accumulate [-nc] direction=name format=string [weight=name] [input_accumulation=name] [accumulation=name] [threshold=float] [stream=name] [coordinates=east,north[,east,north,...]] [id=integer[,integer,...]] [outlet=name] [outlet_layer=string] [outlet_id_column=name] [id_column=name] [longest_flow_path=name] [--overwrite] [--help] [--verbose] [--quiet] [--ui]

Flags:

-n: Use negative flow accumulation for likely underestimates
-c: Delineate streams across confluences
--overwrite: Allow output files to overwrite existing files
--help: Print usage summary
--verbose: Verbose module output
--quiet: Quiet module output
--ui: Force launching GUI dialog

Parameters:

direction=name [required]: Name of input direction map
format=string [required]: Format of input direction map; Options: auto, degree, 45degree; Default: auto; auto: auto-detect direction format; degree: degrees CCW from East; 45degree: degrees CCW from East divided by 45 (e.g. r.watershed directions)
weight=name: Name of input flow weight map
input_accumulation=name: Name of input weighted flow accumulation map
accumulation=name: Name for output weighted flow accumulation map
threshold=float: Minimum flow accumulation for streams
stream=name: Name for output stream vector map
coordinates=east,north[,east,north,...]: Coordinates of longest flow path outlet point
id=integer[,integer,...]: ID for longest flow path
outlet=name: Name of input outlet vector map for longest flow path; Or data source for direct OGR access
outlet_layer=string: Layer number or name for outlet points; Vector features can have category values in different layers. This number determines which layer to use. When used with direct OGR access this is the layer name.; Default: 1
outlet_id_column=name: Name of longest flow path ID column in outlet vector map
id_column=name: Name for output longest flow path ID column
longest_flow_path=name: Name for output longest flow path vector map

DESCRIPTION
NOTES
EXAMPLES
SEE ALSO
AUTHOR

DESCRIPTION

r.accumulate calculates weighted flow accumulation, stream networks, and the longest flow path using a flow direction map.

NOTES

Flow accumulation

Unlike r.watershed, r.accumulate does not require the elevation data to calculate weighted flow accumulation. Instead, this module only uses a flow direction map to trace and accumulate the amount of flow draining through and including each cell.

With -n flag, the module will count the number of upstream cells plus one and convert it to the negative if any upstream cells are likely to receive flow from outside the computational region (flow direction edges). Negative values identify cells with likely underestimates because not all upstream cells were accounted for. Since raster map weight may contain negative flow weights, -n flag is not compatible with weight option. Running the module twice with and without -n flag and weight option may be useful in this specific case.

The module recognizes two different formats of the flow direction map:

Direction encoding for neighbors of x

  135  90  45             3 2 1
  180  x  360             4 x 8
  225 270 315             5 6 7

  degrees              45 degrees
  CCW from East        CCW from East
                   (r.watershed drainage)

Since the module does not use elevation data (i.e., slope), flow accumulation is calculated by single flow direction (SFD) routing and may not be comparable to the result from multiple flow direction (MFD) routing.

The module requires flow accumulation for any output, so it will internally accumulate flows every time it runs unless input_accumulation option is provided to save computational time by not repeating this process. In this case, it is important to use flow accumulation consistent with the flow direction map (e.g., accumulation output from this module).

Stream network delineation

With stream and threshold options, the module will delineate stream networks with the minimum flow accumulation for stream generation. A weight input map may be used with threshold. Delineated stream lines are split at confluences.

With -c flag, stream lines are delineated across confluences and may overlap with other stream lines that share the same downstream outlet.

Longest flow path calculation

With longest_flow_path option, the module will create a longest flow path vector map for outlet points specified by coordinates and/or outlet with outlet_layer option. You can assign unique IDs to longest flow paths using id (with coordinates) and/or outlet_id_column (with outlet). Assigning IDs also requires id_column option to specify the output column name for the IDs in the longest_flow_path vector map. The outlet_id_column specifies a column in the outlet vector map that contains unique IDs to be copied over to the id_column column in the output map. This column must be of integer type.

EXAMPLES

These examples use the North Carolina sample dataset.

Flow accumulation

Calculate flow accumulation using r.watershed and r.accumulate:

# set computational region
g.region raster=elevation -p

# calculate positive flow accumulation and drainage directions using r.watershed
# for comparison, use -s (SFD)
r.watershed elevation=elevation accumulation=flow_accum drainage=drain_directions -s -a

# calculate flow accumulation using r.accumulate
r.accumulate direction=drain_directions accumulation=flow_accum_new

# copy color table
r.colors map=flow_accum_new raster=flow_accum

# check difference betwen flow_accum and flow_accum_new
r.mapcalc expression="accum_diff=if(flow_accum-flow_accum_new, flow_accum-flow_accum_new, null())"

For some reaon, there are slight differences between the two output maps.

The yellow and purple cells show the difference raster map (accum_diff). The red arrows and numbers represent drainage directions (drain_directions) and flow accumulation (flow_accum from r.watershed), respectively. Note that some cells close to headwater cells are assigned 1 even if they are located downstream of other cells.

For comparison, these numbers show the new flow accumulation (flow_accum_new from r.accumulate). The same cells are properly accumulated from the headwater cells.

Stream network delineation

Calculate flow accumulation and delineate stream networks at once:

# set computational region
g.region raster=elevation -p

# calculate positive flow accumulation and drainage directions using r.watershed
# for comparison, use -s (SFD)
r.watershed elevation=elevation accumulation=flow_accum drainage=drain_directions -s -a

# use r.accumulate to create flow_accum_new and streams_new at once
r.accumulate direction=drain_directions accumulation=flow_accum_new threshold=50000 stream=streams_new

# or delineate stream networks only without creating an accumulation map
r.accumulate direction=drain_directions threshold=50000 stream=streams_new_only

# use r.stream.extract, elevation, and flow_accum_new to delineate stream networks
r.stream.extract elevation=elevation accumulation=flow_accum threshold=50000 stream_vector=streams_extract direction=drain_directions_extract

In this example, r.accumulate and r.stream.extract produced slightly different stream networks where the flow turns 90 degrees or there are multiple downstream cells with the same elevation. The following figure shows an example where the streams (red from r.stream.extract) and streams_new (blue from r.accumulate) vector maps present different stream paths. The numbers show cell elevations (elevation map), and the yellow (drain_directions map) and green (drain_directions_2 map) arrows represent flow directions generated by r.watershed with -s flag and r.stream.extract, respectively. Note that the two flow direction maps are different.

Longest flow path calculation

Create the longest flow path for one outlet:

# set computational region
g.region raster=elevation -p

# calculate drainage directions using r.watershed
r.watershed elevation=elevation drainage=drain_directions -s -a

# delineate watershed
r.water.outlet input=drain_directions output=basin coordinates=642455,222614

# calculate longest flow path
r.accumulate direction=drain_directions lfp=lfp coordinates=642455,222614

Note that there can be more than one longest flow path when multiple paths have the same flow length. In fact, the above example produces two lines with the same length.

There are different ways to calculate multiple longest flow paths in one run:

# set computational region
g.region raster=elevation -p

# calculate drainage directions using r.watershed
r.watershed elevation=elevation drainage=drain_directions -s -a

# calculate longest flow paths at two outlets
r.accumulate direction=drain_directions lfp=lfp coordinates=642455,222614,642306,222734

# calculate longest flow paths at two outlets and assign IDs
r.accumulate direction=drain_directions lfp=lfp_w_id coordinates=642455,222614,642306,222734 \
    id=1,2 id_column=lfp_id

# calculate longest flow paths at all points in the outlets map
r.accumulate direction=drain_directions lfp=lfp_at_outlets outlet=outlets

# calculate longest flow paths at all points in the outlets map and assign IDs using a column in this map
r.accumulate direction=drain_directions lfp=lfp_at_outlets_w_id outlet=outlets \
    id_column=lfp_id outlet_id_column=outlet_id

# calculate longest flow paths at given coordinates and all points in the outlets map and assign IDs
r.accumulate direction=drain_directions lfp=lfp_multi_w_id coordinates=642455,222614,642306,222734 outlet=outlets \
    id=1,2 id_column=lfp_id outlet_id_column=outlet_id

Calculate the longest flow paths for sub-watersheds:

# set computational region
g.region raster=elevation -p

# calculate drainage directions using r.watershed
r.watershed elevation=elevation drainage=drain_directions -s -a

# get nsres
eval `r.info -g map=elevation`

# delineate streams using a threshold
r.accumulate direction=drain_directions threshold=50000 stream=streams

# populate stream lengths
v.db.addtable map=streams columns="length double"
v.to.db map=streams option=length columns=length

# create points along the streams starting from downstream
v.to.points -r input=streams output=stream_points dmax=$nsres

# find outlets (downstream-most less nsres points)
cats=`db.select -c sql="select stream_points_2.cat from stream_points_2 \
    inner join stream_points_1 on stream_points_1.cat = stream_points_2.lcat \
    where length-along > 0.5*$nsres and length-along < 1.5*$nsres"`
cats=`echo $cats | tr " " ,`
v.extract input=stream_points layer=2 cats=$cats output=stream_outlets

# create the longest flow paths for all outlets
r.accumulate direction=drain_directions lfp=lfp id_column=id outlet=stream_outlets outlet_layer=2 outlet_id_column=lcat

AUTHOR

Huidae Cho

SOURCE CODE

Available at: r.accumulate source code (history)