diff --git a/DESCRIPTION b/DESCRIPTION
index 35cdeb7272e1a273385e1381dc164522ba1f3756..da547bd32cd923b0edd284a345282bbb2868a3b2 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -1,8 +1,8 @@
 Package: airGR
 Type: Package
 Title: Suite of GR Hydrological Models for Precipitation-Runoff Modelling
-Version: 1.6.3.55
-Date: 2020-11-12
+Version: 1.6.3.56
+Date: 2020-11-16
 Authors@R: c(
   person("Laurent", "Coron", role = c("aut", "trl"), comment = c(ORCID = "0000-0002-1503-6204")),
   person("Olivier", "Delaigue", role = c("aut", "cre"), comment = c(ORCID = "0000-0002-7668-8468"), email = "airGR@inrae.fr"),
diff --git a/NEWS.md b/NEWS.md
index f0a82b7be6cc4b96716947c33a19efe2c0203e1a..d977dbc34fe07bd2894a6b1a383c67472aa54649 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -4,7 +4,7 @@
 
 
 
-### 1.6.3.55 Release Notes (2020-11-12)
+### 1.6.3.56 Release Notes (2020-11-16)
 
 #### New features
 
diff --git a/R/RunModel_GR2M.R b/R/RunModel_GR2M.R
index 14a2b8ff393fc4f1d04f554dcc57b6cd0a9327e3..90fd4488c9b452f66c7eec04bc8de4be1c68e1b0 100644
--- a/R/RunModel_GR2M.R
+++ b/R/RunModel_GR2M.R
@@ -7,13 +7,27 @@ RunModel_GR2M <- function(InputsModel, RunOptions, Param) {
   
   
   ## Arguments_check
-  if (inherits(InputsModel, "InputsModel") == FALSE) { stop("'InputsModel' must be of class 'InputsModel'") }  
-  if (inherits(InputsModel, "monthly"    ) == FALSE) { stop("'InputsModel' must be of class 'monthly'    ") }  
-  if (inherits(InputsModel, "GR"         ) == FALSE) { stop("'InputsModel' must be of class 'GR'         ") }  
-  if (inherits(RunOptions, "RunOptions"  ) == FALSE) { stop("'RunOptions' must be of class 'RunOptions'  ") }  
-  if (inherits(RunOptions, "GR"          ) == FALSE) { stop("'RunOptions' must be of class 'GR'          ") }  
-  if (!is.vector(Param) | !is.numeric(Param)) { stop("'Param' must be a numeric vector") }
-  if (sum(!is.na(Param)) != NParam) { stop(paste("'Param' must be a vector of length ", NParam, " and contain no NA", sep = "")) }
+  if (inherits(InputsModel, "InputsModel") == FALSE) {
+    stop("'InputsModel' must be of class 'InputsModel'")
+  }  
+  if (inherits(InputsModel, "monthly"    ) == FALSE) {
+    stop("'InputsModel' must be of class 'monthly'    ")
+  }  
+  if (inherits(InputsModel, "GR"         ) == FALSE) {
+    stop("'InputsModel' must be of class 'GR'         ")
+  }  
+  if (inherits(RunOptions, "RunOptions"  ) == FALSE) {
+    stop("'RunOptions' must be of class 'RunOptions'  ")
+  }  
+  if (inherits(RunOptions, "GR"          ) == FALSE) {
+    stop("'RunOptions' must be of class 'GR'          ")
+  }  
+  if (!is.vector(Param) | !is.numeric(Param)) {
+    stop("'Param' must be a numeric vector")
+  }
+  if (sum(!is.na(Param)) != NParam) {
+    stop(paste("'Param' must be a vector of length ", NParam, " and contain no NA", sep = ""))
+  }
   Param <- as.double(Param)
   
   Param_X1X2_threshold <- 1e-2
@@ -27,11 +41,16 @@ RunModel_GR2M <- function(InputsModel, RunOptions, Param) {
   }
   
   ## Input_data_preparation
-  if (identical(RunOptions$IndPeriod_WarmUp, as.integer(0))) { RunOptions$IndPeriod_WarmUp <- NULL }
+  if (identical(RunOptions$IndPeriod_WarmUp, as.integer(0))) {
+    RunOptions$IndPeriod_WarmUp <- NULL
+  }
   IndPeriod1   <- c(RunOptions$IndPeriod_WarmUp, RunOptions$IndPeriod_Run)
   LInputSeries <- as.integer(length(IndPeriod1))
-  if ("all" %in% RunOptions$Outputs_Sim) { IndOutputs <- as.integer(1:length(FortranOutputs)) 
-  } else { IndOutputs <- which(FortranOutputs %in% RunOptions$Outputs_Sim)  }
+  if ("all" %in% RunOptions$Outputs_Sim) {
+    IndOutputs <- as.integer(1:length(FortranOutputs)) 
+  } else {
+    IndOutputs <- which(FortranOutputs %in% RunOptions$Outputs_Sim)
+  }
   
   ## Output_data_preparation
   IndPeriod2     <- (length(RunOptions$IndPeriod_WarmUp)+1):LInputSeries
@@ -75,23 +94,27 @@ RunModel_GR2M <- function(InputsModel, RunOptions, Param) {
   ## OutputsModel_only
   if (ExportDatesR == FALSE & ExportStateEnd == FALSE) {
     OutputsModel <- lapply(seq_len(RESULTS$NOutputs), function(i) RESULTS$Outputs[IndPeriod2, i])
-    names(OutputsModel) <- FortranOutputs[IndOutputs]      }
+    names(OutputsModel) <- FortranOutputs[IndOutputs]
+  }
   ## DatesR_and_OutputsModel_only
   if (ExportDatesR == TRUE & ExportStateEnd == FALSE) {
     OutputsModel <- c( list(InputsModel$DatesR[RunOptions$IndPeriod_Run]), 
                        lapply(seq_len(RESULTS$NOutputs), function(i) RESULTS$Outputs[IndPeriod2, i]) )
-    names(OutputsModel) <- c("DatesR", FortranOutputs[IndOutputs])      }
+    names(OutputsModel) <- c("DatesR", FortranOutputs[IndOutputs])
+  }
   ## OutputsModel_and_SateEnd_only
   if (ExportDatesR == FALSE & ExportStateEnd == TRUE) {
     OutputsModel <- c( lapply(seq_len(RESULTS$NOutputs), function(i) RESULTS$Outputs[IndPeriod2, i]), 
                        list(RESULTS$StateEnd) )
-    names(OutputsModel) <- c(FortranOutputs[IndOutputs], "StateEnd")      }
+    names(OutputsModel) <- c(FortranOutputs[IndOutputs], "StateEnd")
+  }
   ## DatesR_and_OutputsModel_and_SateEnd
   if ((ExportDatesR==TRUE & ExportStateEnd==TRUE) | "all" %in% RunOptions$Outputs_Sim) {
     OutputsModel <- c( list(InputsModel$DatesR[RunOptions$IndPeriod_Run]), 
                        lapply(seq_len(RESULTS$NOutputs), function(i) RESULTS$Outputs[IndPeriod2, i]), 
                        list(RESULTS$StateEnd) )
-    names(OutputsModel) <- c("DatesR", FortranOutputs[IndOutputs], "StateEnd")      }
+    names(OutputsModel) <- c("DatesR", FortranOutputs[IndOutputs], "StateEnd")
+  }
   
   ## End
   rm(RESULTS) 
