diff --git a/DESCRIPTION b/DESCRIPTION
index 56631f99114c9ee736a8ce4626e3c71b1a7307b8..da6556c119c3217ef736dfc15d8320ebb12dc19f 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -1,7 +1,7 @@
Package: airGR
Type: Package
Title: Suite of GR Hydrological Models for Precipitation-Runoff Modelling
-Version: 1.0.15.14
+Version: 1.1.0.0
Date: 2018-10-17
Authors@R: c(
person("Laurent", "Coron", role = c("aut", "trl"), comment = c(ORCID = "0000-0002-1503-6204")),
diff --git a/R/CreateInputsCrit.R b/R/CreateInputsCrit.R
index 83b3b025587b198ce466762312aea1eab77e2a0d..c22396c55ce33dcbc760da23ad1ae6ca2d651d65 100644
--- a/R/CreateInputsCrit.R
+++ b/R/CreateInputsCrit.R
@@ -2,121 +2,238 @@ CreateInputsCrit <- function(FUN_CRIT,
InputsModel,
RunOptions,
Qobs,
+ obs,
+ varObs = "Qobs",
BoolCrit = NULL,
transfo = "",
+ # groupLayer,
+ weights = NULL,
Ind_zeroes = NULL,
epsilon = NULL,
+ warnings = TRUE,
verbose = TRUE) {
ObjectClass <- NULL
+ ## ---------- check arguments
- ##check_FUN_CRIT
- BOOL <- FALSE
-
- if (identical(FUN_CRIT, ErrorCrit_NSE) | identical(FUN_CRIT, ErrorCrit_KGE) |
- identical(FUN_CRIT, ErrorCrit_KGE2) | identical(FUN_CRIT, ErrorCrit_RMSE)) {
- BOOL <- TRUE
- }
- if (!BOOL) {
- stop("incorrect FUN_CRIT for use in CreateInputsCrit \n")
- return(NULL)
+ if (!missing(Qobs)) {
+ if (missing(obs)) {
+ if (warnings) {
+ warning("argument 'Qobs' is deprecated. Please use 'obs' and 'varObs' instead")
+ }
+ obs <- Qobs
+ # varObs <- "Qobs"
+ } else {
+ warning("argument 'Qobs' is deprecated. The values set in 'obs' will be used instead")
}
-
- ##check_arguments
- if (inherits(InputsModel, "InputsModel") == FALSE) {
- stop("InputsModel must be of class 'InputsModel' \n")
- return(NULL)
+ }
+ if (!missing(Ind_zeroes) & warnings) {
+ warning("Deprecated 'Ind_zeroes' argument")
+ }
+ if (!missing(verbose)) {
+ warning("Deprecated 'verbose' argument. Use 'warnings', instead")
+ }
+
+
+ ## create list of arguments
+ listArgs <- list(FUN_CRIT = FUN_CRIT,
+ obs = obs,
+ varObs = varObs,
+ BoolCrit = BoolCrit,
+ transfo = transfo,
+ # groupLayer = groupLayer,
+ weights = weights,
+ epsilon = epsilon)
+
+
+ ## check lists lengths
+ for (iArgs in names(listArgs)) {
+ if (iArgs %in% c("weights", "BoolCrit", "epsilon")) {
+ if (any(is.null(listArgs[[iArgs]]))) {
+ listArgs[[iArgs]] <- lapply(seq_along(listArgs$FUN_CRIT), function(x) NULL)
+ }
}
- if (inherits(RunOptions , "RunOptions") == FALSE) {
- stop("RunOptions must be of class 'RunOptions' \n")
- return(NULL)
+ if (!is.list(listArgs[[iArgs]])) {
+ listArgs[[iArgs]] <- list(listArgs[[iArgs]])
}
-
- LLL <- length(InputsModel$DatesR[RunOptions$IndPeriod_Run])
-
- if (is.null(Qobs)) {
- stop("Qobs is missing \n")
- return(NULL)
- }
- if (!is.vector(Qobs)) {
- stop(paste("Qobs must be a vector of numeric values \n", sep = ""))
- return(NULL)
+ }
+
+ ## check 'varObs'
+ if (missing(varObs)) {
+ listArgs$varObs <- as.list(rep("Qobs", times = length(listArgs$obs)))
+ if (warnings) {
+ warning("'varObs' automatically set to \"Qobs\"")
}
- if (!is.numeric(Qobs)) {
- stop(paste("Qobs must be a vector of numeric values \n", sep = ""))
- return(NULL)
+ }
+
+ ## check 'transfo'
+ if (missing(transfo)) {
+ listArgs$transfo <- as.list(rep("", times = length(listArgs$obs)))
+ if (warnings) {
+ warning("'transfo' automatically set to \"\"")
}
- if (length(Qobs) != LLL) {
- stop("Qobs and InputsModel series must have the same length \n")
+ }
+
+ ## check length of each args
+ if (length(unique(sapply(listArgs, FUN = length))) != 1) {
+ stopListArgs <- paste(sapply(names(listArgs), shQuote), collapse = ", ")
+ stop(sprintf("arguments %s must have the same length", stopListArgs))
+ }
+
+
+ ## check "InputsModel"
+ if (!inherits(InputsModel, "InputsModel")) {
+ stop("'InputsModel' must be of class 'InputsModel' \n")
+ return(NULL)
+ }
+
+
+ ## check 'RunOptions'
+ if (!inherits(RunOptions , "RunOptions")) {
+ stop("'RunOptions' must be of class 'RunOptions' \n")
+ return(NULL)
+ }
+
+ ## check 'weights'
+ if (length(listArgs$weights) > 1 & sum(unlist(listArgs$weights)) == 0 & !any(sapply(listArgs$weights, is.null))) {
+ stop("sum of 'weights' cannot be equal to zero \n")
+ }
+
+
+ ## reformat list of arguments
+ listArgs2 <- lapply(seq_along(listArgs$FUN_CRIT), function(i) lapply(listArgs, "[[", i))
+
+
+ ## length of index of period to be used for the model run
+ LLL <- length(InputsModel$DatesR[RunOptions$IndPeriod_Run])
+
+
+ ## preparation of warning messages
+ inVarObs <- c("Qobs") ##, "SCAobs")
+ msgVarObs <- "'varObs' must be a (list of) character vector(s) and one of %s \n"
+ msgVarObs <- sprintf(msgVarObs, paste(sapply(inVarObs, shQuote), collapse = ","))
+ inTransfo <- c("", "sqrt", "log", "inv", "sort")
+ msgTransfo <- "'transfo' must be a (list of) character vector(s) and one of %s \n"
+ msgTransfo <- sprintf(msgTransfo, paste(sapply(inTransfo, shQuote), collapse = ","))
+
+
+ ## ---------- loop on the list of inputs
+
+ InputsCrit <- lapply(listArgs2, function(iListArgs2) {
+
+ ## check 'FUN_CRIT'
+ if (!(identical(iListArgs2$FUN_CRIT, ErrorCrit_NSE ) | identical(iListArgs2$FUN_CRIT, ErrorCrit_KGE ) |
+ identical(iListArgs2$FUN_CRIT, ErrorCrit_KGE2) | identical(iListArgs2$FUN_CRIT, ErrorCrit_RMSE))) {
+ stop("incorrect 'FUN_CRIT' for use in 'CreateInputsCrit' \n", call. = FALSE)
return(NULL)
}
- if (is.null(BoolCrit)) {
- BoolCrit <- rep(TRUE, length(Qobs))
- }
- if (!is.logical(BoolCrit)) {
- stop("BoolCrit must be a vector of boolean \n")
+ if (identical(iListArgs2$FUN_CRIT, ErrorCrit_RMSE) & length(listArgs$weights) > 1 & all(!is.null(unlist(listArgs$weights)))) {
+ stop("calculating a composite criterion with the RMSE is not allowed since RMSE is not an adimensional measure \n", call. = FALSE)
return(NULL)
}
- if (length(BoolCrit) != LLL) {
- stop("BoolCrit and InputsModel series must have the same length \n")
- return(NULL)
+
+ ## check 'BoolCrit'
+ if (is.null(iListArgs2$BoolCrit)) {
+ iListArgs2$BoolCrit <- rep(TRUE, length(iListArgs2$obs))
}
- if (is.null(transfo)) {
- stop("transfo must be a chosen among the following: '', 'sqrt', 'log' or 'inv' or 'sort' \n")
+ if (!is.logical(iListArgs2$BoolCrit)) {
+ stop("'BoolCrit' must be a (list of) vector(s) of boolean \n", call. = FALSE)
return(NULL)
}
- if (!is.vector(transfo)) {
- stop("transfo must be a chosen among the following: '', 'sqrt', 'log' or 'inv' or 'sort' \n")
+ if (length(iListArgs2$BoolCrit) != LLL) {
+ print(str(LLL))
+ print(str(iListArgs2$BoolCrit))
+ stop("'BoolCrit' and 'InputsModel' series must have the same length \n", call. = FALSE)
return(NULL)
}
- if (length(transfo) != 1) {
- stop("transfo must be a chosen among the following: '', 'sqrt', 'log' or 'inv' or 'sort' \n")
+
+ ## check 'obs'
+ if (!is.vector(iListArgs2$obs) | length(iListArgs2$obs) != LLL | !is.numeric(iListArgs2$obs)) {
+ stop("'obs' must be a (list of) vector(s) of numeric values \n", call. = FALSE)
return(NULL)
}
- if (!is.character(transfo)) {
- stop("transfo must be a chosen among the following: '', 'sqrt', 'log' or 'inv' or 'sort' \n")
+
+ ## check 'varObs'
+ if (!is.vector(iListArgs2$varObs) | length(iListArgs2$varObs) != 1 | !is.character(iListArgs2$varObs) | !all(iListArgs2$varObs %in% inVarObs)) {
+ stop(msgVarObs, call. = FALSE)
return(NULL)
}
- if (! transfo %in% c("", "sqrt", "log", "inv", "sort")) {
- stop("transfo must be a chosen among the following: '', 'sqrt', 'log' or 'inv' or 'sort' \n")
+
+ ## check 'transfo'
+ if (is.null(iListArgs2$transfo) | !is.vector(iListArgs2$transfo) | length(iListArgs2$transfo) != 1 | !is.character(iListArgs2$transfo) | !all(iListArgs2$transfo %in% inTransfo)) {
+ stop(msgTransfo, call. = FALSE)
return(NULL)
}
- if (!missing(Ind_zeroes)) {
- warning("Deprecated \"Ind_zeroes\" argument")
- }
-
- if (!is.null(epsilon)) {
- if (!is.vector(epsilon) | length(epsilon) != 1 | !is.numeric(epsilon) | any(epsilon <= 0)) {
- stop("epsilon must a be single positive value \n")
+ ## check 'weights'
+ if (!is.null(iListArgs2$weights)) {
+ if (!is.vector(iListArgs2$weights) | length(iListArgs2$weights) != 1 | !is.numeric(iListArgs2$weights) | any(iListArgs2$weights < 0)) {
+ stop("'weights' must be a single (list of) positive or equal to zero value(s) \n", call. = FALSE)
return(NULL)
}
- } else if (transfo %in% c("log", "inv") & any(Qobs %in% 0) & verbose) {
- warning("zeroes detected in Qobs: the corresponding time-steps will be exclude by the 'ErrorCrit*' functions if the epsilon agrument = NULL")
}
- if (transfo == "log" & verbose) {
- warn_log_kge <- "we do not advise using the %s with a log transformation on Qobs (see the details part in the 'CreateInputsCrit' help)"
- if (identical(FUN_CRIT, ErrorCrit_KGE)) {
- warning(sprintf(warn_log_kge, "KGE"))
- }
- if (identical(FUN_CRIT, ErrorCrit_KGE2)) {
- warning(sprintf(warn_log_kge, "KGE'"))
+ ## check 'epsilon'
+ if (!is.null(iListArgs2$epsilon)) {
+ if (!is.vector(iListArgs2$epsilon) | length(iListArgs2$epsilon) != 1 | !is.numeric(iListArgs2$epsilon) | any(iListArgs2$epsilon <= 0)) {
+ stop("'epsilon' must be a single (list of) positive value(s) \n", call. = FALSE)
+ return(NULL)
}
+ } else if (iListArgs2$transfo %in% c("log", "inv") & any(iListArgs2$obs %in% 0) & warnings) {
+ warning("zeroes detected in obs: the corresponding time-steps will be excluded by the 'ErrorCrit*' functions if the epsilon agrument = NULL", call. = FALSE)
}
- ##Create_InputsCrit
- InputsCrit <- list(BoolCrit = BoolCrit,
- Qobs = Qobs,
- transfo = transfo,
- epsilon = epsilon)
-
- class(InputsCrit) <- c("InputsCrit", ObjectClass)
-
- return(InputsCrit)
-
+ ## check 'transfo' + 'FUN_CRIT'
+ if (iListArgs2$transfo == "log" & warnings) {
+ warn_log_kge <- "we do not advise using the %s with a log transformation on obs (see the details part in the 'CreateInputsCrit' help)"
+ if (identical(iListArgs2$FUN_CRIT, ErrorCrit_KGE)) {
+ warning(sprintf(warn_log_kge, "KGE"), call. = FALSE)
+ }
+ if (identical(iListArgs2$FUN_CRIT, ErrorCrit_KGE2)) {
+ warning(sprintf(warn_log_kge, "KGE'"), call. = FALSE)
+ }
+ }
+ ## Create InputsCrit
+ iInputsCrit <- list(FUN_CRIT = iListArgs2$FUN_CRIT,
+ obs = iListArgs2$obs,
+ varObs = iListArgs2$varObs,
+ BoolCrit = iListArgs2$BoolCrit,
+ # groupLayer = iListArgs2$groupLayer,
+ transfo = iListArgs2$transfo,
+ epsilon = iListArgs2$epsilon,
+ weights = iListArgs2$weights)
+ class(iInputsCrit) <- c("Single", "InputsCrit", ObjectClass)
+ return(iInputsCrit)
+ })
+ names(InputsCrit) <- paste0("IC", seq_along(InputsCrit))
+
+ # if only one criterion --> not a list of InputsCrit but directly an InputsCrit
+ if (length(InputsCrit) < 2) {
+ InputsCrit <- InputsCrit[[1L]]
+ InputsCrit["weights"] <- list(weights = NULL)
+ } else {
+ if (any(sapply(listArgs$weights, is.null))) {
+ for (iListArgs in InputsCrit) {
+ iListArgs$weights <- NULL
+ }
+ class(InputsCrit) <- c("Multi", "InputsCrit", ObjectClass)
+ } else {
+ class(InputsCrit) <- c("Compo", "InputsCrit", ObjectClass)
+ }
+ combInputsCrit <- combn(x = length(InputsCrit), m = 2)
+ apply(combInputsCrit, MARGIN = 2, function(i) {
+ equalInputsCrit <- identical(InputsCrit[[i[1]]], InputsCrit[[i[2]]])
+ if(equalInputsCrit) {
+ warning(sprintf("Elements %i and %i of the criteria list are identical. This might not be necessary", i[1], i[2]), call. = FALSE)
+ }
+ return(NULL)
+ })
}
+
+ return(InputsCrit)
+
+}
diff --git a/man/CreateInputsCrit.Rd b/man/CreateInputsCrit.Rd
index f8808238a2d3e9579e830225d553e8f1a772e467..ce3f2ff2b2c302a196a10a478e537029c6d279db 100644
--- a/man/CreateInputsCrit.Rd
+++ b/man/CreateInputsCrit.Rd
@@ -9,53 +9,74 @@
\usage{
-CreateInputsCrit(FUN_CRIT, InputsModel, RunOptions, Qobs, BoolCrit = NULL,
- transfo = "", Ind_zeroes = NULL, epsilon = NULL, verbose = TRUE)
+CreateInputsCrit(FUN_CRIT, InputsModel, RunOptions,
+ Qobs, obs, varObs = "Qobs", BoolCrit = NULL,
+ transfo = "", weights = NULL,
+ Ind_zeroes = NULL, epsilon = NULL,
+ warnings = TRUE, verbose = TRUE)
}
\arguments{
-\item{FUN_CRIT}{[function] error criterion function (e.g. \code{\link{ErrorCrit_RMSE}}, \code{\link{ErrorCrit_NSE}})}
+\item{FUN_CRIT}{[function (atomic or list)] error criterion function (e.g. \code{\link{ErrorCrit_RMSE}}, \code{\link{ErrorCrit_NSE}})}
\item{InputsModel}{[object of class \emph{InputsModel}] see \code{\link{CreateInputsModel}} for details}
\item{RunOptions}{[object of class \emph{RunOptions}] see \code{\link{CreateRunOptions}} for details}
-\item{Qobs}{[numeric] series of observed discharges [mm/time step]}
+\item{Qobs}{(deprecated) [numeric (atomic or list)] series of observed discharges [mm/time step]}
-\item{BoolCrit}{(optional) [boolean] boolean giving the time steps to consider in the computation (all time steps are consider by default)}
+\item{obs}{[numeric (atomic or list)] series of observed variable (typically discharge [mm/time step])}
-\item{transfo}{(optional) [character] name of the transformation (e.g. \code{""}, \code{"sqrt"}, \code{"log"}, \code{"inv"}, \code{"sort"})}
+\item{varObs}{(optional) [character (atomic or list)] names of the observed variable (\code{"Qobs"} by default])}
+
+\item{BoolCrit}{(optional) [boolean (atomic or list)] boolean (the same length as \code{obs}) giving the time steps to consider in the computation (all time steps are considered by default)}
+
+\item{transfo}{(optional) [character (atomic or list)] name of the transformation (e.g. \code{""}, \code{"sqrt"}, \code{"log"}, \code{"inv"}, \code{"sort"})}
+
+\item{weights}{(optional) [numeric (atomic or list)] vector of weights necessary to calculate a composite criterion (the same length as \code{FUN_CRIT}) giving the weights to use for elements of \code{FUN_CRIT} [-]}
\item{Ind_zeroes}{(deprecated) [numeric] indices of the time steps where zeroes are observed}
-\item{epsilon}{(optional) [numeric] small value to add to all Qobs and Qsim (useful when \code{"log"} or \code{"inv"} transformations are used) [same unit as \code{Qobs}]}
+\item{epsilon}{(optional) [numeric (atomic or list)] small value to add to all Qobs and Qsim (useful when \code{"log"} or \code{"inv"} transformations are used) [same unit as \code{obs}]}
-\item{verbose}{(optional) [boolean] boolean indicating if the function is run in verbose mode or not, default = \code{TRUE}}
+\item{warnings}{(optional) [boolean] boolean indicating if the warning messages are shown, default = \code{TRUE}}
+
+\item{verbose}{(deprecated) [boolean] boolean indicating if the function is run in verbose mode or not, default = \code{TRUE}}
}
\value{
[list] object of class \emph{InputsCrit} containing the data required to evaluate the model outputs; it can include the following:
- \tabular{ll}{
- \emph{$BoolCrit } \tab [boolean] boolean giving the time steps considered in the computation \cr
- \emph{$Qobs } \tab [numeric] series of observed discharges [mm/time step] \cr
- \emph{$transfo } \tab [character] name of the transformation (e.g. \code{""}, \code{"sqrt"}, \code{"log"}, \code{"inv"}, \code{"sort"}) \cr
- \emph{$epsilon } \tab [numeric] small value to add to all Qobs and Qsim (useful when \code{"log"} or \code{"inv"} transformations are used) [same unit as \code{Qobs}] \cr
- }
+ \tabular{ll}{
+ \emph{$FUN_CRIT } \tab [function] error criterion function (e.g. \code{\link{ErrorCrit_RMSE}}, \code{\link{ErrorCrit_NSE}}) \cr
+ \emph{$obs } \tab [numeric] series of observed variable (typically discharges [mm/time step]) \cr
+ \emph{$varObs } \tab [character] names of the observed variable (\code{"Qobs"} by default]) \cr
+ \emph{$BoolCrit } \tab [boolean] boolean giving the time steps considered in the computation \cr
+ \emph{$transfo } \tab [character] name of the transformation (e.g. \code{""}, \code{"sqrt"}, \code{"log"}, \code{"inv"}, \code{"sort"}) \cr
+ \emph{$epsilon } \tab [numeric] small value to add to all Qobs and Qsim (useful when \code{"log"} or \code{"inv"} transformations are used) [same unit as \code{obs}] \cr
+ \emph{$weights } \tab [numeric] vector of weights (the same length as x giving the weights to use for elements of \code{FUN_CRIT}) [-] \cr
+ }
+
+When \code{weights = NULL}, \code{CreateInputsCrit} returns an object of class \emph{Single} that is a list such as the one described above. \cr
+When \code{weights} contains at least one \code{NULL} value, \code{CreateInputsCrit} returns an object of class \emph{Multi} that is a list of lists such as the one we have just described above. The \code{\link{ErrorCrit}} function will then compute the different criteria prepared by \code{CreateInputsCrit}.
+When \code{weights} is a list of more than 2 numerical values, \code{CreateInputsCrit} returns an object of class \emph{Compo} that is a list of lists such as the one described above. This object will be useful to compute composite criterion with the \code{\link{ErrorCrit}} function. \cr
+The other \code{ErrorCrit_*} functions (e.g. \code{\link{ErrorCrit_RMSE}}, \code{\link{ErrorCrit_NSE}}) can only use objects of class \emph{Single} (and not \emph{Multi} or \emph{Compo}) \cr
}
\description{
-Creation of the \emph{InputsCrit} object required to the \code{ErrorCrit*} functions.
+Creation of the \code{InputsCrit} object required to the \code{ErrorCrit_*} functions. It can prepare a single object, a multiple object in order to compute many criteria or a complex object in order to compute a composite criterion.
}
\details{
-Users wanting to use \code{FUN_CRIT} functions that are not included in
-the package must create their own InputsCrit object accordingly. \cr
-The epsilon value is useful when \code{"log"} or \code{"inv"} transformations are used (to avoid division by zero). The effect of this value and recommendation about the epsilon value to use (usually one hundredth of average Qobs) are discussed in Pushpalatha et al. (2012) for NSE and Santos et al. (2018) for KGE and KGE'. \cr
-We do not advise computing KGE or KGE' with log-transformation as it might be wrongly influenced by discharge values close to 0 or 1 and it is dependent on the discharge unit. See Santos et al. (2018) for more details and alternative solutions (see the reference below).
+Users wanting to use \code{FUN_CRIT} functions that are not included in the package must create their own InputsCrit object accordingly. \cr
+Users can set the following arguments as atomic or list: \code{FUN_CRIT}, \code{obs}, \code{varObs}, \code{BoolCrit}, \code{transfo}, \code{weights}. If the list format is chosen, all the lists must have the same length. \cr
+The epsilon value is useful when \code{"log"} or \code{"inv"} transformations are used (to avoid division by zero). The effect of this value and recommendation about the epsilon value to use (usually one hundredth of average Qobs) are discussed in Pushpalatha et al. (2012) for NSE and in Santos et al. (2018) for KGE and KGE'. \cr
+We do not advise computing KGE or KGE' with log-transformation as it might be wrongly influenced by discharge values close to 0 or 1 and it is dependent on the discharge unit. See Santos et al. (2018) for more details and alternative solutions (see the reference list below). \cr
+When weighted values are given, \code{\link{ErrorCrit}} will calculate a composite criterion, i.e. a weighted average of criteria using normalized weights values. \cr
+\code{\link{ErrorCrit_RMSE}} cannot be used in a composite criterion since it is not a unitless value.
}
@@ -65,52 +86,54 @@ library(airGR)
## loading catchment data
data(L0123001)
-## preparation of the InputsModel object
+
InputsModel <- CreateInputsModel(FUN_MOD = RunModel_GR4J, DatesR = BasinObs$DatesR,
Precip = BasinObs$P, PotEvap = BasinObs$E)
-## run period selection
+## calibration period selection
Ind_Run <- seq(which(format(BasinObs$DatesR, format = "\%d/\%m/\%Y")=="01/01/1990"),
which(format(BasinObs$DatesR, format = "\%d/\%m/\%Y")=="31/12/1999"))
-## preparation of the RunOptions object
-RunOptions <- CreateRunOptions(FUN_MOD = RunModel_GR4J,
- InputsModel = InputsModel, IndPeriod_Run = Ind_Run)
+## preparation of RunOptions object
+RunOptions <- CreateRunOptions(FUN_MOD = RunModel_GR4J, InputsModel = InputsModel,
+ IndPeriod_Run = Ind_Run)
## simulation
-Param <- c(734.568, -0.840, 109.809, 1.971)
-OutputsModel <- RunModel(InputsModel = InputsModel, RunOptions = RunOptions,
- Param = Param, FUN = RunModel_GR4J)
-
-## efficiency criterion: Nash-Sutcliffe Efficiency
-InputsCrit <- CreateInputsCrit(FUN_CRIT = ErrorCrit_NSE, InputsModel = InputsModel,
- RunOptions = RunOptions, Qobs = BasinObs$Qmm[Ind_Run])
-OutputsCrit <- ErrorCrit_NSE(InputsCrit = InputsCrit, OutputsModel = OutputsModel)
-
-## efficiency criterion: Nash-Sutcliffe Efficiency on log-transformed flows
-transfo <- "log"
-InputsCrit <- CreateInputsCrit(FUN_CRIT = ErrorCrit_NSE, InputsModel = InputsModel,
- RunOptions = RunOptions, Qobs = BasinObs$Qmm[Ind_Run],
- transfo = transfo)
-OutputsCrit <- ErrorCrit_NSE(InputsCrit = InputsCrit, OutputsModel = OutputsModel)
-
-## efficiency criterion: Nash-Sutcliffe Efficiency above a threshold (q75\%)
-BoolCrit <- rep(TRUE, length(BasinObs$Qmm[Ind_Run]));
-BoolCrit[BasinObs$Qmm[Ind_Run]<quantile(BasinObs$Qmm[Ind_Run], 0.75, na.rm = TRUE)] <- FALSE
-InputsCrit <- CreateInputsCrit(FUN_CRIT = ErrorCrit_NSE, InputsModel = InputsModel,
- RunOptions = RunOptions, Qobs = BasinObs$Qmm[Ind_Run],
- BoolCrit = BoolCrit)
-OutputsCrit <- ErrorCrit_NSE(InputsCrit = InputsCrit, OutputsModel = OutputsModel)
-
-## efficiency criterion: Kling-Gupta Efficiency
-InputsCrit <- CreateInputsCrit(FUN_CRIT = ErrorCrit_KGE, InputsModel = InputsModel,
- RunOptions = RunOptions, Qobs = BasinObs$Qmm[Ind_Run])
-OutputsCrit <- ErrorCrit_KGE(InputsCrit = InputsCrit, OutputsModel = OutputsModel)
+Param <- c(257.238, 1.012, 88.235, 2.208)
+OutputsModel <- RunModel_GR4J(InputsModel = InputsModel, RunOptions = RunOptions, Param = Param)
+
+## single efficiency criterion: Nash-Sutcliffe Efficiency
+InputsCritSingle <- CreateInputsCrit(FUN_CRIT = ErrorCrit_NSE,
+ InputsModel = InputsModel, RunOptions = RunOptions,
+ obs = list(BasinObs$Qmm[Ind_Run]),
+ varObs = "Qobs", transfo = "",
+ weight = NULL)
+str(InputsCritSingle)
+invisible(ErrorCrit(InputsCrit = InputsCritSingle, OutputsModel = OutputsModel))
+
+## 2 efficiency critera: RMSE and the Nash-Sutcliffe Efficiency
+InputsCritMulti <- CreateInputsCrit(FUN_CRIT = list(ErrorCrit_RMSE, ErrorCrit_NSE),
+ InputsModel = InputsModel, RunOptions = RunOptions,
+ obs = list(BasinObs$Qmm[Ind_Run], BasinObs$Qmm[Ind_Run]),
+ varObs = list("Qobs", "Qobs"), transfo = list("", "sqrt"),
+ weight = NULL)
+str(InputsCritMulti)
+invisible(ErrorCrit(InputsCrit = InputsCritMulti, OutputsModel = OutputsModel))
+
+## efficiency composite criterion: Nash-Sutcliffe Efficiency mixing
+## both raw and log-transformed flows
+InputsCritCompo <- CreateInputsCrit(FUN_CRIT = list(ErrorCrit_NSE, ErrorCrit_NSE),
+ InputsModel = InputsModel, RunOptions = RunOptions,
+ obs = list(BasinObs$Qmm[Ind_Run], BasinObs$Qmm[Ind_Run]),
+ varObs = list("Qobs", "Qobs"), transfo = list("", "log"),
+ weight = list(0.4, 0.6))
+str(InputsCritCompo)
+invisible(ErrorCrit(InputsCrit = InputsCritCompo, OutputsModel = OutputsModel))
}
\author{
-Laurent Coron, Olivier Delaigue, Guillaume Thirel
+Olivier Delaigue, Laurent Coron, Guillaume Thirel
}
\references{
@@ -124,6 +147,6 @@ Santos, L., Thirel, G. and Perrin, C. (2018),
\seealso{
-\code{\link{RunModel}}, \code{\link{CreateInputsModel}}, \code{\link{CreateRunOptions}}, \code{\link{CreateCalibOptions}}
+\code{\link{RunModel}}, \code{\link{CreateInputsModel}}, \code{\link{CreateRunOptions}}, \code{\link{CreateCalibOptions}}, \code{\link{ErrorCrit}}
}