Introduction

Scope

The airGR package implements semi-distributed model capabilities using a lag model between subcatchments. It allows to chain together several lumped models as well as integrating anthropogenic influence such as reservoirs or withdrawals.

RunModel_Lag documentation gives an example of simulating the influence of a reservoir in a lumped model. Try example(RunModel_Lag) to get it.

In this vignette, we show how to calibrate 2 sub-catchments in series with a semi-distributed model consisting of 2 GR4J models. For doing this we compare two strategies for calibrating the downstream subcatchment:

• using upstream observed flows
• using upstream simulated flows

We finally compare these calibrations with a theoretical set of parameters.

Model description

We use an example data set from the package that unfortunately contains data for only one catchment.

## loading catchment data
data(L0123001)

Let's imagine that this catchment of 360 km² is divided into 2 subcatchments:

• An upstream subcatchment of 180 km²
• 100 km downstream another subcatchment of 180 km²

We consider that meteorological data are homogeneous on the whole catchment, so we use the same pluviometry BasinObs$P and the same evapotranspiration BasinObs$E for the 2 subcatchments.

For the observed flow at the downstream outlet, we generate it with the assumption that the upstream flow arrives at downstream with a constant delay of 2 days.

QObsDown <- (BasinObs$Qmm + c(0, 0, BasinObs$Qmm[1:(length(BasinObs$Qmm)-2)])) / 2
summary(cbind(QObsUp = BasinObs$Qmm, QObsDown))

##      QObsUp       QObsDown  
##  Min.   : 0    Min.   : 0   
##  1st Qu.: 0    1st Qu.: 0   
##  Median : 1    Median : 1   
##  Mean   : 1    Mean   : 1   
##  3rd Qu.: 2    3rd Qu.: 2   
##  Max.   :24    Max.   :20   
##  NA's   :802   NA's   :820

Calibration of the upstream subcatchment

The operations are exactly the same as the ones for a GR4J lumped model. So we do exactly the same operations as in the Get Started vignette.

InputsModelUp <- CreateInputsModel(FUN_MOD = RunModel_GR4J, DatesR = BasinObs$DatesR,
                                   Precip = BasinObs$P, PotEvap = BasinObs$E)
Ind_Run <- seq(which(format(BasinObs$DatesR, format = "%Y-%m-%d") == "1990-01-01"),
               which(format(BasinObs$DatesR, format = "%Y-%m-%d") == "1999-12-31"))
RunOptionsUp <- CreateRunOptions(FUN_MOD = RunModel_GR4J,
                                 InputsModel = InputsModelUp
                                 , IndPeriod_WarmUp = NULL, IndPeriod_Run = Ind_Run,
                                 IniStates = NULL, IniResLevels = NULL)

## Warning in CreateRunOptions(FUN_MOD = RunModel_GR4J, InputsModel = InputsModelUp, : model warm up period not defined: default configuration used
##   the year preceding the run period is used

InputsCritUp <- CreateInputsCrit(FUN_CRIT = ErrorCrit_NSE, InputsModel = InputsModelUp,
                                 RunOptions = RunOptionsUp,
                                 VarObs = "Q", Obs = BasinObs$Qmm[Ind_Run])
CalibOptionsUp <- CreateCalibOptions(FUN_MOD = RunModel_GR4J, FUN_CALIB = Calibration_Michel)
OutputsCalibUp <- Calibration_Michel(InputsModel = InputsModelUp, RunOptions = RunOptionsUp,
                                     InputsCrit = InputsCritUp, CalibOptions = CalibOptionsUp,
                                     FUN_MOD = RunModel_GR4J)

## Grid-Screening in progress (0% 20% 40% 60% 80% 100%)
##   Screening completed (81 runs)
##       Param =  247.151,   -0.020,   83.096,    2.384
##       Crit. NSE[Q]       = 0.7688
## Steepest-descent local search in progress
##   Calibration completed (21 iterations, 234 runs)
##       Param =  257.238,    1.012,   88.235,    2.208
##       Crit. NSE[Q]       = 0.7988

And see the result of the simulation:

OutputsModelUp <- RunModel_GR4J(InputsModel = InputsModelUp, RunOptions = RunOptionsUp,
                                Param = OutputsCalibUp$ParamFinalR)

Calibration of the downstream subcatchment with upstream flow observations

Observed flow data contain NA values and a complete time series is mandatory for running the Lag model. We propose to complete the observed upstream flow with linear interpolation:

QObsUp <- imputeTS::na_interpolation(BasinObs$Qmm)

we need to create the InputsModel object completed with upstream information:

InputsModelDown1 <- CreateInputsModel(
  FUN_MOD = RunModel_GR4J, DatesR = BasinObs$DatesR,
  Precip = BasinObs$P, PotEvap = BasinObs$E,
  Qupstream = matrix(QObsUp, ncol = 1), # upstream observed flow
  LengthHydro = 1e2 * 1e3, # distance between upstream catchment outlet & the downstream one [m]
  BasinAreas = c(180, 180) # upstream and downstream areas [km²]
)

And then calibrate the combination of Lag model for upstream flow transfer and GR4J model for the runoff of the downstream subcatchment:

RunOptionsDown <- CreateRunOptions(FUN_MOD = RunModel_GR4J,
                                   InputsModel = InputsModelDown1,
                                   IndPeriod_WarmUp = NULL, IndPeriod_Run = Ind_Run,
                                   IniStates = NULL, IniResLevels = NULL)