diff --git a/R/RunModel_GR4H.R b/R/RunModel_GR4H.R
index f43091b14f9302be43f02725e1be42777c261bd1..f323479f8a0f2231327bb320ceca591f056a7d21 100644
--- a/R/RunModel_GR4H.R
+++ b/R/RunModel_GR4H.R
@@ -7,13 +7,27 @@ RunModel_GR4H <- function(InputsModel, RunOptions, Param) {
   
   
   ## Arguments_check
-  if (inherits(InputsModel, "InputsModel") == FALSE) { stop("'InputsModel' must be of class 'InputsModel'") }  
-  if (inherits(InputsModel, "hourly"     ) == FALSE) { stop("'InputsModel' must be of class 'hourly'     ") }  
-  if (inherits(InputsModel, "GR"         ) == FALSE) { stop("'InputsModel' must be of class 'GR'         ") }  
-  if (inherits(RunOptions, "RunOptions"  ) == FALSE) { stop("'RunOptions' must be of class 'RunOptions'  ") }  
-  if (inherits(RunOptions, "GR"          ) == FALSE) { stop("'RunOptions' must be of class 'GR'          ") }  
-  if (!is.vector(Param) | !is.numeric(Param)) { stop("'Param' must be a numeric vector") }
-  if (sum(!is.na(Param)) != NParam) { stop(paste("'Param' must be a vector of length ", NParam, " and contain no NA", sep = "")) }
+  if (inherits(InputsModel, "InputsModel") == FALSE) {
+    stop("'InputsModel' must be of class 'InputsModel'")
+  }  
+  if (inherits(InputsModel, "hourly"     ) == FALSE) {
+    stop("'InputsModel' must be of class 'hourly'     ")
+  }  
+  if (inherits(InputsModel, "GR"         ) == FALSE) {
+    stop("'InputsModel' must be of class 'GR'         ")
+  }  
+  if (inherits(RunOptions, "RunOptions"  ) == FALSE) {
+    stop("'RunOptions' must be of class 'RunOptions'  ")
+  }  
+  if (inherits(RunOptions, "GR"          ) == FALSE) {
+    stop("'RunOptions' must be of class 'GR'          ")
+  }  
+  if (!is.vector(Param) | !is.numeric(Param)) {
+    stop("'Param' must be a numeric vector")
+  }
+  if (sum(!is.na(Param)) != NParam) {
+    stop(paste("'Param' must be a vector of length ", NParam, " and contain no NA", sep = ""))
+  }
   Param <- as.double(Param)
   
   Param_X1X3_threshold <- 1e-2
@@ -32,11 +46,16 @@ RunModel_GR4H <- function(InputsModel, RunOptions, Param) {
   }     
   
   ## Input_data_preparation
-  if (identical(RunOptions$IndPeriod_WarmUp, as.integer(0))) { RunOptions$IndPeriod_WarmUp <- NULL }
+  if (identical(RunOptions$IndPeriod_WarmUp, as.integer(0))) {
+    RunOptions$IndPeriod_WarmUp <- NULL
+  }
   IndPeriod1   <- c(RunOptions$IndPeriod_WarmUp, RunOptions$IndPeriod_Run)
   LInputSeries <- as.integer(length(IndPeriod1))
-  if ("all" %in% RunOptions$Outputs_Sim) { IndOutputs <- as.integer(1:length(FortranOutputs)) 
-  } else { IndOutputs <- which(FortranOutputs %in% RunOptions$Outputs_Sim)  }
+  if ("all" %in% RunOptions$Outputs_Sim) {
+    IndOutputs <- as.integer(1:length(FortranOutputs)) 
+  } else {
+    IndOutputs <- which(FortranOutputs %in% RunOptions$Outputs_Sim)
+  }
   
   ## Output_data_preparation
   IndPeriod2     <- (length(RunOptions$IndPeriod_WarmUp)+1):LInputSeries
@@ -80,23 +99,27 @@ RunModel_GR4H <- function(InputsModel, RunOptions, Param) {
   ## OutputsModel_only
   if (ExportDatesR == FALSE & ExportStateEnd == FALSE) {
     OutputsModel <- lapply(seq_len(RESULTS$NOutputs), function(i) RESULTS$Outputs[IndPeriod2, i])
-    names(OutputsModel) <- FortranOutputs[IndOutputs]      }
+    names(OutputsModel) <- FortranOutputs[IndOutputs]
+  }
   ## DatesR_and_OutputsModel_only
   if (ExportDatesR == TRUE & ExportStateEnd == FALSE) {
     OutputsModel <- c( list(InputsModel$DatesR[RunOptions$IndPeriod_Run]), 
                        lapply(seq_len(RESULTS$NOutputs), function(i) RESULTS$Outputs[IndPeriod2, i]) )
-    names(OutputsModel) <- c("DatesR", FortranOutputs[IndOutputs])      }
+    names(OutputsModel) <- c("DatesR", FortranOutputs[IndOutputs])
+  }
   ## OutputsModel_and_SateEnd_only
   if (ExportDatesR == FALSE & ExportStateEnd == TRUE) {
     OutputsModel <- c( lapply(seq_len(RESULTS$NOutputs), function(i) RESULTS$Outputs[IndPeriod2, i]), 
                        list(RESULTS$StateEnd) )
-    names(OutputsModel) <- c(FortranOutputs[IndOutputs], "StateEnd")      }
+    names(OutputsModel) <- c(FortranOutputs[IndOutputs], "StateEnd")
+  }
   ## DatesR_and_OutputsModel_and_SateEnd
   if ((ExportDatesR == TRUE & ExportStateEnd == TRUE) | "all" %in% RunOptions$Outputs_Sim) {
     OutputsModel <- c( list(InputsModel$DatesR[RunOptions$IndPeriod_Run]), 
                        lapply(seq_len(RESULTS$NOutputs), function(i) RESULTS$Outputs[IndPeriod2, i]), 
                        list(RESULTS$StateEnd) )
-    names(OutputsModel) <- c("DatesR", FortranOutputs[IndOutputs], "StateEnd")      }
+    names(OutputsModel) <- c("DatesR", FortranOutputs[IndOutputs], "StateEnd")
+  }
   
   ## End
   rm(RESULTS) 
