class: center, middle, inverse, title-slide .title[ # Découverte de
airGRiwrm
sur la Sèvre-Nantaise ] .subtitle[ ## Gestion intégrée de la ressource en eau avec
airGR
] .author[ ### David Dorchies ] .institute[ ### UMR G-EAU ] .date[ ### Montpellier / Clisson, le 6 juillet 2023 (MAJ 30/07/2024) ] --- # Programme de la formation - Introduction au modèle semi-distribué (5 mn) - Présentation du package **airGRiwrm** (10 mn) - Installation du package **airGRiwrm** (5 mn) - Présentation du jeu de données de la formation (15 mn) - Créer un réseau semi-distribué avec **airGRiwrm** (15 mn) - Calage d'un réseau semi-distribué de modèles hydrologiques (60 mn) - Modélisation du barrage de la Bultière (30 mn) - Régulation du barrage de la Bultière (30 mn) --- class: inverse, middle, center # Le modèle semi-distribué --- # Un modèle semi-distribué : c'est quoi ? .pull-left[ - Découpage du bassin versant en sous-bassins en fonction de la position des stations hydrométriques exutoires de chaque sous-bassin - Le ruissellement de chaque sous-bassin est modélisé par un modèle global (GR...) - Le modèle semi-distribué relie les stations hydrométrique grâce à un routage hydraulique de type "lag" <img src="img/scheme_bvi.png" width="50%" style="display: block; margin: auto;" /> ] .pull-right[ .vertical-center[ ![:scale 90%](img/scheme_GRSD.png) ]] --- # Intérêt du modèle hydrologique semi-distribué .left-column[ Au delà de la simulation de débits ayant une cohérence amont-aval dans le modèle, la semi-distribution et le routage hydraulique permettent l'introduction d'influences humaines : - Prélèvements de débit - Réservoirs - Transferts inter-bassins *Exemple ci-contre avec le bassin versant de l'Aude où sont modélisés 7 réservoirs, des transferts inter-bassins et des canaux de navigation.* ] .right-column[ .center[ ![:scale 62%](img/plot_griwrm_aude.png) ] ] --- class: inverse, middle, center ![:scale 30%](img/logo_airGRiwrm.png) # *airGRiwrm*: extension de *airGR* pour un réseau de modèles semi-distribués --- # Introduction au package **airGRiwrm** .pull-left[ **airGRiwrm** complète la galaxie **airGR** en automatisant la semi-distribution et en ajoutant des fonctionnalités pour simuler les influences humaines. Principalement utilisé pour les études d'impact et d'adaptation aux changements globaux de bassins versants anthropisés. - Le package airGRiwrm est en développement depuis mai 2020 - Diffusé sur [le dépôt officiel "CRAN" en août 2022 *(v0.6.1)*](https://cloud.r-project.org/package=airGRiwrm) - Logiciel gratuit et open-source (Github : https://github.com/inrae/airGRiwrm) .center[ ![:scale 75%](img/website_thumbnail.jpg) ] ] .pull-right[ .center[ ![:scale 70%](img/airgr_galaxy.png) ] Documentation avec des exemples d'utilisation: - https://airgriwrm.g-eau.fr/ *(v0.6.1)* - https://airgriwrm.g-eau.fr/dev *(v0.6.1.9000 en développement)* ] --- class: hide_logo # *airGRiwrm*: extension de *airGR* pour un réseau de modèles semi-distribués **airGRiwrm** redéfinit les fonctions de **airGR** pour automatiser la gestion d'un réseau semi-distribué: ``` r library(airGRiwrm) ``` Les fonctions originales de **airGR** restent accessibles (Redirection avec [les classes S3](http://www.duclert.org/r-divers/classes-S3-R.php)). --- # Procédure de calage d'un réseau avec *airGRiwrm* Par rapport à *airGR*, on ajoute une étape préalable de description du réseau :
--- # Les fonctionnalités de *airGRiwrm* ## Version officielle diffusée sur le CRAN *(v0.6.1)* - Automatisation des fonctionnalités de *airGR* pour un réseau semi-distribué via la description d'un réseau de "noeuds": - Modèles GR (pas de temps journalier et horaire) et transfert hydraulique (Lag) - Calage et run des simulations - Régularisation des paramètres (Méthode de De Lavenne) - Noeuds "DirectInjection" pour introduire des influences humaines dans le réseau via des chroniques prédéfinies de débits prélevés ou lâchés ## Version en développement *(v0.6.1.9000)* - Ajout de noeuds de type "Ungauged" pour simuler les débits du cours d'eau sur des points non jaugés - Ajout de noeuds de type "Reservoir" pour simuler l'évolution du volume d'un réservoir - Ajout de noeuds de type "Diversion" pour transférer des débits entre les noeuds du réseau --- class: inverse, middle, center # Installation du package *airGRiwrm* ![](img/logo_airGRiwrm.png) --- # Installation du package *airGRiwrm* ### La version diffusée sur le CRAN ``` r install.packages("airGRiwrm") ``` ### La version en cours de développement Installation de **airGRiwrm** branche "dev" : ``` r install.packages("remotes") remotes::install_github("inrae/airGRiwrm", "dev") ``` --- class: inverse, middle, center # Le jeu de données de la formation: le cas d'étude "Maine" --- # Présentation du cas d'étude "Maine"
--- # Cas d'étude: chargement des données ## Exercice - Créer un R Notebook sous RStudio - Enregistrer le dossier `data` et le R Notebook dans le même dossier - Définir le working directory (Menu Session > Set working directory > To source file location) - Créer un premier chunk pour - effacer l'environnement de travail - charger les données du fichier `data/Maine_SevreNantaise.RData` - afficher la liste des variables présentes dans l'environnement de travail -- ``` r rm(list = ls()) load("data/Maine_SevreNantaise.RData") ls() #> [1] "BasinObs" "connections_reservoir_use" #> [3] "DatesR" "Q_water_use" #> [5] "reseau_maine" ``` --- # Cas d'étude: chargement des données ## Description des données fournies ``` #> [1] "BasinObs" "connections_reservoir_use" #> [3] "DatesR" "Q_water_use" #> [5] "reseau_maine" ``` - `BasinObs` (*list*): Données hydroclimatiques de chaque bassin - `connections_reservoir_use` (*data.frame*): Description du réseau des influences - `DatesR` (*POSIXct*): Dates des pas de temps d'observation - `Q_water_use` (*matrix*): Débits observés à la prise et à la restitution des réservoirs - `reseau_maine` (*data.frame*): Description du réseau de stations hydrométriques --- # Cas d'étude: description du réseau de stations hydrométriques Exercice: *Afficher le tableau décrivant le réseau de stations* -- ``` r reseau_maine ``` |id | area|nom |id_aval | distance_aval| |:---------------------|------:|:-------------------------------------------|:---------------|-------------:| |Maine_Remouille | 594.58|La Maine a Remouille |NA | NA| |GrandeMaine_StFulgent | 132.17|La Grande Maine a Saint-Fulgent |Maine_Remouille | 33.41| |PetiteMaine_StGeorges | 191.82|La Petite Maine a Saint-Georges-de-Montaigu |Maine_Remouille | 23.07| --- # Cas d'étude: description des observations hydroclimatiques Exercice: *Afficher des informations concernant les dates de chroniques (début/fin) et la structure des données d'observation* -- ``` r head(DatesR, 3) #> [1] "2008-01-01 UTC" "2008-01-02 UTC" "2008-01-03 UTC" ``` ``` r tail(DatesR, 3) #> [1] "2020-12-29 UTC" "2020-12-30 UTC" "2020-12-31 UTC" ``` ``` r str(BasinObs) #> List of 3 #> $ Maine_Remouille :'data.frame': 4749 obs. of 3 variables: #> ..$ P: num [1:4749] 0 0.121 4.842 11.442 9.305 ... #> ..$ E: num [1:4749] 0.4 0.3 0.3 0.2 0.3 ... #> ..$ Q: num [1:4749] 0.278 0.17 0.189 0.219 0.722 ... #> $ GrandeMaine_StFulgent:'data.frame': 4749 obs. of 3 variables: #> ..$ P: num [1:4749] 0 0.2 4.7 12.2 9.4 17.7 0.5 1.9 2 4 ... #> ..$ E: num [1:4749] 0.4 0.3 0.3 0.2 0.3 0.3 0.5 0.3 0.3 0.2 ... #> ..$ Q: num [1:4749] 0.244 0.243 0.268 0.307 1.405 ... #> $ PetiteMaine_StGeorges:'data.frame': 4749 obs. of 3 variables: #> ..$ P: num [1:4749] 0 0.2 5 11.6 9.7 16.7 0.4 2 2.1 4.4 ... #> ..$ E: num [1:4749] 0.4 0.3 0.3 0.2 0.3 0.3 0.4 0.3 0.3 0.2 ... #> ..$ Q: num [1:4749] 0.146 0.149 0.159 0.21 1.221 ... ``` --- # Cas d'étude: description des influences ## Exercice *Afficher le tableau de description du réseau des influences* -- ```r connections_reservoir_use ``` |id |id_aval | distance_aval| lambert2.x| lambert2.y| |:-------------|:---------------------|-------------:|----------:|----------:| |P_BULTIERE |Maine_Remouille | 28.035979| 329665.5| 2219226| |R_BULTIERE |Maine_Remouille | 28.035979| 329665.5| 2219226| |P_MAINE |Maine_Remouille | 19.115837| 324618.9| 2223265| |R_MAINE |Maine_Remouille | 21.844591| 327528.5| 2221721| |P_GRANDEMAINE |GrandeMaine_StFulgent | 9.025684| 339235.6| 2215470| |R_GRANDEMAINE |GrandeMaine_StFulgent | 10.418234| 339746.9| 2214639| |P_PETITEMAINE |PetiteMaine_StGeorges | 15.472812| 327524.9| 2211222| |R_PETITEMAINE |PetiteMaine_StGeorges | 15.472703| 328396.7| 2211426| --- # Cas d'étude: description des influences ## Exercice *Afficher les données des influences de débit (`str`, `summary`, `plot`)* (Attention aux unités) -- ``` r str(Q_water_use) #> num [1:4749, 1:8] -0.438 -0.438 -0.829 -2.223 -4.083 ... #> - attr(*, "dimnames")=List of 2 #> ..$ : chr [1:4749] "732" "733" "734" "735" ... #> ..$ : chr [1:8] "P_BULTIERE" "R_BULTIERE" "P_MAINE" "R_MAINE" ... ``` ``` r summary(Q_water_use, echo=Sys.getenv("FORMATION_HIDE_SOLUTIONS")=="") #> P_BULTIERE R_BULTIERE P_MAINE R_MAINE #> Min. :-23.87281 Min. : 0.01599 Min. :-1.098290 Min. :0.02074 #> 1st Qu.: -1.40618 1st Qu.: 0.15800 1st Qu.:-0.139724 1st Qu.:0.06151 #> Median : -0.35891 Median : 0.16000 Median :-0.057601 Median :0.07197 #> Mean : -1.24848 Mean : 0.99701 Mean :-0.092263 Mean :0.07599 #> 3rd Qu.: -0.06629 3rd Qu.: 0.95764 3rd Qu.:-0.030761 3rd Qu.:0.08801 #> Max. : 0.00000 Max. :25.00000 Max. :-0.009128 Max. :0.26807 #> P_GRANDEMAINE R_GRANDEMAINE P_PETITEMAINE R_PETITEMAINE #> Min. :-0.386404 Min. :0.01875 Min. :-0.92594 Min. :0.01175 #> 1st Qu.:-0.037282 1st Qu.:0.03265 1st Qu.:-0.06940 1st Qu.:0.02482 #> Median :-0.020975 Median :0.03892 Median :-0.03683 Median :0.02967 #> Mean :-0.029479 Mean :0.04408 Mean :-0.05502 Mean :0.03367 #> 3rd Qu.:-0.012459 3rd Qu.:0.05043 3rd Qu.:-0.02440 3rd Qu.:0.03916 #> Max. :-0.006554 Max. :0.15985 Max. :-0.01015 Max. :0.14649 ``` --- # Cas d'étude: description des influences ## Exercice *Afficher les données des influences de débit (`str`, `summary`, `plot`)* -- ``` r matplot(DatesR, Q_water_use[, c("P_BULTIERE", "R_BULTIERE")], type = "l") ``` <img src="index_files/figure-html/plot-bultiere-1.png" width="65%" style="display: block; margin: auto;" /> --- class: inverse, middle, center # Créer un réseau de modèles semi-distribués avec *airGRiwrm* --- # Créer un réseau de modèles semi-distribués avec *airGRiwrm* Le réseau est décrit par un objet `GRiwrm` qu'il faut créer : ```r ?CreateGRiwrm ``` ## Exercice *Quelles colonnes manquent à nos tableaux ?* -- Il faut définir quel modèle on souhaite utiliser pour chaque nœud du réseau : - Un modèle hydrologique pour les nœuds correspondants à une station hydrométrique; - ... autre chose pour les nœuds utilisés pour les influences humaines observées. -- ``` r reseau_maine$model <- "RunModel_GR4J" connections_reservoir_use$model <- NA ``` --- # Créer un réseau de modèles semi-distribués avec *airGRiwrm* ## Exercice *Fusionner les deux descriptions de réseau (les colonnes doivent être identiques)* -- ``` r names(reseau_maine) #> [1] "id" "lambert2.x" "lambert2.y" "area" #> [5] "nom" "id_aval" "distance_aval" "model" ``` ``` r names(connections_reservoir_use) #> [1] "id" "id_aval" "distance_aval" "lambert2.x" #> [5] "lambert2.y" "model" ``` ``` r setdiff(names(reseau_maine), names(connections_reservoir_use)) #> [1] "area" "nom" ``` Il faut ajouter les colonnes manquantes avec les bonnes valeurs et/ou supprimer les colonnes superflues. -- ``` r connections_reservoir_use$area <- NA connections_reservoir_use$nom <- connections_reservoir_use$id ``` --- # Créer un réseau de modèles semi-distribués avec *airGRiwrm* ## Exercice *Fusionner les deux descriptions de réseau* (`rbind`) -- ``` r reseau_inf <- rbind(reseau_maine, connections_reservoir_use) ``` |id | lambert2.x| lambert2.y| area|nom |id_aval | distance_aval|model | |:---------------------|----------:|----------:|------:|:-------------------------------------------|:---------------------|-------------:|:-------------| |Maine_Remouille | 318515.0| 2235050| 594.58|La Maine a Remouille |NA | NA|RunModel_GR4J | |GrandeMaine_StFulgent | 333911.0| 2217450| 132.17|La Grande Maine a Saint-Fulgent |Maine_Remouille | 33.410000|RunModel_GR4J | |PetiteMaine_StGeorges | 325104.0| 2219950| 191.82|La Petite Maine a Saint-Georges-de-Montaigu |Maine_Remouille | 23.070000|RunModel_GR4J | |P_BULTIERE | 329665.5| 2219226| NA|P_BULTIERE |Maine_Remouille | 28.035979|NA | |R_BULTIERE | 329665.5| 2219226| NA|R_BULTIERE |Maine_Remouille | 28.035979|NA | |P_MAINE | 324618.9| 2223265| NA|P_MAINE |Maine_Remouille | 19.115837|NA | |R_MAINE | 327528.5| 2221721| NA|R_MAINE |Maine_Remouille | 21.844591|NA | |P_GRANDEMAINE | 339235.6| 2215470| NA|P_GRANDEMAINE |GrandeMaine_StFulgent | 9.025684|NA | |R_GRANDEMAINE | 339746.9| 2214639| NA|R_GRANDEMAINE |GrandeMaine_StFulgent | 10.418234|NA | |P_PETITEMAINE | 327524.9| 2211222| NA|P_PETITEMAINE |PetiteMaine_StGeorges | 15.472812|NA | |R_PETITEMAINE | 328396.7| 2211426| NA|R_PETITEMAINE |PetiteMaine_StGeorges | 15.472703|NA | --- # Création de l'objet `GRiwrm` On peut faire correspondre les noms de colonne avec le paramètre `cols` : ## Exercice *Créer l'objet GRiwrm à partir du réseau fusionné* -- ``` r griwrm <- CreateGRiwrm( reseau_inf, cols = list(down = "id_aval", length = "distance_aval")) str(griwrm) #> GRiwrm [11 × 6] (S3: GRiwrm/tbl_df/tbl/data.frame) #> $ id : chr [1:11] "GrandeMaine_StFulgent" "PetiteMaine_StGeorges" "Maine_Remouille" "P_BULTIERE" ... #> $ down : chr [1:11] "Maine_Remouille" "Maine_Remouille" NA "Maine_Remouille" ... #> $ length: num [1:11] 33.4 23.1 NA 28 28 ... #> $ area : num [1:11] 132 192 595 NA NA ... #> $ model : chr [1:11] "RunModel_GR4J" "RunModel_GR4J" "RunModel_GR4J" NA ... #> $ donor : chr [1:11] "GrandeMaine_StFulgent" "PetiteMaine_StGeorges" "Maine_Remouille" "P_BULTIERE" ... ``` --- # Créer un réseau de modèles semi-distribués avec **airGRiwrm** La fonction `plot.GRiwrm` permet de tracer une représentation schématique du réseau. ```r ?plot.GRiwrm ``` Exercice: *afficher le schéma du réseau en mode "top-bottom"* -- ``` r plot(griwrm, orientation = "BT") ``` <img src="index_files/figure-html/plot.GRiwrm-1.png" width="100%" style="display: block; margin: auto;" /> --- class: inverse, middle, center # Calage d'un réseau de modèles hydrologiques semi-distribués avec *airGRiwrm* --- # `CreateInputsModel` dans *airGRiwrm* ```r ?CreateInputsModel.GRiwrm ``` -- ## Exercice *Créer des matrices pour les "inputs" avec le code de la station en nom de colonne* -- ``` r P <- cbind(BasinObs[[1]]$P, BasinObs[[2]]$P, BasinObs[[3]]$P) str(P) #> num [1:4749, 1:3] 0 0.121 4.842 11.442 9.305 ... ``` ``` r colnames(P) <- names(BasinObs) str(P) #> num [1:4749, 1:3] 0 0.121 4.842 11.442 9.305 ... #> - attr(*, "dimnames")=List of 2 #> ..$ : NULL #> ..$ : chr [1:3] "Maine_Remouille" "GrandeMaine_StFulgent" "PetiteMaine_StGeorges" ``` Heureusement qu'il n'y a que 3 colonnes ! Mais ne peut-on pas mieux faire ? --- # `CreateInputsModel` dans *airGRiwrm* ## Exercice *Créer des matrices pour les "inputs" avec le code de la station en nom de colonne (master class)* -- ``` r l <- lapply(BasinObs, function(x) {x$P}) str(l) #> List of 3 #> $ Maine_Remouille : num [1:4749] 0 0.121 4.842 11.442 9.305 ... #> $ GrandeMaine_StFulgent: num [1:4749] 0 0.2 4.7 12.2 9.4 17.7 0.5 1.9 2 4 ... #> $ PetiteMaine_StGeorges: num [1:4749] 0 0.2 5 11.6 9.7 16.7 0.4 2 2.1 4.4 ... ``` ``` r P <- do.call(cbind, l) str(P) #> num [1:4749, 1:3] 0 0.121 4.842 11.442 9.305 ... #> - attr(*, "dimnames")=List of 2 #> ..$ : NULL #> ..$ : chr [1:3] "Maine_Remouille" "GrandeMaine_StFulgent" "PetiteMaine_StGeorges" ``` -- En une seule ligne, avec la fonction `"[["` et un argument : ``` r E <- do.call(cbind, lapply(BasinObs, "[[", "E")) ``` --- # `CreateInputsModel` dans *airGRiwrm* ## Exercice *Créer l'objet `InputsModel` avec le réseau, les dates, les entrées climatiques et les influences observées (Attention aux unités des prélèvements/rejets)* -- ``` r IM <- CreateInputsModel( griwrm, DatesR = DatesR, Precip = P, PotEvap = E, Qobs = Q_water_use * 86400 # m3/s -> m3/j ) #> Warning in CreateInputsModel.GRiwrm(griwrm, DatesR = DatesR, Precip = P, : The #> usage of 'Qobs' is deprecated, use 'Qinf' instead #> CreateInputsModel.GRiwrm: Processing sub-basin GrandeMaine_StFulgent... #> CreateInputsModel.GRiwrm: Processing sub-basin PetiteMaine_StGeorges... #> CreateInputsModel.GRiwrm: Processing sub-basin Maine_Remouille... ``` --- # L'objet `GRiwrmInputsModel` L'objet `GRiwrmInputsModel` est une liste d'`InputsModel` : 1 élément de liste = 1 modèle *GR ( + Lag )* ``` r str(IM) #> List of 3 #> $ GrandeMaine_StFulgent:List of 19 #> ..$ DatesR : POSIXlt[1:4749], format: "2008-01-01" "2008-01-02" ... #> ..$ Precip : num [1:4749] 0 0.2 4.7 12.2 9.4 17.7 0.5 1.9 2 4 ... #> ..$ PotEvap : num [1:4749] 0.4 0.3 0.3 0.2 0.3 0.3 0.5 0.3 0.3 0.2 ... #> ..$ Qupstream : num [1:4749, 1:2] -943 -1009 -1009 -989 -947 ... #> .. ..- attr(*, "dimnames")=List of 2 #> .. .. ..$ : NULL #> .. .. ..$ : chr [1:2] "P_GRANDEMAINE" "R_GRANDEMAINE" #> ..$ LengthHydro : Named num [1:2] 9.03 10.42 #> .. ..- attr(*, "names")= chr [1:2] "P_GRANDEMAINE" "R_GRANDEMAINE" #> ..$ BasinAreas : Named num [1:3] NA NA 132 #> .. ..- attr(*, "names")= chr [1:3] "P_GRANDEMAINE" "R_GRANDEMAINE" "GrandeMaine_StFulgent" #> ..$ id : chr "GrandeMaine_StFulgent" #> ..$ down : chr "Maine_Remouille" #> ..$ UpstreamNodes : chr [1:2] "P_GRANDEMAINE" "R_GRANDEMAINE" #> ..$ UpstreamIsModeled: Named logi [1:2] FALSE FALSE #> .. ..- attr(*, "names")= chr [1:2] "P_GRANDEMAINE" "R_GRANDEMAINE" #> ..$ UpstreamVarQ : Named chr [1:2] "Qsim_m3" "Qsim_m3" #> .. ..- attr(*, "names")= chr [1:2] "P_GRANDEMAINE" "R_GRANDEMAINE" #> ..$ FUN_MOD : chr "RunModel_GR4J" #> ..$ inUngaugedCluster: logi FALSE #> ..$ isReceiver : logi FALSE #> ..$ gaugedId : chr "GrandeMaine_StFulgent" #> ..$ hasUngaugedNodes : logi FALSE #> ..$ model :List of 4 #> .. ..$ indexParamUngauged: num [1:5] 1 2 3 4 5 #> .. ..$ hasX4 : logi TRUE #> .. ..$ iX4 : num 5 #> .. ..$ IsHyst : logi FALSE #> ..$ hasDiversion : logi FALSE #> ..$ isReservoir : logi FALSE #> ..- attr(*, "class")= chr [1:5] "RunModel_GR4J" "InputsModel" "daily" "GR" ... #> $ PetiteMaine_StGeorges:List of 19 #> ..$ DatesR : POSIXlt[1:4749], format: "2008-01-01" "2008-01-02" ... #> ..$ Precip : num [1:4749] 0 0.2 5 11.6 9.7 16.7 0.4 2 2.1 4.4 ... #> ..$ PotEvap : num [1:4749] 0.4 0.3 0.3 0.2 0.3 0.3 0.4 0.3 0.3 0.2 ... #> ..$ Qupstream : num [1:4749, 1:2] -1771 -1891 -1891 -1859 -1424 ... #> .. ..- attr(*, "dimnames")=List of 2 #> .. .. ..$ : NULL #> .. .. ..$ : chr [1:2] "P_PETITEMAINE" "R_PETITEMAINE" #> ..$ LengthHydro : Named num [1:2] 15.5 15.5 #> .. ..- attr(*, "names")= chr [1:2] "P_PETITEMAINE" "R_PETITEMAINE" #> ..$ BasinAreas : Named num [1:3] NA NA 192 #> .. ..- attr(*, "names")= chr [1:3] "P_PETITEMAINE" "R_PETITEMAINE" "PetiteMaine_StGeorges" #> ..$ id : chr "PetiteMaine_StGeorges" #> ..$ down : chr "Maine_Remouille" #> ..$ UpstreamNodes : chr [1:2] "P_PETITEMAINE" "R_PETITEMAINE" #> ..$ UpstreamIsModeled: Named logi [1:2] FALSE FALSE #> .. ..- attr(*, "names")= chr [1:2] "P_PETITEMAINE" "R_PETITEMAINE" #> ..$ UpstreamVarQ : Named chr [1:2] "Qsim_m3" "Qsim_m3" #> .. ..- attr(*, "names")= chr [1:2] "P_PETITEMAINE" "R_PETITEMAINE" #> ..$ FUN_MOD : chr "RunModel_GR4J" #> ..$ inUngaugedCluster: logi FALSE #> ..$ isReceiver : logi FALSE #> ..$ gaugedId : chr "PetiteMaine_StGeorges" #> ..$ hasUngaugedNodes : logi FALSE #> ..$ model :List of 4 #> .. ..$ indexParamUngauged: num [1:5] 1 2 3 4 5 #> .. ..$ hasX4 : logi TRUE #> .. ..$ iX4 : num 5 #> .. ..$ IsHyst : logi FALSE #> ..$ hasDiversion : logi FALSE #> ..$ isReservoir : logi FALSE #> ..- attr(*, "class")= chr [1:5] "RunModel_GR4J" "InputsModel" "daily" "GR" ... #> $ Maine_Remouille :List of 19 #> ..$ DatesR : POSIXlt[1:4749], format: "2008-01-01" "2008-01-02" ... #> ..$ Precip : num [1:4749] 0 0.121 4.842 11.442 9.305 ... #> ..$ PotEvap : num [1:4749] 0.4 0.3 0.3 0.2 0.3 ... #> ..$ Qupstream : num [1:4749, 1:6] 0 0 0 0 0 0 0 0 0 0 ... #> .. ..- attr(*, "dimnames")=List of 2 #> .. .. ..$ : NULL #> .. .. ..$ : chr [1:6] "GrandeMaine_StFulgent" "PetiteMaine_StGeorges" "P_BULTIERE" "R_BULTIERE" ... #> ..$ LengthHydro : Named num [1:6] 33.4 23.1 28 28 19.1 ... #> .. ..- attr(*, "names")= chr [1:6] "GrandeMaine_StFulgent" "PetiteMaine_StGeorges" "P_BULTIERE" "R_BULTIERE" ... #> ..$ BasinAreas : Named num [1:7] 132 192 NA NA NA ... #> .. ..- attr(*, "names")= chr [1:7] "GrandeMaine_StFulgent" "PetiteMaine_StGeorges" "P_BULTIERE" "R_BULTIERE" ... #> ..$ id : chr "Maine_Remouille" #> ..$ down : chr NA #> ..$ UpstreamNodes : chr [1:6] "GrandeMaine_StFulgent" "PetiteMaine_StGeorges" "P_BULTIERE" "R_BULTIERE" ... #> ..$ UpstreamIsModeled: Named logi [1:6] TRUE TRUE FALSE FALSE FALSE FALSE #> .. ..- attr(*, "names")= chr [1:6] "GrandeMaine_StFulgent" "PetiteMaine_StGeorges" "P_BULTIERE" "R_BULTIERE" ... #> ..$ UpstreamVarQ : Named chr [1:6] "Qsim_m3" "Qsim_m3" "Qsim_m3" "Qsim_m3" ... #> .. ..- attr(*, "names")= chr [1:6] "GrandeMaine_StFulgent" "PetiteMaine_StGeorges" "P_BULTIERE" "R_BULTIERE" ... #> ..$ FUN_MOD : chr "RunModel_GR4J" #> ..$ inUngaugedCluster: logi FALSE #> ..$ isReceiver : logi FALSE #> ..$ gaugedId : chr "Maine_Remouille" #> ..$ hasUngaugedNodes : logi FALSE #> ..$ model :List of 4 #> .. ..$ indexParamUngauged: num [1:5] 1 2 3 4 5 #> .. ..$ hasX4 : logi TRUE #> .. ..$ iX4 : num 5 #> .. ..$ IsHyst : logi FALSE #> ..$ hasDiversion : logi FALSE #> ..$ isReservoir : logi FALSE #> ..- attr(*, "class")= chr [1:5] "RunModel_GR4J" "InputsModel" "daily" "GR" ... #> - attr(*, "class")= chr [1:2] "GRiwrmInputsModel" "list" #> - attr(*, "GRiwrm")= GRiwrm [11 × 6] (S3: GRiwrm/tbl_df/tbl/data.frame) #> ..$ id : chr [1:11] "GrandeMaine_StFulgent" "PetiteMaine_StGeorges" "Maine_Remouille" "P_BULTIERE" ... #> ..$ down : chr [1:11] "Maine_Remouille" "Maine_Remouille" NA "Maine_Remouille" ... #> ..$ length: num [1:11] 33.4 23.1 NA 28 28 ... #> ..$ area : num [1:11] 132 192 595 NA NA ... #> ..$ model : chr [1:11] "RunModel_GR4J" "RunModel_GR4J" "RunModel_GR4J" NA ... #> ..$ donor : chr [1:11] "GrandeMaine_StFulgent" "PetiteMaine_StGeorges" "Maine_Remouille" "P_BULTIERE" ... #> - attr(*, "TimeStep")= num 86400 ``` --- # Calage avec *airGRiwrm*: CreateRunOptions Définition des options de simulation: - Pas de temps de simulation (*warm-up* + run) - *états initiaux du modèle* - *Liste des variables en sortie du modèles* ```r ?CreateRunOptions ``` ## Exercice Définir les indices des pas de temps des périodes de : - initialisation du modèle (Warm-up) sur un an en début de chronique - simulation (Run) sur le reste de la chronique -- ``` r I_WarmUp <- 1:365 I_Run <- seq(366, length(DatesR)) ``` --- # Calage avec *airGRiwrm*: CreateRunOptions ## Exercice *Créer l'objet `RunOptions` à partir de l'objet `InputsModel` et des indices des périodes de chauffe et simulation* -- ``` r RO <- CreateRunOptions( IM, IndPeriod_WarmUp = I_WarmUp, IndPeriod_Run = I_Run ) ``` -- ``` r str(RO) #> List of 3 #> $ GrandeMaine_StFulgent:List of 9 #> ..$ IndPeriod_WarmUp: int [1:365] 1 2 3 4 5 6 7 8 9 10 ... #> ..$ IndPeriod_Run : int [1:4384] 366 367 368 369 370 371 372 373 374 375 ... #> ..$ IniStates : num [1:67] 0 0 0 0 0 0 0 0 0 0 ... #> ..$ IniResLevels : num [1:4] 0.3 0.5 NA NA #> ..$ Outputs_Cal : chr [1:2] "Qsim" "Param" #> ..$ Outputs_Sim : Named chr [1:24] "DatesR" "PotEvap" "Precip" "Prod" ... #> .. ..- attr(*, "names")= chr [1:24] "" "GR1" "GR2" "GR3" ... #> ..$ FortranOutputs :List of 2 #> .. ..$ GR: chr [1:18] "PotEvap" "Precip" "Prod" "Pn" ... #> .. ..$ CN: NULL #> ..$ FeatFUN_MOD :List of 12 #> .. ..$ CodeMod : chr "GR4J" #> .. ..$ NameMod : chr "GR4J" #> .. ..$ NbParam : num 5 #> .. ..$ TimeUnit : chr "daily" #> .. ..$ Id : logi NA #> .. ..$ Class : chr [1:2] "daily" "GR" #> .. ..$ Pkg : chr "airGR" #> .. ..$ NameFunMod : chr "RunModel_GR4J" #> .. ..$ TimeStep : num 86400 #> .. ..$ TimeStepMean: int 86400 #> .. ..$ CodeModHydro: chr "GR4J" #> .. ..$ IsSD : logi TRUE #> ..$ id : chr "GrandeMaine_StFulgent" #> ..- attr(*, "class")= chr [1:3] "RunOptions" "daily" "GR" #> $ PetiteMaine_StGeorges:List of 9 #> ..$ IndPeriod_WarmUp: int [1:365] 1 2 3 4 5 6 7 8 9 10 ... #> ..$ IndPeriod_Run : int [1:4384] 366 367 368 369 370 371 372 373 374 375 ... #> ..$ IniStates : num [1:67] 0 0 0 0 0 0 0 0 0 0 ... #> ..$ IniResLevels : num [1:4] 0.3 0.5 NA NA #> ..$ Outputs_Cal : chr [1:2] "Qsim" "Param" #> ..$ Outputs_Sim : Named chr [1:24] "DatesR" "PotEvap" "Precip" "Prod" ... #> .. ..- attr(*, "names")= chr [1:24] "" "GR1" "GR2" "GR3" ... #> ..$ FortranOutputs :List of 2 #> .. ..$ GR: chr [1:18] "PotEvap" "Precip" "Prod" "Pn" ... #> .. ..$ CN: NULL #> ..$ FeatFUN_MOD :List of 12 #> .. ..$ CodeMod : chr "GR4J" #> .. ..$ NameMod : chr "GR4J" #> .. ..$ NbParam : num 5 #> .. ..$ TimeUnit : chr "daily" #> .. ..$ Id : logi NA #> .. ..$ Class : chr [1:2] "daily" "GR" #> .. ..$ Pkg : chr "airGR" #> .. ..$ NameFunMod : chr "RunModel_GR4J" #> .. ..$ TimeStep : num 86400 #> .. ..$ TimeStepMean: int 86400 #> .. ..$ CodeModHydro: chr "GR4J" #> .. ..$ IsSD : logi TRUE #> ..$ id : chr "PetiteMaine_StGeorges" #> ..- attr(*, "class")= chr [1:3] "RunOptions" "daily" "GR" #> $ Maine_Remouille :List of 9 #> ..$ IndPeriod_WarmUp: int [1:365] 1 2 3 4 5 6 7 8 9 10 ... #> ..$ IndPeriod_Run : int [1:4384] 366 367 368 369 370 371 372 373 374 375 ... #> ..$ IniStates : num [1:67] 0 0 0 0 0 0 0 0 0 0 ... #> ..$ IniResLevels : num [1:4] 0.3 0.5 NA NA #> ..$ Outputs_Cal : chr [1:2] "Qsim" "Param" #> ..$ Outputs_Sim : Named chr [1:24] "DatesR" "PotEvap" "Precip" "Prod" ... #> .. ..- attr(*, "names")= chr [1:24] "" "GR1" "GR2" "GR3" ... #> ..$ FortranOutputs :List of 2 #> .. ..$ GR: chr [1:18] "PotEvap" "Precip" "Prod" "Pn" ... #> .. ..$ CN: NULL #> ..$ FeatFUN_MOD :List of 12 #> .. ..$ CodeMod : chr "GR4J" #> .. ..$ NameMod : chr "GR4J" #> .. ..$ NbParam : num 5 #> .. ..$ TimeUnit : chr "daily" #> .. ..$ Id : logi NA #> .. ..$ Class : chr [1:2] "daily" "GR" #> .. ..$ Pkg : chr "airGR" #> .. ..$ NameFunMod : chr "RunModel_GR4J" #> .. ..$ TimeStep : num 86400 #> .. ..$ TimeStepMean: int 86400 #> .. ..$ CodeModHydro: chr "GR4J" #> .. ..$ IsSD : logi TRUE #> ..$ id : chr "Maine_Remouille" #> ..- attr(*, "class")= chr [1:3] "RunOptions" "daily" "GR" #> - attr(*, "class")= chr [1:2] "list" "GRiwrmRunOptions" ``` --- # Calage avec *airGRiwrm*: `CreateInputsCrit` Définition des critères de calage : ```r ?CreateInputsCrit.GRiwrmInputsModel ``` ## Exercice *Créer un critère de calage utilisant les débit observées au stations hydrométriques, un critère **KGE2** et une transformation "Racine carrée" des débits* -- ``` r Q <- do.call(cbind, lapply(BasinObs, "[[", "Q")) IC <- CreateInputsCrit( IM, FUN_CRIT = airGR::ErrorCrit_KGE2, RunOptions = RO, Obs = Q[I_Run,], transfo = "sqrt" ) ``` -- ``` r str(IC) #> List of 3 #> $ GrandeMaine_StFulgent:List of 8 #> ..$ FUN_CRIT:function (InputsCrit, OutputsModel, warnings = TRUE, verbose = TRUE) #> .. ..- attr(*, "class")= chr [1:2] "FUN_CRIT" "function" #> ..$ Obs : num [1:4384] 0.409 0.386 0.377 0.352 0.337 0.335 0.333 0.279 0.291 0.293 ... #> ..$ VarObs : chr "Q" #> ..$ BoolCrit: logi [1:4384] TRUE TRUE TRUE TRUE TRUE TRUE ... #> ..$ idLayer : logi NA #> ..$ transfo : chr "sqrt" #> ..$ epsilon : NULL #> ..$ Weights : NULL #> ..- attr(*, "class")= chr [1:2] "Single" "InputsCrit" #> $ PetiteMaine_StGeorges:List of 8 #> ..$ FUN_CRIT:function (InputsCrit, OutputsModel, warnings = TRUE, verbose = TRUE) #> .. ..- attr(*, "class")= chr [1:2] "FUN_CRIT" "function" #> ..$ Obs : num [1:4384] 0.278 0.273 0.246 0.245 0.227 0.211 0.222 0.203 0.191 0.118 ... #> ..$ VarObs : chr "Q" #> ..$ BoolCrit: logi [1:4384] TRUE TRUE TRUE TRUE TRUE TRUE ... #> ..$ idLayer : logi NA #> ..$ transfo : chr "sqrt" #> ..$ epsilon : NULL #> ..$ Weights : NULL #> ..- attr(*, "class")= chr [1:2] "Single" "InputsCrit" #> $ Maine_Remouille :List of 8 #> ..$ FUN_CRIT:function (InputsCrit, OutputsModel, warnings = TRUE, verbose = TRUE) #> .. ..- attr(*, "class")= chr [1:2] "FUN_CRIT" "function" #> ..$ Obs : num [1:4384] 0.43 0.43 0.372 0.224 0.246 0.34 0.212 0.201 0.179 0.176 ... #> ..$ VarObs : chr "Q" #> ..$ BoolCrit: logi [1:4384] TRUE TRUE TRUE TRUE TRUE TRUE ... #> ..$ idLayer : logi NA #> ..$ transfo : chr "sqrt" #> ..$ epsilon : NULL #> ..$ Weights : NULL #> ..- attr(*, "class")= chr [1:2] "Single" "InputsCrit" #> - attr(*, "class")= chr [1:2] "GRiwrmInputsCrit" "list" ``` --- # Calage avec *airGRiwrm*: `CreateCalibOptions` ```r ?CreateInputsCrit.GRiwrmInputsModel ``` ## Exercice *Créer l'objet `CalibOptions` avec les options par défaut* ``` r CO <- CreateCalibOptions(IM) ``` ``` r str(CO) #> List of 3 #> $ GrandeMaine_StFulgent:List of 4 #> ..$ FixedParam : logi [1:5] NA NA NA NA NA #> ..$ SearchRanges : num [1:2, 1:5] 1.00e-02 2.00e+01 4.59e-05 2.18e+04 -1.09e+04 ... #> ..$ FUN_TRANSFO :function (ParamIn, Direction) #> ..$ StartParamDistrib: num [1:3, 1:5] 1.25 2.5 5 169.02 247.15 ... #> ..- attr(*, "class")= chr [1:5] "CalibOptions" "daily" "GR" "SD" ... #> $ PetiteMaine_StGeorges:List of 4 #> ..$ FixedParam : logi [1:5] NA NA NA NA NA #> ..$ SearchRanges : num [1:2, 1:5] 1.00e-02 2.00e+01 4.59e-05 2.18e+04 -1.09e+04 ... #> ..$ FUN_TRANSFO :function (ParamIn, Direction) #> ..$ StartParamDistrib: num [1:3, 1:5] 1.25 2.5 5 169.02 247.15 ... #> ..- attr(*, "class")= chr [1:5] "CalibOptions" "daily" "GR" "SD" ... #> $ Maine_Remouille :List of 4 #> ..$ FixedParam : logi [1:5] NA NA NA NA NA #> ..$ SearchRanges : num [1:2, 1:5] 1.00e-02 2.00e+01 4.59e-05 2.18e+04 -1.09e+04 ... #> ..$ FUN_TRANSFO :function (ParamIn, Direction) #> ..$ StartParamDistrib: num [1:3, 1:5] 1.25 2.5 5 169.02 247.15 ... #> ..- attr(*, "class")= chr [1:5] "CalibOptions" "daily" "GR" "SD" ... #> - attr(*, "class")= chr [1:2] "GRiwrmCalibOptions" "list" ``` --- # `Calibration` dans *airGRiwrm*: `Calibration` **airGRiwrm** opère un calage séquentiel amont-aval des modèles hydrologiques des sous-bassins. ```r ?Calibration.GRiwrmInputsModel ``` ## Exercice *Lancer la calibration du modèle avec les inputs (`InputsModel`), les options de simulations (`RunOptions`), les critères de calage (`InputsCrit`) et les options de calage (`CalibOptions`)* -- ``` r OC <- suppressWarnings( Calibration(IM, RunOptions = RO, InputsCrit = IC, CalibOptions = CO) ) #> Calibration.GRiwrmInputsModel: Processing sub-basin GrandeMaine_StFulgent... #> Grid-Screening in progress (0% 20% 40% 60% 80% 100%) #> Screening completed (243 runs) #> Param = 1.250, 169.017, -2.376, 42.098, 1.944 #> Crit. KGE2[sqrt(Q)] = 0.9173 #> Steepest-descent local search in progress #> Calibration completed (70 iterations, 964 runs) #> Param = 0.676, 231.109, -0.745, 15.290, 2.094 #> Crit. KGE2[sqrt(Q)] = 0.9421 #> Calibration.GRiwrmInputsModel: Processing sub-basin PetiteMaine_StGeorges... #> Grid-Screening in progress (0% 20% 40% 60% 80% 100%) #> Screening completed (243 runs) #> Param = 1.250, 169.017, -2.376, 20.697, 2.384 #> Crit. KGE2[sqrt(Q)] = 0.8888 #> Steepest-descent local search in progress #> Calibration completed (67 iterations, 931 runs) #> Param = 0.930, 198.835, -0.892, 10.753, 2.193 #> Crit. KGE2[sqrt(Q)] = 0.9417 #> Calibration.GRiwrmInputsModel: Processing sub-basin Maine_Remouille... #> Grid-Screening in progress (0% 20% 40% 60% 80% 100%) #> Screening completed (243 runs) #> Param = 5.000, 169.017, -0.649, 20.697, 1.944 #> Crit. KGE2[sqrt(Q)] = 0.9522 #> Steepest-descent local search in progress #> Calibration completed (40 iterations, 630 runs) #> Param = 5.454, 187.150, -0.528, 14.447, 2.329 #> Crit. KGE2[sqrt(Q)] = 0.9550 ``` --- # `Calibration` dans *airGRiwrm*: `Calibration` ``` r str(OC) #> List of 3 #> $ GrandeMaine_StFulgent:List of 9 #> ..$ ParamFinalR : num [1:5] 0.676 231.109 -0.745 15.29 2.094 #> ..$ CritFinal : num 0.942 #> ..$ NIter : num 70 #> ..$ NRuns : num 964 #> ..$ HistParamR : num [1:70, 1:5] 1.25 1.25 0.93 0.93 0.93 0.93 0.77 0.77 0.77 0.77 ... #> .. ..- attr(*, "dimnames")=List of 2 #> .. .. ..$ : NULL #> .. .. ..$ : chr [1:5] "Param1" "Param2" "Param3" "Param4" ... #> ..$ HistCrit : num [1:70, 1] 0.917 0.917 0.917 0.917 0.92 ... #> ..$ MatBoolCrit : logi [1:4384, 1:2] TRUE TRUE TRUE TRUE TRUE TRUE ... #> .. ..- attr(*, "dimnames")=List of 2 #> .. .. ..$ : NULL #> .. .. ..$ : chr [1:2] "BoolCrit_Requested" "BoolCrit_Actual" #> ..$ CritName : chr "KGE2[sqrt(Q)]" #> ..$ CritBestValue: num 1 #> ..- attr(*, "class")= chr [1:2] "OutputsCalib" "HBAN" #> $ PetiteMaine_StGeorges:List of 9 #> ..$ ParamFinalR : num [1:5] 0.93 198.835 -0.892 10.753 2.193 #> ..$ CritFinal : num 0.942 #> ..$ NIter : num 67 #> ..$ NRuns : num 931 #> ..$ HistParamR : num [1:67, 1:5] 1.25 1.25 1.25 1.25 1.25 1.25 1.25 1.25 1.25 1.25 ... #> .. ..- attr(*, "dimnames")=List of 2 #> .. .. ..$ : NULL #> .. .. ..$ : chr [1:5] "Param1" "Param2" "Param3" "Param4" ... #> ..$ HistCrit : num [1:67, 1] 0.889 0.889 0.92 0.931 0.931 ... #> ..$ MatBoolCrit : logi [1:4384, 1:2] TRUE TRUE TRUE TRUE TRUE TRUE ... #> .. ..- attr(*, "dimnames")=List of 2 #> .. .. ..$ : NULL #> .. .. ..$ : chr [1:2] "BoolCrit_Requested" "BoolCrit_Actual" #> ..$ CritName : chr "KGE2[sqrt(Q)]" #> ..$ CritBestValue: num 1 #> ..- attr(*, "class")= chr [1:2] "OutputsCalib" "HBAN" #> $ Maine_Remouille :List of 9 #> ..$ ParamFinalR : num [1:5] 5.454 187.15 -0.528 14.447 2.329 #> ..$ CritFinal : num 0.955 #> ..$ NIter : num 40 #> ..$ NRuns : num 630 #> ..$ HistParamR : num [1:40, 1:5] 5 5.64 6.28 6.28 6.28 6.28 6.28 6.28 6.12 5.96 ... #> .. ..- attr(*, "dimnames")=List of 2 #> .. .. ..$ : NULL #> .. .. ..$ : chr [1:5] "Param1" "Param2" "Param3" "Param4" ... #> ..$ HistCrit : num [1:40, 1] 0.952 0.952 0.952 0.952 0.952 ... #> ..$ MatBoolCrit : logi [1:4384, 1:2] TRUE TRUE TRUE TRUE TRUE TRUE ... #> .. ..- attr(*, "dimnames")=List of 2 #> .. .. ..$ : NULL #> .. .. ..$ : chr [1:2] "BoolCrit_Requested" "BoolCrit_Actual" #> ..$ CritName : chr "KGE2[sqrt(Q)]" #> ..$ CritBestValue: num 1 #> ..- attr(*, "class")= chr [1:2] "OutputsCalib" "HBAN" #> - attr(*, "class")= chr [1:2] "GRiwrmOutputsCalib" "list" ``` --- # `RunModel` dans *airGRiwrm* ```r ?RunModel.GRiwrmInputsModel ``` ## Exercice Récupérer les paramètres de calage et lancer le modèle avec les inputs et les options de simulation -- ``` r Params <- lapply(OC, "[[", "ParamFinalR") str(Params) #> List of 3 #> $ GrandeMaine_StFulgent: num [1:5] 0.676 231.109 -0.745 15.29 2.094 #> $ PetiteMaine_StGeorges: num [1:5] 0.93 198.835 -0.892 10.753 2.193 #> $ Maine_Remouille : num [1:5] 5.454 187.15 -0.528 14.447 2.329 ``` -- ``` r OM <- RunModel(IM, RunOptions = RO, Param = Params) #> RunModel.GRiwrmInputsModel: Processing sub-basin GrandeMaine_StFulgent... #> Warning in RunModel_Lag(InputsModel, RunOptions, Param[1], OutputsModel): 174 #> time steps with negative flow, set to zero. #> RunModel.GRiwrmInputsModel: Processing sub-basin PetiteMaine_StGeorges... #> Warning in RunModel_Lag(InputsModel, RunOptions, Param[1], OutputsModel): 459 #> time steps with negative flow, set to zero. #> RunModel.GRiwrmInputsModel: Processing sub-basin Maine_Remouille... #> Warning in RunModel_Lag(InputsModel, RunOptions, Param[1], OutputsModel): 83 #> time steps with negative flow, set to zero. ``` --- # Visualisation des données de simulation ```r ?plot.GRiwrmOutputsModel ``` ## Exercice Afficher les plots d'analyse de **airGR** avec les débits simulés/observés -- ``` r plot(OM, Q[I_Run,]) ``` <img src="index_files/figure-html/plot.GRiwrmOutputsModel-1.png" width="65%" style="display: block; margin: auto;" /><img src="index_files/figure-html/plot.GRiwrmOutputsModel-2.png" width="65%" style="display: block; margin: auto;" /><img src="index_files/figure-html/plot.GRiwrmOutputsModel-3.png" width="65%" style="display: block; margin: auto;" /> --- # Visualisation des données de simulation Le plot des débits simulés sur tous les noeuds du modèle en m3/s ```r ?plot.Qm3s ``` ## Exercice Afficher tous les débits simulés pour la première année de simulation -- ``` r Qm3s <- attr(OM, "Qm3s") plot(Qm3s[1:365,]) ``` <img src="index_files/figure-html/plot.Qm3s-1.png" width="65%" style="display: block; margin: auto;" /> --- class: inverse, middle, center # Modélisation du barrage de la Bultière <img src="img/Barrage_de_la_Bultiere.jpg" width="65%" style="display: block; margin: auto;" /> --- # Modélisation du barrage de la Bultière Nous implémenterons le barrage de la Bultière à l'aide d'un modèle de type "Reservoir" (`RunModel_Reservoir`) qui simule le volume stocké en fonction des entrées provenant des nœuds amont et d'un débit lâcher fourni par l'utilisateur. Le barrage peut stocker jusqu'à 5 millions de mètres cubes et est utilisé comme réserve pour un prélèvement AEP qui sera lui aussi modélisé. Il est réglé pour lâcher en permanence un débit réservé de 160 L/s. ``` #> Ungauged node 'Barrage_Bultiere' automatically gets the node 'Maine_Remouille' as parameter donor ``` <img src="index_files/figure-html/plot.GRiwrm.bultiere-1.png" width="65%" style="display: block; margin: auto;" /> --- # Installation de la version de développement de airGRiwrm Le noeud de type "Reservoir" n'est présent que dans la version de développement de **airGRiwrm**. ``` r install.packages("remotes") # Si nécessaire remotes::install_github("inrae/airGRiwrm", "dev") ``` --- # Chargement des données du barrage ## Exercice *Charger et explorer les variables `reseau_bultiere` et `Q_AEP_Bultiere` situées dans le fichier "`data/Barrage_Bultiere.RData`".* -- ``` r load("data/Barrage_Bultiere.RData") summary(Q_AEP_Bultiere) #> Min. 1st Qu. Median Mean 3rd Qu. Max. #> 2512 12328 14947 14569 16830 26128 ``` Le débit de prélèvement AEP est ici en m<sup>3</sup>/jour. --- # Chargement des données du barrage ## Exercice *Charger et explorer les variables `reseau_bultiere` et `Q_AEP_Bultiere` situées dans le fichier "`data/Barrage_Bultiere.RData`".* -- ``` r reseau_bultiere ``` |id |down | length|model | area| |:---------------------|:---------------------|---------:|:------------------|------:| |Maine_Remouille |NA | NA|RunModel_GR4J | 594.58| |GrandeMaine_StFulgent |Barrage_Bultiere | 5.370000|RunModel_GR4J | 132.17| |PetiteMaine_StGeorges |Maine_Remouille | 23.070000|RunModel_GR4J | 191.82| |P_MAINE |Maine_Remouille | 19.115837|NA | NA| |R_MAINE |Maine_Remouille | 21.844591|NA | NA| |P_GRANDEMAINE |GrandeMaine_StFulgent | 9.025684|NA | NA| |R_GRANDEMAINE |GrandeMaine_StFulgent | 10.418234|NA | NA| |P_PETITEMAINE |PetiteMaine_StGeorges | 15.472812|NA | NA| |R_PETITEMAINE |PetiteMaine_StGeorges | 15.472703|NA | NA| |Barrage_Bultiere |Maine_Remouille | 28.040000|RunModel_Reservoir | NA| |AEP_Bultiere |Barrage_Bultiere | 0.000000|NA | NA| --- # Création du réseau : `CreateGRiwrm` ## Exercice *Créer le réseau GRiwrm et afficher le schéma du réseau* -- ``` r g_bultiere <- CreateGRiwrm(reseau_bultiere) #> Ungauged node 'Barrage_Bultiere' automatically gets the node 'Maine_Remouille' as parameter donor ``` ``` r plot(g_bultiere) ``` <img src="index_files/figure-html/g_bultiere-1.png" width="65%" style="display: block; margin: auto;" /> --- # Initialiser les données d'entrée du modèle Les entrées du modèle comprennent les données météo (`Precip`, `PotEvap`), les prélèvements et rejets et le débit de lâcher du barrage (`Qobs`). Le barrage de la Bultière relâche 160 L/s toute l'année (plus en cas de surverse). Ce sera le débit imposé sur le modèle `RunModel_Reservoir` qui relâchera ce débit si le volume contenu dans le barrage le permet. ## Exercice *Créer une chronique constante de débit de lâchers programmés sur le barrage de la Bultière de 160 L/s pour une injection dans les données `Qobs` (en m<sup>3</sup>/jour)* -- ``` r Q_Barrage_Bultiere <- rep(160 / 1000 * 86400, length(DatesR)) str(Q_Barrage_Bultiere) #> num [1:4749] 13824 13824 13824 13824 13824 ... ``` --- # Initialiser les données d'entrée du modèle Les entrées du modèle comprennent les données météo (`Precip`, `PotEvap`), les prélèvements et rejets et le débit de lâcher du barrage (`Qobs`). ## Exercice *Mettre à jour la matrice des prélèvements/rejets qui sera injectée dans `CreateInputsModel` via le paramètre `Qobs`* -- ``` r str(Q_water_use) #> num [1:4749, 1:8] -0.438 -0.438 -0.829 -2.223 -4.083 ... #> - attr(*, "dimnames")=List of 2 #> ..$ : chr [1:4749] "732" "733" "734" "735" ... #> ..$ : chr [1:8] "P_BULTIERE" "R_BULTIERE" "P_MAINE" "R_MAINE" ... ``` ``` r Q_water_use2 <- Q_water_use[, !grepl("BULTIERE", colnames(Q_water_use))] Q_water_use2 <- cbind(Q_water_use2 * 86400, AEP_Bultiere = -Q_AEP_Bultiere, Barrage_Bultiere = Q_Barrage_Bultiere) str(Q_water_use2) #> num [1:4749, 1:8] -1966 -2116 -2115 -2090 -1417 ... #> - attr(*, "dimnames")=List of 2 #> ..$ : chr [1:4749] "732" "733" "734" "735" ... #> ..$ : chr [1:8] "P_MAINE" "R_MAINE" "P_GRANDEMAINE" "R_GRANDEMAINE" ... ``` --- # Initialiser les données d'entrée du modèle ## Exercice *Créer l'objet `InputsModel`* -- ``` r IM2 <- CreateInputsModel( g_bultiere, DatesR = DatesR, Precip = P, PotEvap = E, Qobs = Q_water_use2 ) #> Warning in CreateInputsModel.GRiwrm(g_bultiere, DatesR = DatesR, Precip = P, : #> The usage of 'Qobs' is deprecated, use 'Qinf' instead #> Warning in updateQinfQrelease(g = x, Qinf = Qinf, Qrelease = Qrelease): Use of the `Qinf` parameter for reservoir releases is deprecated, please use `Qrelease` instead. #> Processing `Qrelease <- cbind(Qrelease, Qinf[, c("Barrage_Bultiere"])`... #> CreateInputsModel.GRiwrm: Processing sub-basin GrandeMaine_StFulgent... #> CreateInputsModel.GRiwrm: Processing sub-basin PetiteMaine_StGeorges... #> CreateInputsModel.GRiwrm: Processing sub-basin Barrage_Bultiere... #> CreateInputsModel.GRiwrm: Processing sub-basin Maine_Remouille... ``` ``` r str(IM2) #> List of 4 #> $ GrandeMaine_StFulgent:List of 19 #> ..$ DatesR : POSIXlt[1:4749], format: "2008-01-01" "2008-01-02" ... #> ..$ Precip : num [1:4749] 0 0.2 4.7 12.2 9.4 17.7 0.5 1.9 2 4 ... #> ..$ PotEvap : num [1:4749] 0.4 0.3 0.3 0.2 0.3 0.3 0.5 0.3 0.3 0.2 ... #> ..$ Qupstream : num [1:4749, 1:2] -943 -1009 -1009 -989 -947 ... #> .. ..- attr(*, "dimnames")=List of 2 #> .. .. ..$ : NULL #> .. .. ..$ : chr [1:2] "P_GRANDEMAINE" "R_GRANDEMAINE" #> ..$ LengthHydro : Named num [1:2] 9.03 10.42 #> .. ..- attr(*, "names")= chr [1:2] "P_GRANDEMAINE" "R_GRANDEMAINE" #> ..$ BasinAreas : Named num [1:3] NA NA 132 #> .. ..- attr(*, "names")= chr [1:3] "P_GRANDEMAINE" "R_GRANDEMAINE" "GrandeMaine_StFulgent" #> ..$ id : chr "GrandeMaine_StFulgent" #> ..$ down : chr "Barrage_Bultiere" #> ..$ UpstreamNodes : chr [1:2] "P_GRANDEMAINE" "R_GRANDEMAINE" #> ..$ UpstreamIsModeled: Named logi [1:2] FALSE FALSE #> .. ..- attr(*, "names")= chr [1:2] "P_GRANDEMAINE" "R_GRANDEMAINE" #> ..$ UpstreamVarQ : Named chr [1:2] "Qsim_m3" "Qsim_m3" #> .. ..- attr(*, "names")= chr [1:2] "P_GRANDEMAINE" "R_GRANDEMAINE" #> ..$ FUN_MOD : chr "RunModel_GR4J" #> ..$ inUngaugedCluster: logi FALSE #> ..$ isReceiver : logi FALSE #> ..$ gaugedId : chr "GrandeMaine_StFulgent" #> ..$ hasUngaugedNodes : logi FALSE #> ..$ model :List of 4 #> .. ..$ indexParamUngauged: num [1:5] 1 2 3 4 5 #> .. ..$ hasX4 : logi TRUE #> .. ..$ iX4 : num 5 #> .. ..$ IsHyst : logi FALSE #> ..$ hasDiversion : logi FALSE #> ..$ isReservoir : logi FALSE #> ..- attr(*, "class")= chr [1:5] "RunModel_GR4J" "InputsModel" "daily" "GR" ... #> $ PetiteMaine_StGeorges:List of 19 #> ..$ DatesR : POSIXlt[1:4749], format: "2008-01-01" "2008-01-02" ... #> ..$ Precip : num [1:4749] 0 0.2 5 11.6 9.7 16.7 0.4 2 2.1 4.4 ... #> ..$ PotEvap : num [1:4749] 0.4 0.3 0.3 0.2 0.3 0.3 0.4 0.3 0.3 0.2 ... #> ..$ Qupstream : num [1:4749, 1:2] -1771 -1891 -1891 -1859 -1424 ... #> .. ..- attr(*, "dimnames")=List of 2 #> .. .. ..$ : NULL #> .. .. ..$ : chr [1:2] "P_PETITEMAINE" "R_PETITEMAINE" #> ..$ LengthHydro : Named num [1:2] 15.5 15.5 #> .. ..- attr(*, "names")= chr [1:2] "P_PETITEMAINE" "R_PETITEMAINE" #> ..$ BasinAreas : Named num [1:3] NA NA 192 #> .. ..- attr(*, "names")= chr [1:3] "P_PETITEMAINE" "R_PETITEMAINE" "PetiteMaine_StGeorges" #> ..$ id : chr "PetiteMaine_StGeorges" #> ..$ down : chr "Maine_Remouille" #> ..$ UpstreamNodes : chr [1:2] "P_PETITEMAINE" "R_PETITEMAINE" #> ..$ UpstreamIsModeled: Named logi [1:2] FALSE FALSE #> .. ..- attr(*, "names")= chr [1:2] "P_PETITEMAINE" "R_PETITEMAINE" #> ..$ UpstreamVarQ : Named chr [1:2] "Qsim_m3" "Qsim_m3" #> .. ..- attr(*, "names")= chr [1:2] "P_PETITEMAINE" "R_PETITEMAINE" #> ..$ FUN_MOD : chr "RunModel_GR4J" #> ..$ inUngaugedCluster: logi FALSE #> ..$ isReceiver : logi FALSE #> ..$ gaugedId : chr "PetiteMaine_StGeorges" #> ..$ hasUngaugedNodes : logi FALSE #> ..$ model :List of 4 #> .. ..$ indexParamUngauged: num [1:5] 1 2 3 4 5 #> .. ..$ hasX4 : logi TRUE #> .. ..$ iX4 : num 5 #> .. ..$ IsHyst : logi FALSE #> ..$ hasDiversion : logi FALSE #> ..$ isReservoir : logi FALSE #> ..- attr(*, "class")= chr [1:5] "RunModel_GR4J" "InputsModel" "daily" "GR" ... #> $ Barrage_Bultiere :List of 18 #> ..$ DatesR : POSIXlt[1:4749], format: "2008-01-01" "2008-01-02" ... #> ..$ Qupstream : num [1:4749, 1:2] 0 0 0 0 0 0 0 0 0 0 ... #> .. ..- attr(*, "dimnames")=List of 2 #> .. .. ..$ : NULL #> .. .. ..$ : chr [1:2] "GrandeMaine_StFulgent" "AEP_Bultiere" #> ..$ LengthHydro : Named num [1:2] 5.37 0 #> .. ..- attr(*, "names")= chr [1:2] "GrandeMaine_StFulgent" "AEP_Bultiere" #> ..$ BasinAreas : Named num [1:3] 132 NA NA #> .. ..- attr(*, "names")= chr [1:3] "GrandeMaine_StFulgent" "AEP_Bultiere" "Barrage_Bultiere" #> ..$ id : chr "Barrage_Bultiere" #> ..$ down : chr "Maine_Remouille" #> ..$ UpstreamNodes : chr [1:2] "GrandeMaine_StFulgent" "AEP_Bultiere" #> ..$ UpstreamIsModeled: Named logi [1:2] TRUE FALSE #> .. ..- attr(*, "names")= chr [1:2] "GrandeMaine_StFulgent" "AEP_Bultiere" #> ..$ UpstreamVarQ : Named chr [1:2] "Qsim_m3" "Qsim_m3" #> .. ..- attr(*, "names")= chr [1:2] "GrandeMaine_StFulgent" "AEP_Bultiere" #> ..$ FUN_MOD : chr "RunModel_Lag" #> ..$ inUngaugedCluster: logi FALSE #> ..$ isReceiver : logi FALSE #> ..$ gaugedId : chr "Barrage_Bultiere" #> ..$ hasUngaugedNodes : logi FALSE #> ..$ model :List of 4 #> .. ..$ indexParamUngauged: num [1:2] 1 2 #> .. ..$ hasX4 : logi FALSE #> .. ..$ iX4 : num 5 #> .. ..$ IsHyst : logi FALSE #> ..$ hasDiversion : logi FALSE #> ..$ isReservoir : logi TRUE #> ..$ Qrelease : Named num [1:4749] 13824 13824 13824 13824 13824 ... #> .. ..- attr(*, "names")= chr [1:4749] "732" "733" "734" "735" ... #> ..- attr(*, "class")= chr [1:5] "RunModel_Reservoir" "InputsModel" "daily" "SD" ... #> $ Maine_Remouille :List of 19 #> ..$ DatesR : POSIXlt[1:4749], format: "2008-01-01" "2008-01-02" ... #> ..$ Precip : num [1:4749] 0 0.121 4.842 11.442 9.305 ... #> ..$ PotEvap : num [1:4749] 0.4 0.3 0.3 0.2 0.3 ... #> ..$ Qupstream : num [1:4749, 1:4] 0 0 0 0 0 0 0 0 0 0 ... #> .. ..- attr(*, "dimnames")=List of 2 #> .. .. ..$ : NULL #> .. .. ..$ : chr [1:4] "PetiteMaine_StGeorges" "Barrage_Bultiere" "P_MAINE" "R_MAINE" #> ..$ LengthHydro : Named num [1:4] 23.1 28 19.1 21.8 #> .. ..- attr(*, "names")= chr [1:4] "PetiteMaine_StGeorges" "Barrage_Bultiere" "P_MAINE" "R_MAINE" #> ..$ BasinAreas : Named num [1:5] 192 132 NA NA 271 #> .. ..- attr(*, "names")= chr [1:5] "PetiteMaine_StGeorges" "Barrage_Bultiere" "P_MAINE" "R_MAINE" ... #> ..$ id : chr "Maine_Remouille" #> ..$ down : chr NA #> ..$ UpstreamNodes : chr [1:4] "PetiteMaine_StGeorges" "Barrage_Bultiere" "P_MAINE" "R_MAINE" #> ..$ UpstreamIsModeled: Named logi [1:4] TRUE TRUE FALSE FALSE #> .. ..- attr(*, "names")= chr [1:4] "PetiteMaine_StGeorges" "Barrage_Bultiere" "P_MAINE" "R_MAINE" #> ..$ UpstreamVarQ : Named chr [1:4] "Qsim_m3" "Qsim_m3" "Qsim_m3" "Qsim_m3" #> .. ..- attr(*, "names")= chr [1:4] "PetiteMaine_StGeorges" "Barrage_Bultiere" "P_MAINE" "R_MAINE" #> ..$ FUN_MOD : chr "RunModel_GR4J" #> ..$ inUngaugedCluster: logi FALSE #> ..$ isReceiver : logi FALSE #> ..$ gaugedId : chr "Maine_Remouille" #> ..$ hasUngaugedNodes : logi FALSE #> ..$ model :List of 4 #> .. ..$ indexParamUngauged: num [1:5] 1 2 3 4 5 #> .. ..$ hasX4 : logi TRUE #> .. ..$ iX4 : num 5 #> .. ..$ IsHyst : logi FALSE #> ..$ hasDiversion : logi FALSE #> ..$ isReservoir : logi FALSE #> ..- attr(*, "class")= chr [1:5] "RunModel_GR4J" "InputsModel" "daily" "GR" ... #> - attr(*, "class")= chr [1:2] "GRiwrmInputsModel" "list" #> - attr(*, "GRiwrm")= GRiwrm [11 × 6] (S3: GRiwrm/tbl_df/tbl/data.frame) #> ..$ id : chr [1:11] "GrandeMaine_StFulgent" "PetiteMaine_StGeorges" "Barrage_Bultiere" "Maine_Remouille" ... #> ..$ down : chr [1:11] "Barrage_Bultiere" "Maine_Remouille" "Maine_Remouille" NA ... #> ..$ length: num [1:11] 5.37 23.07 28.04 NA 19.12 ... #> ..$ area : num [1:11] 132 192 NA 595 NA ... #> ..$ model : chr [1:11] "RunModel_GR4J" "RunModel_GR4J" "RunModel_Reservoir" "RunModel_GR4J" ... #> ..$ donor : chr [1:11] "GrandeMaine_StFulgent" "PetiteMaine_StGeorges" "Barrage_Bultiere" "Maine_Remouille" ... #> - attr(*, "TimeStep")= num 86400 ``` --- # Paramètres de simulation Nous utilisons les paramètres calés précédemment mais il faut ajouter les paramètres du réservoir: - `Vmax`: la capacité de stockage du réservoir (m<sup>3</sup>) - `celerity`: la vitesse de propagation des débits amont vers le réservoir ## Exercice *Compléter la liste des paramètres avec ceux du réservoir. Pour la célérité, utiliser celle calée sur le bassin versant intermédiaire aval.* -- ``` r str(Params) #> List of 3 #> $ GrandeMaine_StFulgent: num [1:5] 0.676 231.109 -0.745 15.29 2.094 #> $ PetiteMaine_StGeorges: num [1:5] 0.93 198.835 -0.892 10.753 2.193 #> $ Maine_Remouille : num [1:5] 5.454 187.15 -0.528 14.447 2.329 ``` ``` r Params$Barrage_Bultiere <- c(Vmax = 5E6, celerity = Params$Maine_Remouille[1]) ``` --- # Options de simulation du réservoir Le lancement de `CreateRunOptions` est le même que précédemment mais l'objet `InputsModel` a changé... ## Exercice *Définissons les options de simulation* -- ``` r RO2 <- CreateRunOptions( IM2, IndPeriod_WarmUp = I_WarmUp, IndPeriod_Run = I_Run ) ``` Les options de simulations contiennent les états initiaux du model. Le réservoir a pour état initial le volume contenu au premier pas de temps de simulation. Il est fixé par défaut à la moitié de la capacité du réservoir mais peut être redéfini (Voir `?RunModel_Reservoir`). --- # Simulation du réservoir ## Exercice *Lancer la simulation* -- ``` r OM2 <- RunModel(IM2, RunOptions = RO2, Param = Params) #> RunModel.GRiwrmInputsModel: Processing sub-basin GrandeMaine_StFulgent... #> Warning in RunModel_Lag(InputsModel, RunOptions, Param[1], OutputsModel): 174 #> time steps with negative flow, set to zero. #> RunModel.GRiwrmInputsModel: Processing sub-basin PetiteMaine_StGeorges... #> Warning in RunModel_Lag(InputsModel, RunOptions, Param[1], OutputsModel): 459 #> time steps with negative flow, set to zero. #> RunModel.GRiwrmInputsModel: Processing sub-basin Barrage_Bultiere... #> RunModel.GRiwrmInputsModel: Processing sub-basin Maine_Remouille... #> Warning in RunModel_Lag(InputsModel, RunOptions, Param[1], OutputsModel): 53 #> time steps with negative flow, set to zero. ``` --- # Simulation du réservoir ## Exercice *Afficher le graphique des débits et volumes simulés sur le barrage* ```r ?plot.OutputsModelReservoir ``` -- ``` r plot(OM2$Barrage_Bultiere) ``` <img src="index_files/figure-html/plot.OutputModelReservoir-1.png" width="65%" style="display: block; margin: auto;" /> --- class: inverse, middle, center # Régulation du barrage de la Bultière Et si on régulait le barrage pour avoir un débit minimal de 400 L/s à Rémouillé ? --- # Création du superviseur Le superviseur est un ordonnanceur de la simulation qui va : - stopper la simulation tous les *n* pas de temps - lancer un ou plusieurs contrôleurs qui vont: - récupérer des données simulées (mesures) aux pas de temps précédents - calculer des commandes (ex: prélèvement, lâcher de réservoir...) à partir d'une fonction dite de logique de contrôle - appliquer les commandes calculées pour les prochains pas de temps de simulation ```r ?CreateSupervisor ``` ## Exercice *Créer un superviseur avec un pas de temps de décision de 1 jour* -- ``` r sv <- CreateSupervisor(IM2) ``` --- # La fonction de logique de contrôle Elle prend en entrée, les mesures (`Y`) qui seront effectuées durant la simulation. Dans notre cas, la mesure principale correspondra au débit simulé à Rémouillé. Dans le cas où un soutien d'étiage est nécessaire, il faut savoir quelle part du débit de Rémouillé est déjà soutenu par le barrage. Le débit simulé au niveau du barrage sera nécessaire pour naturaliser le débit de Rémouillé et ainsi savoir combien ajouter pour le soutien. Le débit réservé est de 160 L/s et il faut soutenir l'étiage à Rémouillé de façon à avoir un débit minimum de 400 L/s. Le débit à lâcher peut être calculé comme suit. ``` r #' Fonction de logique pour un DOE de 400 L/s à Rémouillé #' @param Y [numeric] avec: #' - Y[1]: le débit simulé à Rémouillé (m3/j) #' - Y[2]: le débit simulé au barrage (m3/j) #' @return Le débit à lâcher au barrage (m3/j) logicFun <- function(Y) { Qnat <- Y[1] - Y[2] # Débit naturel à Rémouillé sans soutien U <- 0 # Commençons avec un soutien nul # Le soutien pour 400 L/s if (Qnat < 0.4 * 86400) U <- 0.4 * 86400 - Qnat # Respectons le débit réservé if (U < 0.16 * 86400) U <- 0.16 * 86400 return(U) } ``` --- # Création du contrôleur ```r ?CreateController ``` Le contrôleur est ajouté au superviseur et doit définir: - Son nom - La localisation des mesures `Y` - La localisation des commandes `U` - La fonction de logique de contrôle utilisée `FUN` ## Exercice *Créer le contrôleur de soutien d'étiage* -- ``` r CreateController(sv, "DOE", Y = c("Maine_Remouille", "Barrage_Bultiere"), U = "Barrage_Bultiere", FUN = logicFun) #> The controller 'DOE' has been added to the supervisor ``` --- ## Simulation avec superviseur ```r ?RunModel.Supervisor ``` ## Exercice *Lancer la simulation supervisée :)* -- ``` r OM3 <- RunModel(sv, RunOptions = RO2, Param = Params) #> Processing: 0% 10% 20% 30% 40% 50% 60% 70% 80% 90% 100% ``` --- # Visualisation du résultat au barrage ``` r plot(OM3$Barrage_Bultiere) ``` <img src="index_files/figure-html/plotBarrageSupervised-1.png" width="100%" style="display: block; margin: auto;" /> --- # Visualisation du résultat à Rémouillé *Traçons la chronique des débits simulés et comparons-la aux débits observés* ``` r plot(OM3$Maine_Remouille, Qobs = Q[I_Run, "Maine_Remouille"], #OM$Maine_Remouille$Qsim, BasinArea = g_bultiere$area[g_bultiere$id == "Maine_Remouille"], which = "Flows", log_scale = TRUE) ``` <img src="index_files/figure-html/plotFlowsRemouille-1.png" width="100%" style="display: block; margin: auto;" /> --- class: inverse, middle, center # Merci pour votre attention **airGRiwrm: 'airGR' Integrated Water Resource Management** **Documentation**: `https://airgriwrm.g-eau.fr` **Contact**: David Dorchies (david.dorchies@inrae.fr)