knitr::opts_chunk$set( collapse = TRUE, comment = "#>", fig.width = 6, fig.height = 4 )
The reval
package is a redesign of the reval
package that
takes advantage of functionality provided by tidyverse
,
furrr
, and the future
package. The original reval
package
attempted to provide a one-size-fits-all wrapper function
combining packages doParallel
and foreach
along with the
argument combination logic. In contrast, reval
provides the
basic building blocks for generating argument sets in a format
that will work with the tidyverse
and furrr
framework.
The basic procedure is
1) Generate argument sets using the reval
functions
args_set()
, args_ofat()
, or args_permute()
.
2) Define a plan using future::plan()
.
3) Evaluate the function and argument sets using furrr::pmap
.
In-stream structures such as dams, weirs and culverts modify flows in a river. In large rivers with tranquil flows, such structures can affect the river stage (water depth) many miles upstream. These water surface profiles or "backwater curves" can be modelled using well-understood hydraulic relationships. One important parameter---a coefficient representing the texture or "roughness" of the river bed---is empirical and cannot be easily measured. Therefore it is often important for engineers to compute these backwater curves for a range of roughness values in order to establish confidence limits for planning and management purposes.
The rivr
package provides the function compute_profile
for
modelling backwater curves in prismatic channels given a known water
depth at a specified location. Computing a single profile would look
something like this:
library(rivr) myprofile = compute_profile(So = 0.001, n = 0.045, Q = 250, y0 = 2.5, Cm = 1.486, g = 32.2, B = 100, SS = 0, stepdist = 50, totaldist = 3000) head(myprofile)
In order to perform a sensitivity analysis on the effect of the roughness parameter on the backwater curve, we need to compare a variety of roughness values (the argument "n") and compile the results for comparison. Following the procedure described above, we might come up with something like this:
library(reval) library(dplyr) library(future) library(furrr) # generate the argument table arg_tbl = args_set(n = seq(0.03, 0.06, by = 0.005)) # define the plan (from 'future' package) # could also use e.g. 'callr', 'multicore', etc. plan(sequential) # get output as list-column of argument table # using furrr:future_pmap results = mutate(arg_tbl, output = future_pmap(arg_tbl, compute_profile, So = 0.001, Q = 250, y0 = 2.5, Cm = 1.486, g = 32.2, B = 100, SS = 0, stepdist = 50, totaldist = 3000) )
Wrapping the future_pmap()
call in a dplyr::mutate()
statement adds
the results (as a list column) to the argument table. This keeps the
outputs associated with the arguments, allowing you to use the argument
values as identifiers as you do further transformations on the outputs.
For example, compute_profile()
returns a dataframe which can be
unnested using tidyr::unnest()
to quickly prepare the data for
plotting:
library(tidyr) library(ggplot2) ggplot(unnest(results, output)) + aes(x = x, y = y, color = factor(n)) + geom_line() + scale_color_viridis_d("Manning's n")
Other factors can also influence the water surface profile, such as the
channel slope and the angle of the channel walls. Here we use
args_permute()
to generate a table of all possible permutations of
the three parameters.
arg_tbl = args_permute(n = seq(0.03, 0.06, by = 0.005), So = seq(0.001, 0.0015, by = 0.00025), SS = seq(0, 6, by = 2) ) results = mutate(arg_tbl, output = future_pmap(arg_tbl, compute_profile, Q = 250, y0 = 2.5, Cm = 1.486, g = 32.2, B = 100, stepdist = 50, totaldist = 3000))
ggplot(unnest(results, output)) + aes(x = x, y = y, color = factor(n)) + geom_line() + facet_grid(SS ~ So) + scale_color_viridis_d("Manning's n")
That's it!
Any scripts or data that you put into this service are public.
Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.