diff --git a/R/RunModel_GR4J.R b/R/RunModel_GR4J.R
index 98973044a6e96409aeb3c3dec70c591d9cc5e336..58e7d163ce860bb110bad1862df33083c01e0edb 100644
--- a/R/RunModel_GR4J.R
+++ b/R/RunModel_GR4J.R
@@ -7,13 +7,27 @@ RunModel_GR4J <- function(InputsModel, RunOptions, Param) {
   
   
   ## Arguments_check
-  if (inherits(InputsModel, "InputsModel") == FALSE) { stop("'InputsModel' must be of class 'InputsModel'") }  
-  if (inherits(InputsModel, "daily"      ) == FALSE) { stop("'InputsModel' must be of class 'daily'      ") }  
-  if (inherits(InputsModel, "GR"         ) == FALSE) { stop("'InputsModel' must be of class 'GR'         ") }  
-  if (inherits(RunOptions, "RunOptions"  ) == FALSE) { stop("'RunOptions' must be of class 'RunOptions'  ") }  
-  if (inherits(RunOptions, "GR"          ) == FALSE) { stop("'RunOptions' must be of class 'GR'          ") }  
-  if (!is.vector(Param) | !is.numeric(Param)) { stop("'Param' must be a numeric vector") }
-  if (sum(!is.na(Param)) != NParam) { stop(paste("'Param' must be a vector of length ", NParam, " and contain no NA", sep = "")) }
+  if (inherits(InputsModel, "InputsModel") == FALSE) {
+    stop("'InputsModel' must be of class 'InputsModel'")
+  }  
+  if (inherits(InputsModel, "daily"      ) == FALSE) {
+    stop("'InputsModel' must be of class 'daily'      ")
+  }  
+  if (inherits(InputsModel, "GR"         ) == FALSE) {
+    stop("'InputsModel' must be of class 'GR'         ")
+  }  
+  if (inherits(RunOptions, "RunOptions"  ) == FALSE) {
+    stop("'RunOptions' must be of class 'RunOptions'  ")
+  }  
+  if (inherits(RunOptions, "GR"          ) == FALSE) {
+    stop("'RunOptions' must be of class 'GR'          ")
+  }  
+  if (!is.vector(Param) | !is.numeric(Param)) {
+    stop("'Param' must be a numeric vector")
+  }
+  if (sum(!is.na(Param)) != NParam) {
+    stop(paste("'Param' must be a vector of length ", NParam, " and contain no NA", sep = ""))
+  }
   Param <- as.double(Param)
   
   Param_X1X3_threshold <- 1e-2
@@ -32,11 +46,16 @@ RunModel_GR4J <- function(InputsModel, RunOptions, Param) {
   }
   
   ## Input_data_preparation
-  if (identical(RunOptions$IndPeriod_WarmUp, as.integer(0))) { RunOptions$IndPeriod_WarmUp <- NULL }
+  if (identical(RunOptions$IndPeriod_WarmUp, as.integer(0))) {
+    RunOptions$IndPeriod_WarmUp <- NULL
+  }
   IndPeriod1   <- c(RunOptions$IndPeriod_WarmUp, RunOptions$IndPeriod_Run)
   LInputSeries <- as.integer(length(IndPeriod1))
-  if ("all" %in% RunOptions$Outputs_Sim) { IndOutputs <- as.integer(1:length(FortranOutputs)) 
-  } else { IndOutputs <- which(FortranOutputs %in% RunOptions$Outputs_Sim)  }
+  if ("all" %in% RunOptions$Outputs_Sim) {
+    IndOutputs <- as.integer(1:length(FortranOutputs)) 
+  } else {
+    IndOutputs <- which(FortranOutputs %in% RunOptions$Outputs_Sim)
+  }
   ## Input_data_preparation      
   IndPeriod2     <- (length(RunOptions$IndPeriod_WarmUp)+1):LInputSeries
   ExportDatesR   <- "DatesR"   %in% RunOptions$Outputs_Sim
@@ -79,23 +98,27 @@ RunModel_GR4J <- function(InputsModel, RunOptions, Param) {
   ## OutputsModel_only
   if (ExportDatesR == FALSE & ExportStateEnd == FALSE) {
     OutputsModel <- lapply(seq_len(RESULTS$NOutputs), function(i) RESULTS$Outputs[IndPeriod2, i])
-    names(OutputsModel) <- FortranOutputs[IndOutputs]      }
+    names(OutputsModel) <- FortranOutputs[IndOutputs]
+  }
   ## DatesR_and_OutputsModel_only
   if (ExportDatesR == TRUE & ExportStateEnd == FALSE) {
     OutputsModel <- c( list(InputsModel$DatesR[RunOptions$IndPeriod_Run]), 
                        lapply(seq_len(RESULTS$NOutputs), function(i) RESULTS$Outputs[IndPeriod2, i]) )
-    names(OutputsModel) <- c("DatesR", FortranOutputs[IndOutputs])      }
+    names(OutputsModel) <- c("DatesR", FortranOutputs[IndOutputs])
+  }
   ## OutputsModel_and_StateEnd_only
   if (ExportDatesR == FALSE & ExportStateEnd == TRUE) {
     OutputsModel <- c( lapply(seq_len(RESULTS$NOutputs), function(i) RESULTS$Outputs[IndPeriod2, i]), 
                        list(RESULTS$StateEnd) )
-    names(OutputsModel) <- c(FortranOutputs[IndOutputs], "StateEnd")      }
+    names(OutputsModel) <- c(FortranOutputs[IndOutputs], "StateEnd")
+  }
   ## DatesR_and_OutputsModel_and_StateEnd
   if ((ExportDatesR == TRUE & ExportStateEnd == TRUE) | "all" %in% RunOptions$Outputs_Sim) {
     OutputsModel <- c( list(InputsModel$DatesR[RunOptions$IndPeriod_Run]), 
                        lapply(seq_len(RESULTS$NOutputs), function(i) RESULTS$Outputs[IndPeriod2, i]), 
                        list(RESULTS$StateEnd) )
-    names(OutputsModel) <- c("DatesR", FortranOutputs[IndOutputs], "StateEnd")      }
+    names(OutputsModel) <- c("DatesR", FortranOutputs[IndOutputs], "StateEnd")
+  }
   
   ## End
   rm(RESULTS) 