## Warning in CreateRunOptions(FUN_MOD = RunModel_GR4J, InputsModel = InputsModelDown1, : model warm up period not defined: default configuration used
##   the year preceding the run period is used

InputsCritDown <- CreateInputsCrit(FUN_CRIT = ErrorCrit_NSE, InputsModel = InputsModelDown1,
                                   RunOptions = RunOptionsDown,
                                   VarObs = "Q", Obs = QObsDown[Ind_Run])
CalibOptionsDown <- CreateCalibOptions(FUN_MOD = RunModel_GR4J,
                                       FUN_CALIB = Calibration_Michel,
                                       IsSD = TRUE) # specify that it's a SD model
OutputsCalibDown1 <- Calibration_Michel(InputsModel = InputsModelDown1,
                                        RunOptions = RunOptionsDown,
                                        InputsCrit = InputsCritDown,
                                        CalibOptions = CalibOptionsDown,
                                        FUN_MOD = RunModel_GR4J)

## Grid-Screening in progress (0% 20% 40% 60% 80% 100%)
##   Screening completed (243 runs)
##       Param =   11.250,  247.151,   -0.020,   83.096,    2.384
##       Crit. NSE[Q]       = 0.8861
## Steepest-descent local search in progress
##   Calibration completed (45 iterations, 675 runs)
##       Param =    2.560,  265.072,    0.970,   83.931,    4.648
##       Crit. NSE[Q]       = 0.9489

To run the complete model, we should substitute the observed upstream flow by the simulated one:

InputsModelDown2 <- InputsModelDown1
InputsModelDown2$Qupstream[Ind_Run] <- OutputsModelUp$Qsim

RunModel is run in order to automatically combine GR4J and Lag models.

OutputsModelDown1 <- RunModel(InputsModel = InputsModelDown2,
                              RunOptions = RunOptionsDown,
                              Param = OutputsCalibDown1$ParamFinalR,
                              FUN_MOD = RunModel_GR4J)

Performance of the model validation is then:

CritDown1 <- ErrorCrit_NSE(InputsCritDown, OutputsModelDown1)

## Crit. NSE[Q] = 0.8170

Calibration of the downstream subcatchment with upstream simulated flow

We calibrate the model with the InputsModel object previously created for substituting the observed upstream flow with the simulated one:

OutputsCalibDown2 <- Calibration_Michel(InputsModel = InputsModelDown2,
                                        RunOptions = RunOptionsDown,
                                        InputsCrit = InputsCritDown,
                                        CalibOptions = CalibOptionsDown,
                                        FUN_MOD = RunModel_GR4J)

## Grid-Screening in progress (0% 20% 40% 60% 80% 100%)
##   Screening completed (243 runs)
##       Param =   11.250,  247.151,   -0.020,   83.096,    2.384
##       Crit. NSE[Q]       = 0.7468
## Steepest-descent local search in progress
##   Calibration completed (39 iterations, 616 runs)
##       Param =    1.970,  270.426,    0.822,   68.717,    5.214
##       Crit. NSE[Q]       = 0.8185

ParamDown2 <- OutputsCalibDown2$ParamFinalR

Discussion

Identification of Lag parameter

The theoretical Lag parameter should be equal to:

Lag <- InputsModelDown1$LengthHydro / (2 * 86400)
paste(format(Lag), "m/s")

## [1] "0.579 m/s"

Both calibrations overestimate this parameter:

mLag <- matrix(c(Lag,
                 OutputsCalibDown1$ParamFinalR[1],
                 OutputsCalibDown2$ParamFinalR[1]),
               ncol = 1,
               dimnames = list(c("theoretical",
                                 "calibrated with observed upstream flow",
                                 "calibrated with simulated  upstream flow"),
                               c("Lag parameter")))
knitr::kable(mLag)

Value of the performance criteria with theoretical calibration

Theoretically, the parameters of the downstream GR4J model should be the same as the upstream one and we know the lag time. So this set of parameter should give a better performance criteria:

ParamDownTheo <- c(Lag, OutputsCalibUp$ParamFinalR)
OutputsModelDownTheo <- RunModel(InputsModel = InputsModelDown2,
                              RunOptions = RunOptionsDown,
                              Param = ParamDownTheo,
                              FUN_MOD = RunModel_GR4J)
CritDownTheo <- ErrorCrit_NSE(InputsCritDown, OutputsModelDownTheo)

## Crit. NSE[Q] = 0.8159

Parameters and performance of each subcatchment for all calibrations

comp <- matrix(c(0, OutputsCalibUp$ParamFinalR,
                 rep(OutputsCalibDown1$ParamFinalR, 2),
                 OutputsCalibDown2$ParamFinalR,
                 ParamDownTheo),
               ncol = 5, byrow = TRUE)
comp <- cbind(comp, c(OutputsCalibUp$CritFinal,
                      OutputsCalibDown1$CritFinal,
                      CritDown1$CritValue,
                      OutputsCalibDown2$CritFinal,
                      CritDownTheo$CritValue))
colnames(comp) <- c("Lag", paste0("X", 1:4), "NSE")
rownames(comp) <- c("Calibration of the upstream subcatchment",
                    "Calibration 1 with observed upstream flow",
                    "Validation 1 with simulated upstream flow",
                    "Calibration 2 with simulated upstream flow",
                    "Validation theoretical set of parameters")
knitr::kable(comp)

Even if calibration with observed upstream flows gives an improved performance criteria, in validation using simulated upstream flows the result is quite similar as the performance obtained with the calibration with upstream simulated flows. The theoretical set of parameters give also an equivalent performance but still underperforming the calibration 2 one.