diff --git a/R/RunModel_GR5H.R b/R/RunModel_GR5H.R
index a09f8bf0e573665d9948c2f4ee399e048e7913dd..5afb287f1af6dfae9404ee04aa709c947a3c2b35 100644
--- a/R/RunModel_GR5H.R
+++ b/R/RunModel_GR5H.R
@@ -13,13 +13,27 @@ RunModel_GR5H <- function(InputsModel, RunOptions, Param) {
   
   
   ## Arguments_check
-  if (inherits(InputsModel, "InputsModel") == FALSE) { stop("'InputsModel' must be of class 'InputsModel'") }  
-  if (inherits(InputsModel, "hourly"     ) == FALSE) { stop("'InputsModel' must be of class 'hourly'     ") }  
-  if (inherits(InputsModel, "GR"         ) == FALSE) { stop("'InputsModel' must be of class 'GR'         ") }  
-  if (inherits(RunOptions, "RunOptions"  ) == FALSE) { stop("'RunOptions' must be of class 'RunOptions'  ") }  
-  if (inherits(RunOptions, "GR"          ) == FALSE) { stop("'RunOptions' must be of class 'GR'          ") }  
-  if (!is.vector(Param) | !is.numeric(Param)) { stop("'Param' must be a numeric vector") }
-  if (sum(!is.na(Param)) != NParam) { stop(paste("'Param' must be a vector of length ", NParam, " and contain no NA", sep = "")) }
+  if (inherits(InputsModel, "InputsModel") == FALSE) {
+    stop("'InputsModel' must be of class 'InputsModel'")
+  }  
+  if (inherits(InputsModel, "hourly"     ) == FALSE) {
+    stop("'InputsModel' must be of class 'hourly'     ")
+  }  
+  if (inherits(InputsModel, "GR"         ) == FALSE) {
+    stop("'InputsModel' must be of class 'GR'         ")
+  }  
+  if (inherits(RunOptions, "RunOptions"  ) == FALSE) {
+    stop("'RunOptions' must be of class 'RunOptions'  ")
+  }  
+  if (inherits(RunOptions, "GR"          ) == FALSE) {
+    stop("'RunOptions' must be of class 'GR'          ")
+  }  
+  if (!is.vector(Param) | !is.numeric(Param)) {
+    stop("'Param' must be a numeric vector")
+  }
+  if (sum(!is.na(Param)) != NParam) {
+    stop(paste("'Param' must be a vector of length ", NParam, " and contain no NA", sep = ""))
+  }
   Param <- as.double(Param)
   
   Param_X1X3_threshold <- 1e-2
@@ -38,11 +52,15 @@ RunModel_GR5H <- function(InputsModel, RunOptions, Param) {
   }     
   
   ## Input_data_preparation
-  if (identical(RunOptions$IndPeriod_WarmUp, as.integer(0))) { RunOptions$IndPeriod_WarmUp <- NULL }
+  if (identical(RunOptions$IndPeriod_WarmUp, as.integer(0))) {
+    RunOptions$IndPeriod_WarmUp <- NULL
+  }
   IndPeriod1   <- c(RunOptions$IndPeriod_WarmUp, RunOptions$IndPeriod_Run)
   LInputSeries <- as.integer(length(IndPeriod1))
   if ("all" %in% RunOptions$Outputs_Sim) { IndOutputs <- as.integer(1:length(FortranOutputs)) 
-  } else { IndOutputs <- which(FortranOutputs %in% RunOptions$Outputs_Sim)  }
+  } else {
+    IndOutputs <- which(FortranOutputs %in% RunOptions$Outputs_Sim)
+  }
   
   ## Output_data_preparation
   IndPeriod2     <- (length(RunOptions$IndPeriod_WarmUp)+1):LInputSeries
@@ -91,23 +109,27 @@ RunModel_GR5H <- function(InputsModel, RunOptions, Param) {
   ## OutputsModel_only
   if (ExportDatesR == FALSE & ExportStateEnd == FALSE) {
     OutputsModel <- lapply(seq_len(RESULTS$NOutputs), function(i) RESULTS$Outputs[IndPeriod2, i])
-    names(OutputsModel) <- FortranOutputs[IndOutputs]      }
+    names(OutputsModel) <- FortranOutputs[IndOutputs]
+  }
   ## DatesR_and_OutputsModel_only
   if (ExportDatesR == TRUE & ExportStateEnd == FALSE) {
     OutputsModel <- c( list(InputsModel$DatesR[RunOptions$IndPeriod_Run]), 
                        lapply(seq_len(RESULTS$NOutputs), function(i) RESULTS$Outputs[IndPeriod2, i]) )
-    names(OutputsModel) <- c("DatesR", FortranOutputs[IndOutputs])      }
+    names(OutputsModel) <- c("DatesR", FortranOutputs[IndOutputs])
+  }
   ## OutputsModel_and_StateEnd_only
   if (ExportDatesR == FALSE & ExportStateEnd == TRUE) {
     OutputsModel <- c( lapply(seq_len(RESULTS$NOutputs), function(i) RESULTS$Outputs[IndPeriod2, i]), 
                        list(RESULTS$StateEnd) )
-    names(OutputsModel) <- c(FortranOutputs[IndOutputs], "StateEnd")      }
+    names(OutputsModel) <- c(FortranOutputs[IndOutputs], "StateEnd")
+  }
   ## DatesR_and_OutputsModel_and_StateEnd
   if ((ExportDatesR == TRUE & ExportStateEnd == TRUE) | "all" %in% RunOptions$Outputs_Sim) {
     OutputsModel <- c( list(InputsModel$DatesR[RunOptions$IndPeriod_Run]), 
                        lapply(seq_len(RESULTS$NOutputs), function(i) RESULTS$Outputs[IndPeriod2, i]), 
                        list(RESULTS$StateEnd) )
-    names(OutputsModel) <- c("DatesR", FortranOutputs[IndOutputs], "StateEnd")      }
+    names(OutputsModel) <- c("DatesR", FortranOutputs[IndOutputs], "StateEnd")
+  }
   
   ## End
   rm(RESULTS) 
diff --git a/R/RunModel_GR5J.R b/R/RunModel_GR5J.R
index 60cd9fd9501ec0430230ab48a64bd55158de3762..5c2e81579efdafcbbb4ca1c4c552f02f2fa26ff8 100644
--- a/R/RunModel_GR5J.R
+++ b/R/RunModel_GR5J.R
@@ -7,13 +7,27 @@ RunModel_GR5J <- function(InputsModel, RunOptions, Param) {
   
   
   ## Arguments_check
-  if (inherits(InputsModel, "InputsModel") == FALSE) { stop("'InputsModel' must be of class 'InputsModel'") }  
-  if (inherits(InputsModel, "daily"      ) == FALSE) { stop("'InputsModel' must be of class 'daily'      ") }  
-  if (inherits(InputsModel, "GR"         ) == FALSE) { stop("'InputsModel' must be of class 'GR'         ") }  
-  if (inherits(RunOptions, "RunOptions"  ) == FALSE) { stop("'RunOptions' must be of class 'RunOptions'  ") }  
-  if (inherits(RunOptions, "GR"          ) == FALSE) { stop("'RunOptions' must be of class 'GR'          ") }  
-  if (!is.vector(Param) | !is.numeric(Param)) { stop("'Param' must be a numeric vector") }
-  if (sum(!is.na(Param)) != NParam) { stop(paste("'Param' must be a vector of length ", NParam, " and contain no NA", sep = "")) }
+  if (inherits(InputsModel, "InputsModel") == FALSE) {
+    stop("'InputsModel' must be of class 'InputsModel'")
+  }  
+  if (inherits(InputsModel, "daily"      ) == FALSE) {
+    stop("'InputsModel' must be of class 'daily'      ")
+  }  
+  if (inherits(InputsModel, "GR"         ) == FALSE) {
+    stop("'InputsModel' must be of class 'GR'         ")
+  }  
+  if (inherits(RunOptions, "RunOptions"  ) == FALSE) {
+    stop("'RunOptions' must be of class 'RunOptions'  ")
+  }  
+  if (inherits(RunOptions, "GR"          ) == FALSE) {
+    stop("'RunOptions' must be of class 'GR'          ")
+  }  
+  if (!is.vector(Param) | !is.numeric(Param)) {
+    stop("'Param' must be a numeric vector")
+  }
+  if (sum(!is.na(Param)) != NParam) {
+    stop(paste("'Param' must be a vector of length ", NParam, " and contain no NA", sep = ""))
+  }
   Param <- as.double(Param)
   
   Param_X1X3_threshold <- 1e-2
@@ -32,11 +46,16 @@ RunModel_GR5J <- function(InputsModel, RunOptions, Param) {
   }      
   
   ## Input_data_preparation
-  if (identical(RunOptions$IndPeriod_WarmUp, as.integer(0))) { RunOptions$IndPeriod_WarmUp <- NULL }
+  if (identical(RunOptions$IndPeriod_WarmUp, as.integer(0))) {
+    RunOptions$IndPeriod_WarmUp <- NULL
+  }
   IndPeriod1   <- c(RunOptions$IndPeriod_WarmUp, RunOptions$IndPeriod_Run)
   LInputSeries <- as.integer(length(IndPeriod1))
-  if ("all" %in% RunOptions$Outputs_Sim) { IndOutputs <- as.integer(1:length(FortranOutputs)) 
-  } else { IndOutputs <- which(FortranOutputs %in% RunOptions$Outputs_Sim)  }
+  if ("all" %in% RunOptions$Outputs_Sim) {
+    IndOutputs <- as.integer(1:length(FortranOutputs)) 
+  } else {
+    IndOutputs <- which(FortranOutputs %in% RunOptions$Outputs_Sim)
+  }
   
   ## Output_data_preparation
   IndPeriod2     <- (length(RunOptions$IndPeriod_WarmUp)+1):LInputSeries
@@ -80,23 +99,27 @@ RunModel_GR5J <- function(InputsModel, RunOptions, Param) {
   ## OutputsModel_only
   if (ExportDatesR == FALSE & ExportStateEnd == FALSE) {
     OutputsModel <- lapply(seq_len(RESULTS$NOutputs), function(i) RESULTS$Outputs[IndPeriod2, i])
-    names(OutputsModel) <- FortranOutputs[IndOutputs]      }
+    names(OutputsModel) <- FortranOutputs[IndOutputs]
+  }
   ## DatesR_and_OutputsModel_only
   if (ExportDatesR == TRUE & ExportStateEnd == FALSE) {
     OutputsModel <- c( list(InputsModel$DatesR[RunOptions$IndPeriod_Run]), 
                        lapply(seq_len(RESULTS$NOutputs), function(i) RESULTS$Outputs[IndPeriod2, i]) )
-    names(OutputsModel) <- c("DatesR", FortranOutputs[IndOutputs])      }
+    names(OutputsModel) <- c("DatesR", FortranOutputs[IndOutputs])
+  }
   ## OutputsModel_and_SateEnd_only
   if (ExportDatesR == FALSE & ExportStateEnd == TRUE) {
     OutputsModel <- c( lapply(seq_len(RESULTS$NOutputs), function(i) RESULTS$Outputs[IndPeriod2, i]), 
                        list(RESULTS$StateEnd) )
-    names(OutputsModel) <- c(FortranOutputs[IndOutputs], "StateEnd")      }
+    names(OutputsModel) <- c(FortranOutputs[IndOutputs], "StateEnd")
+  }
   ## DatesR_and_OutputsModel_and_SateEnd
   if ((ExportDatesR == TRUE & ExportStateEnd == TRUE) | "all" %in% RunOptions$Outputs_Sim) {
     OutputsModel <- c( list(InputsModel$DatesR[RunOptions$IndPeriod_Run]), 
                        lapply(seq_len(RESULTS$NOutputs), function(i) RESULTS$Outputs[IndPeriod2, i]), 
                        list(RESULTS$StateEnd) )
-    names(OutputsModel) <- c("DatesR", FortranOutputs[IndOutputs], "StateEnd")      }
+    names(OutputsModel) <- c("DatesR", FortranOutputs[IndOutputs], "StateEnd")
+  }
   
   ## End
   rm(RESULTS) 
diff --git a/R/RunModel_GR6J.R b/R/RunModel_GR6J.R
index f5df113b84d12843494c2d0e758cce55fafb925b..92042076bd40eafb97cc09d37485d2ff0d08a91c 100644
--- a/R/RunModel_GR6J.R
+++ b/R/RunModel_GR6J.R
@@ -7,13 +7,27 @@ RunModel_GR6J <- function(InputsModel, RunOptions, Param) {
   
   
   ## Arguments_check
-  if (inherits(InputsModel, "InputsModel") == FALSE) { stop("'InputsModel' must be of class 'InputsModel'") }  
-  if (inherits(InputsModel, "daily"      ) == FALSE) { stop("'InputsModel' must be of class 'daily'      ") }  
-  if (inherits(InputsModel, "GR"         ) == FALSE) { stop("'InputsModel' must be of class 'GR'         ") }  
-  if (inherits(RunOptions, "RunOptions"  ) == FALSE) { stop("'RunOptions' must be of class 'RunOptions'  ") }  
-  if (inherits(RunOptions, "GR"          ) == FALSE) { stop("'RunOptions' must be of class 'GR'          ") }  
-  if (!is.vector(Param) | !is.numeric(Param)) { stop("'Param' must be a numeric vector") }
-  if (sum(!is.na(Param)) != NParam) { stop(paste("'Param' must be a vector of length ", NParam, " and contain no NA", sep = "")) }
+  if (inherits(InputsModel, "InputsModel") == FALSE) {
+    stop("'InputsModel' must be of class 'InputsModel'")
+  }  
+  if (inherits(InputsModel, "daily"      ) == FALSE) {
+    stop("'InputsModel' must be of class 'daily'      ")
+  }  
+  if (inherits(InputsModel, "GR"         ) == FALSE) {
+    stop("'InputsModel' must be of class 'GR'         ")
+  }  
+  if (inherits(RunOptions, "RunOptions"  ) == FALSE) {
+    stop("'RunOptions' must be of class 'RunOptions'  ")
+  }  
+  if (inherits(RunOptions, "GR"          ) == FALSE) {
+    stop("'RunOptions' must be of class 'GR'          ")
+  }  
+  if (!is.vector(Param) | !is.numeric(Param)) {
+    stop("'Param' must be a numeric vector")
+  }
+  if (sum(!is.na(Param)) != NParam) {
+    stop(paste("'Param' must be a vector of length ", NParam, " and contain no NA", sep = ""))
+  }
   Param <- as.double(Param)
   
   Param_X1X3X6_threshold <- 1e-2
@@ -36,11 +50,16 @@ RunModel_GR6J <- function(InputsModel, RunOptions, Param) {
   }      
   
   ## Input_data_preparation
-  if (identical(RunOptions$IndPeriod_WarmUp, as.integer(0))) { RunOptions$IndPeriod_WarmUp <- NULL }
+  if (identical(RunOptions$IndPeriod_WarmUp, as.integer(0))) {
+    RunOptions$IndPeriod_WarmUp <- NULL
+  }
   IndPeriod1   <- c(RunOptions$IndPeriod_WarmUp, RunOptions$IndPeriod_Run)
   LInputSeries <- as.integer(length(IndPeriod1))
-  if ("all" %in% RunOptions$Outputs_Sim) { IndOutputs <- as.integer(1:length(FortranOutputs)) 
-  } else { IndOutputs <- which(FortranOutputs %in% RunOptions$Outputs_Sim)  }
+  if ("all" %in% RunOptions$Outputs_Sim) {
+    IndOutputs <- as.integer(1:length(FortranOutputs)) 
+  } else {
+    IndOutputs <- which(FortranOutputs %in% RunOptions$Outputs_Sim)
+  }
   
   ## Output_data_preparation
   IndPeriod2     <- (length(RunOptions$IndPeriod_WarmUp)+1):LInputSeries
@@ -85,23 +104,27 @@ RunModel_GR6J <- function(InputsModel, RunOptions, Param) {
   ## OutputsModel_only
   if (ExportDatesR == FALSE & ExportStateEnd == FALSE) {
     OutputsModel <- lapply(seq_len(RESULTS$NOutputs), function(i) RESULTS$Outputs[IndPeriod2, i])
-    names(OutputsModel) <- FortranOutputs[IndOutputs]      }
+    names(OutputsModel) <- FortranOutputs[IndOutputs]
+  }
   ## DatesR_and_OutputsModel_only
   if (ExportDatesR == TRUE & ExportStateEnd == FALSE) {
     OutputsModel <- c( list(InputsModel$DatesR[RunOptions$IndPeriod_Run]), 
                        lapply(seq_len(RESULTS$NOutputs), function(i) RESULTS$Outputs[IndPeriod2, i]) )
-    names(OutputsModel) <- c("DatesR", FortranOutputs[IndOutputs])      }
+    names(OutputsModel) <- c("DatesR", FortranOutputs[IndOutputs])
+  }
   ## OutputsModel_and_SateEnd_only
   if (ExportDatesR == FALSE & ExportStateEnd == TRUE) {
     OutputsModel <- c( lapply(seq_len(RESULTS$NOutputs), function(i) RESULTS$Outputs[IndPeriod2, i]), 
                        list(RESULTS$StateEnd) )
-    names(OutputsModel) <- c(FortranOutputs[IndOutputs], "StateEnd")      }
+    names(OutputsModel) <- c(FortranOutputs[IndOutputs], "StateEnd")
+  }
   ## DatesR_and_OutputsModel_and_SateEnd
   if ((ExportDatesR == TRUE & ExportStateEnd == TRUE) | "all" %in% RunOptions$Outputs_Sim) {
     OutputsModel <- c( list(InputsModel$DatesR[RunOptions$IndPeriod_Run]), 
                        lapply(seq_len(RESULTS$NOutputs), function(i) RESULTS$Outputs[IndPeriod2, i]), 
                        list(RESULTS$StateEnd) )
-    names(OutputsModel) <- c("DatesR", FortranOutputs[IndOutputs], "StateEnd")      }
+    names(OutputsModel) <- c("DatesR", FortranOutputs[IndOutputs], "StateEnd")
+  }
   
   ## End
   rm(RESULTS)