wolfhece 2.1.127__py3-none-any.whl → 2.1.129__py3-none-any.whl

wolfhece/eikonal.py

@@ -153,7 +153,8 @@ def _solve_eikonal_with_data(sources:list[tuple[int,int]],
     assert test_data.shape == where_compute.shape
 
     if len(sources) == 0:
-        raise ValueError("No sources provided.")
+        logging.error("No sources provided")
+        return np.zeros((rows, cols))
 
     if speed is None:
         speed = np.ones((rows, cols))
@@ -195,6 +196,9 @@ def _process_submatrix(args):
     labels[0,:] = -1
     labels[-1,:] = -1
     sources = np.argwhere(np.logical_and(labels == 0, base_data != NoData))
+
+    if len(sources) == 0:
+        return (None, None)
     return (args, _solve_eikonal_with_data(sources, where_compute, base_data, test_data, speed, dx, dy))
 
 def _solve_eikonal_with_value_on_submatrices(where_compute:np.ndarray,
@@ -269,6 +273,8 @@ def _solve_eikonal_with_value_on_submatrices(where_compute:np.ndarray,
 
         time = np.zeros_like(where_compute)
         for slice, (sub, result) in zip(patch_slices, results):
+            if result is None:
+                continue
             useful_result = sub[3] != NoDataValue
             base_data[slice][useful_result] = sub[3][useful_result]
             time[slice][useful_result] = result[useful_result]
@@ -284,6 +290,8 @@ def _solve_eikonal_with_value_on_submatrices(where_compute:np.ndarray,
 
         time = np.zeros_like(where_compute)
         for slice, (sub, result) in zip(patch_slices, results):
+            if result is None:
+                continue
             useful_result = result != NoDataValue
             time[slice][useful_result] = result[useful_result]
 
@@ -378,7 +386,8 @@ def inpaint_waterlevel(water_level:np.ndarray | np.ma.MaskedArray,
                        inplace:bool = True,
                        dx:float = 1., dy:float = 1.,
                        NoDataValue:float = 0.,
-                       multiprocess:bool = True) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+                       multiprocess:bool = True,
+                       epsilon:float = 1e-3) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
     """ Inpaint the water level using the Fast Marching Method (FMM). Similar to the HOLES.EXE Fortran program.
 
     Assumptions:
@@ -452,9 +461,10 @@ def inpaint_waterlevel(water_level:np.ndarray | np.ma.MaskedArray,
     buildings[buildings < 0.] = 0.
 
     # If DTM is below DEM, we set the value to 1
+    buildings[buildings <= epsilon] = 0.
     buildings[buildings > 0.] = 1.
 
-    # We interplate only if building cells are not already in the water_level
+    # We interpolate only if building cells are not already in the water_level
     comp = np.logical_and(buildings == 1., base_data != NoDataValue)
     if np.any(comp):
         logging.warning("Some building cells are already flooded.")

wolfhece/hydrology/Catchment.py

@@ -67,7 +67,8 @@ class Catchment:
     iP_Cloud:cloud_vertices                                                 # cloud of points containing the given coordinates (given in param files) of all subbasin outlets
 
     catchmentDict:dict[Union[str, int], Union[SubBasin, RetentionBasin]]    # dictionnary containing all the elements of the catchment
-    subBasinDict:dict[int, SubBasin]                                        # dictionnary containing all the subbasins
+    subBasinDict:dict[int, SubBasin]                                        # dictionnary containing all the subbasins with the convention dict{ID Interior Point : SubBasin object}
+    retentionBasinDict:dict[str, RetentionBasin]                            # dictionnary containing all the anthropogenic modules
 
     def __init__(self, _name, _workingDir, _plotAllSub, _plotNothing, _initWithResults=True, _catchmentFileName="", _rbFileName="", _tz=0, version=cst.VERSION_WOLFHYDRO):
         "This is the constructor of the class Catchment in which all the caractertics and the network of sub-basins will be created"
@@ -143,7 +144,7 @@ class Catchment:
 
         # Read the input files
         # read the Main File
-        self.paramsInput = Wolf_Param(to_read=False,toShow=False)
+        self.paramsInput = Wolf_Param(to_read=False, toShow=False)
         self.paramsInput.ReadFile(os.path.join(self.workingDir,'Main_model.param'))
         # Get the version of WOLFHydro
         self.change_version(self.paramsInput.get_param("General information", "Version WOLFHydo"))
@@ -343,7 +344,7 @@ class Catchment:
         self._fill_cloud_retentionbasin()
 
     def get_subBasin(self, id_sorted_or_name:int | str) -> SubBasin:
-        """ 
+        """
         This method returns the subbasin object associated with the sorted id or name given in argument.
 
         The sorted id is the one given by the Fortran code.
@@ -620,7 +621,7 @@ class Catchment:
 
     def get_retentionbasin_zones(self)-> Zones:
         """ This method returns a Zones instance of the retention basins. """
-        
+
         zones = Zones()
         for curRB in self.retentionBasinDict.values():
             curRB:RetentionBasin
@@ -1390,6 +1391,75 @@ class Catchment:
         writer.close()
 
 
+
+    def save_hydro_for_2D(self, fileName:str="Hydros_2_simul2D.txt", directory:str="", format:str='%1.5e'):
+        """
+        Procedure that saves the data in an text file that can be read and used in a 2D model.
+
+        Args:
+            fileName (str, optional): The name of the file to save the data to. Defaults to "Hydros_2_simul2D.txt".
+            directory (str, optional): The directory to save the file in. Defaults to an empty string.
+
+        Returns:
+            None
+        """
+        # Writes subbasins' hydrographs
+        if(directory==""):
+            directory = join(self.workingDir,"PostProcess")
+
+        cur_file = join(directory,fileName)
+        time = np.reshape(self.time - self.time[0],(len(self.time),1))
+        # Extract the data for the hydrological and anthropogenic modules
+        data_subs = [cur_sub.outFlow for cur_sub in sorted(self.subBasinDict.values(), key=lambda sub: sub.iDSorted)]
+        data_anth = [cur_anth.get_outFlow(whichOutFlow=name) for cur_anth in self.retentionBasinDict.values() for name in cur_anth.get_outFlow_names()]
+        # Extract the column names according to their sorted subbasin indices
+        col_time = ["Time [s]"]
+        col_subs = [cur_sub.name for cur_sub in sorted(self.subBasinDict.values(), key=lambda sub: sub.iDSorted)]
+        col_anth = [" : ".join([cur_anth.name, name]) 
+                    for cur_anth in self.retentionBasinDict.values() 
+                    for name in cur_anth.get_outFlow_names()]
+        
+        
+        all_data = np.concatenate((time, np.array(data_subs).T, np.array(data_anth).T), axis=1)
+        all_columns = "\t".join(col_time+col_subs+col_anth)
+        
+        # Save the data in a text file
+        np.savetxt(cur_file, all_data, delimiter='\t', newline="\n", header=all_columns, fmt=format)
+
+
+    def save_own_hydro_for_2D(self, fileName:str="HydrosSub_2_simul2D.txt", directory:str="", format:str='%1.5e'):
+        """
+        Saves subbasins' hydrographs from their own drained surface only (not taking into account the 
+        surface drained by the inlets or upstream elements) to a text file that can be read and used in a 2D model.
+
+        Args:
+            fileName (str, optional): Name of the output file. Defaults to "HydrosSub_2_simul2D.txt".
+            directory (str, optional): Directory where the file will be saved. Defaults to an empty string.
+            format (str, optional): Format string for the data values. Defaults to '%1.5e'.
+
+        Returns:
+            None
+        """
+        # Writes subbasins' hydrographs
+        if(directory==""):
+            directory = join(self.workingDir,"PostProcess")
+
+        cur_file = join(directory,fileName)
+        time = np.reshape(self.time - self.time[0],(len(self.time),1))
+        # Extract the data for the hydrological and anthropogenic modules
+        data_subs = [cur_sub.get_myHydro(unit="m3/s") for cur_sub in sorted(self.subBasinDict.values(), key=lambda sub: sub.iDSorted)]
+        # Extract the column names according to their sorted subbasin indices
+        col_time = ["Time [s]"]
+        col_subs = [cur_sub.name for cur_sub in sorted(self.subBasinDict.values(), key=lambda sub: sub.iDSorted)]
+        
+        
+        all_data = np.concatenate((time, np.array(data_subs).T), axis=1)
+        all_columns = "\t".join(col_time+col_subs)
+        
+        # Save the data in a text file
+        np.savetxt(cur_file, all_data, delimiter='\t', newline="\n", header=all_columns, fmt=format)
+
+
     def save_characteristics(self):
         "Procedure that saves the data in an Excel file."
         # Writes subbasins' main characteristics
@@ -1858,7 +1928,7 @@ class Catchment:
                 paramsInput.SavetoFile(None)
 
     
-    def _correct_Umax_from_old_model(self, adapt_with_rain:bool=True):
+    def _correct_Umax_from_old_model(self, adapt_with_rain:bool=True, k_opt:float=0.0, U_max_opt=0.0):
         fileName = "simul_soil.param"
         which="Umax"
 
@@ -1871,7 +1941,9 @@ class Catchment:
             paramsInput = Wolf_Param(to_read=False,toShow=False)
             paramsInput.ReadFile(fileToModif)
             
-            if adapt_with_rain:
+            if U_max_opt>0.0:
+                maxRain = U_max_opt
+            elif adapt_with_rain:
                 myInterval = paramsInput.get_param("Distributed production model parameters", "Time span soil", default_value=0.0)
                 if myInterval==0.0:
                     nbIntervals = len(myBasin.myRain)-1
@@ -1885,9 +1957,12 @@ class Catchment:
                 if maxRain==0.0:
                     logging.warning("The Umax is not adapted with the rain and its value is 0.0. It might be better to put 'adapt_with_rain' to True.")
 
-            k = paramsInput.get_param("Horton parameters", "k", default_value=0.0)
-            if k==0.0:
-                continue
+            if k_opt==0.0:
+                k = paramsInput.get_param("Horton parameters", "k", default_value=0.0)
+                if k==0.0:
+                    continue
+            else:
+                k = k_opt
             
             U_max = maxRain/k
 
@@ -1899,7 +1974,7 @@ class Catchment:
 
 
 
-    def plot_all_diff_cumulRain_with_lagtime(self, interval, lagTime, selection_by_iD=[], graph_title="", show=True, writeDir="", lawNetRain=0, netRainParams={}):
+    def plot_all_diff_cumulRain_with_lagtime(self, interval=0, lagTime=0, selection_by_iD=[], graph_title="", show=True, writeDir="", lawNetRain=0, netRainParams={}):
         """
 
         """
@@ -1951,7 +2026,7 @@ class Catchment:
             isOk, directory = check_path(directory, self.workingDir)
             if isOk<0:
                 logging.error(_("ERROR : measuring station data path not present! "))
-            fileName = os.path.join(directory, self.paramsInput.get_param("Measuring stations SPW", "Filename")) 
+            fileName = os.path.join(directory, self.paramsInput.get_param("Measuring stations SPW", "Filename"))
 
 
         if os.path.exists(fileName):
@@ -2305,11 +2380,11 @@ class Catchment:
 
 
         return timeDelays
-    
+
 
     def get_timeDelays_inlets(self, ref:str = "") -> dict[str, float]:
-        
-        
+
+
         if(ref==""):
             junctionKey = self.junctionOut
         else:
@@ -2317,7 +2392,7 @@ class Catchment:
             if junctionKey is None:
                 logging.error("ERROR : Wrong reference to extract timeDelay !")
                 return
-        
+
         junctionKey = self.junctionOut
         refObj = self.catchmentDict[junctionKey]
         time_delays_inlets = refObj.get_timeDelays_inlets()
@@ -2535,14 +2610,14 @@ class Catchment:
         if self.charact_watrshd.to_update_times:
             self.charact_watrshd.update_times(self.time_wolf_array)
 
-    
+
     def get_all_x_production(self, selection_by_iD: list = [], to_save:bool=True, to_plot:bool=False) -> dict:
         """
         Retrieves the x production values for all sub-basins or a specific selection of sub-basins.
 
         Args:
-            selection_by_iD (list, optional): A list of sub-basin IDs to retrieve x production values for. 
-                                              If empty, retrieves x production values for all sub-basins. 
+            selection_by_iD (list, optional): A list of sub-basin IDs to retrieve x production values for.
+                                              If empty, retrieves x production values for all sub-basins.
                                               Defaults to [].
 
         Returns:
@@ -2560,23 +2635,23 @@ class Catchment:
                 cur_key = self.get_key_catchmentDict(curID)
                 curBasin: SubBasin = self.catchmentDict[cur_key]
                 all_x[curID] = curBasin.collect_x_from_production()
-        
+
         if to_save:
             rd.write_excel_from_dict(all_x, path=self.workingDir, fileName="PostProcess/all_x.xlsx", time=self.time)
 
         return all_x
-    
 
-    def get_all_fractions(self, plt_dict:dict[str:np.array]={},selection_by_iD: list = [], 
+
+    def get_all_fractions(self, plt_dict:dict[str:np.array]={},selection_by_iD: list = [],
                           to_save:bool=True, to_plot:bool=False,
-                          summary:str=None, summary_interval:list[datetime.datetime]=None, 
+                          summary:str=None, summary_interval:list[datetime.datetime]=None,
                           add_info:dict[dict[str,float]]={}) -> dict:
         """
         Retrieves the physical flux fractions values for all sub-basins or a specific selection of sub-basins.
 
         Args:
-            selection_by_iD (list, optional): A list of sub-basin IDs to retrieve fractions values for. 
-                                              If empty, retrieves fractions values for all sub-basins. 
+            selection_by_iD (list, optional): A list of sub-basin IDs to retrieve fractions values for.
+                                              If empty, retrieves fractions values for all sub-basins.
                                               Defaults to [].
 
         Returns:
@@ -2598,7 +2673,7 @@ class Catchment:
             summary_fractions = {}
             summary_dict = {}
             if selection_by_iD == []:
-                summary_fractions = {curBasin.name: curBasin.get_summary_fractions(summary=summary, interval=summary_interval) 
+                summary_fractions = {curBasin.name: curBasin.get_summary_fractions(summary=summary, interval=summary_interval)
                                      for curBasin in self.subBasinDict.values()}
             else:
                 for curID in selection_by_iD:
@@ -2628,9 +2703,9 @@ class Catchment:
                         else:
                             summary_dict[key_add].append(np.nan)
 
-                            
 
-            # summary_dict = {cur_key: [cur_dict[cur_key] for cur_dict in summary_fractions.values() if cur_key in cur_dict] 
+
+            # summary_dict = {cur_key: [cur_dict[cur_key] for cur_dict in summary_fractions.values() if cur_key in cur_dict]
             #                 for cur_dict in summary_fractions.values() for cur_key in cur_dict}
             # all_fractions["Summary"] = summary_dict
 
@@ -2641,7 +2716,7 @@ class Catchment:
             self.plot_all_fractions(all_fractions)
 
         return all_fractions
-        
+
 
     def plot_all_fractions(self, all_fractions:dict[str:np.array]={}, selection_by_iD:list=[], to_show:bool=False, writeDir:str="", range_data:list[datetime.datetime]=[]):
 
@@ -2655,7 +2730,7 @@ class Catchment:
             for curID in selection_by_iD:
                 cur_key = self.get_key_catchmentDict(curID)
                 curBasin: SubBasin = self.catchmentDict[cur_key]
-                curBasin.plot_all_fractions(to_show=False, writeDir=writeDir, range_data=range_data) 
+                curBasin.plot_all_fractions(to_show=False, writeDir=writeDir, range_data=range_data)
 
         if to_show:
             plt.show()
@@ -2667,8 +2742,8 @@ class Catchment:
         Retrieves the x production values for all sub-basins or a specific selection of sub-basins.
 
         Args:
-            selection_by_iD (list, optional): A list of sub-basin IDs to retrieve x production values for. 
-                                              If empty, retrieves x production values for all sub-basins. 
+            selection_by_iD (list, optional): A list of sub-basin IDs to retrieve x production values for.
+                                              If empty, retrieves x production values for all sub-basins.
                                               Defaults to [].
 
         Returns:
@@ -2691,15 +2766,15 @@ class Catchment:
             rd.write_excel_from_dict(all_iv, path=self.workingDir, fileName="PostProcess/all_iv.xlsx", time=self.time)
 
         return all_iv
-    
-    
+
+
     def activate_all_internal_variables(self, selection_by_iD: list = [])->dict:
         """
         Activates all internal variables for all sub-basins or a specific selection of sub-basins.
 
         Args:
-            selection_by_iD (list, optional): A list of sub-basin IDs to activate internal variables for. 
-                                              If empty, activates internal variables for all sub-basins. 
+            selection_by_iD (list, optional): A list of sub-basin IDs to activate internal variables for.
+                                              If empty, activates internal variables for all sub-basins.
                                               Defaults to [].
 
         Returns:
@@ -2722,8 +2797,8 @@ class Catchment:
         Checks the presence of internal variables for all sub-basins or a specific selection of sub-basins.
 
         Args:
-            selection_by_iD (list, optional): A list of sub-basin IDs to check the presence of internal variables for. 
-                                              If empty, checks the presence of internal variables for all sub-basins. 
+            selection_by_iD (list, optional): A list of sub-basin IDs to check the presence of internal variables for.
+                                              If empty, checks the presence of internal variables for all sub-basins.
                                               Defaults to [].
 
         Returns:
@@ -2743,7 +2818,7 @@ class Catchment:
                 all_x[curID] = curBasin.check_presence_of_iv()
 
         return all_x
-    
+
 
     def get_all_Qtest(self, selection_by_iD: list = [], nb_atttempts:int=-1) :
 
@@ -2755,17 +2830,17 @@ class Catchment:
             #     curBasin: SubBasin = self.catchmentDict[cur_key]
             #     q_test = curBasin.get_all_Qtest(nb_atttempts)
             q_test = [
-                self.catchmentDict[self.get_key_catchmentDict(curID)].get_all_Qtest(nb_atttempts) 
+                self.catchmentDict[self.get_key_catchmentDict(curID)].get_all_Qtest(nb_atttempts)
                 for curID in selection_by_iD ]
 
         return q_test
-    
+
 
     def _get_simulation_intervals(self):
         """
         This procedure is getting the simulation intervals of the current module.
         """
-        
+
         nb_interv = self.paramsInput.get_param("Simulation intervals", "Nb", default_value=0)
         simulation_intervals = []
         for i in range(1, nb_interv+1):
@@ -2776,18 +2851,18 @@ class Catchment:
             simulation_intervals.append((di,df))
 
         return simulation_intervals
-    
+
 
     def _set_simulation_intervals(self, simulation_intervals:list[tuple[datetime.datetime,datetime.datetime]]):
         """
         This procedure is setting the simulation intervals of the current module.
         """
-        
+
         self.paramsInput.change_param("Simulation intervals", "Nb", len(simulation_intervals))
         for i, interval in enumerate(simulation_intervals):
             self.paramsInput.change_param("Simulation intervals", "Date begin "+str(i+1), interval[0].strftime(cst.DATE_FORMAT_HYDRO))
             self.paramsInput.change_param("Simulation intervals", "Date end "+str(i+1), interval[1].strftime(cst.DATE_FORMAT_HYDRO))
-        
+
         self.paramsInput.SavetoFile(None)
         self.paramsInput.Reload(None)
 
@@ -2795,7 +2870,7 @@ class Catchment:
     @property
     def simulation_intervals(self) ->list[tuple[datetime.datetime,datetime.datetime]]:
         return self._get_simulation_intervals()
-    
+
 
     @simulation_intervals.setter
     def simulation_intervals(self, value:list[tuple[datetime.datetime,datetime.datetime]]):
@@ -2806,35 +2881,61 @@ class Catchment:
         """
         This procedure is getting the temporal parameters of the current module.
         """
-        
+
         return (self.dateBegin, self.dateEnd)
-    
-    
+
+
     def _set_temporal_parameters(self, simulation_intervals:tuple[datetime.datetime,datetime.datetime]):
         """
         This procedure is setting the temporal parameters of the current module.
         """
-        
+
         self.dateBegin = simulation_intervals[0]
         self.dateEnd = simulation_intervals[1]
 
         self.paramsInput.change_param("Temporal Parameters", "Start date time", self.dateBegin.strftime(cst.DATE_FORMAT_HYDRO))
         self.paramsInput.change_param("Temporal Parameters", "End date time", self.dateEnd.strftime(cst.DATE_FORMAT_HYDRO))
-        
+
         self.paramsInput.SavetoFile(None)
         self.paramsInput.Reload(None)
 
-    
+
     @property
     def temporal_parameters(self) ->tuple[datetime.datetime, datetime.datetime]:
         return self._get_temporal_parameters()
-    
+
 
     @temporal_parameters.setter
     def temporal_parameters(self, value:tuple[datetime.datetime,datetime.datetime]):
         self._set_temporal_parameters(value)
 
 
+    def _set_IC_qif(self, keys:list[str], values:np.ndarray):
+        assert len(keys) == len(values), "The number of keys should be equal to the number of values !"
+        # assert len(keys) == len(self.subBasinDict), "The number of keys should be equal to the number of sub-basins !"
+        # assert len(values) == len(self.subBasinDict), "The number of values should be equal to the number of sub-basins !"
+        fileName = "simul_if.param"
+        group = "Initial conditions"
+        key = "Outflow"
+
+        for iBasin in range(1,len(self.subBasinDict)+1):
+            if self.subBasinDict[iBasin].name in keys:
+                index = np.where(np.array(keys) == self.subBasinDict[iBasin].name)[0][0]
+            else:
+                logging.warning(f"The sub-basin {self.subBasinDict[iBasin].name} is not in the keys list !")
+                continue
+            myBasin = self.subBasinDict[iBasin]
+            dirID = myBasin.iDSorted
+
+            fileToModif = os.path.join(self.workingDir, "Subbasin_" + str(dirID), fileName)
+
+            paramsInput = Wolf_Param(to_read=False,toShow=False)
+            paramsInput.ReadFile(fileToModif)
+            paramsInput.change_param(group, key, values[index])
+            paramsInput.SavetoFile(None)
+            paramsInput.Reload(None)
+        
+
     def make_nd_array(self, c_pointer, shape, dtype=np.float64, order='C', own_data=True,readonly=False):
         arr_size = np.prod(shape[:]) * np.dtype(dtype).itemsize
 

wolfhece/hydrology/Comparison.py

@@ -419,10 +419,10 @@ class Comparison:
             tzPlot = plotDict["General Parameters"]["Time Zone Plot"]
             tzDelta = datetime.timedelta(hours=tzPlot)
 
-        if(envelop and not("Ref Name" in plotDict["General Parameters"])):
-            refName = "Catchment 1"
-        else:
-            refName = plotDict["General Parameters"]["Ref Name"]
+        # if(envelop and not("Ref Name" in plotDict["General Parameters"])):
+        #     refName = "Catchment 1"
+        # else:
+        #     refName = plotDict["General Parameters"]["Ref Name"]
 
         if(not("Add Table" in plotDict["General Parameters"])):
             addTable = False
@@ -524,7 +524,7 @@ class Comparison:
             yLabels = []
             if(not("Catchment traits" in plotDict["General Parameters"])):
                 myTraits = []
-            rain = []
+            rain = None
             z = []
             nbAddRain=0
             y_labelAddRain = []
@@ -721,7 +721,7 @@ class Comparison:
                             myTraits.append('-')
 
                         if(sameRain and displayRain):
-                            if(rain==[]):
+                            if(rain is None):
                                 rain = curCatch.subBasinDict[id].rain/curCatch.subBasinDict[id].surfaceDrainedHydro*3.6
                         elif(displayRain):
                             upperPlot = True
@@ -748,7 +748,7 @@ class Comparison:
                             myTraits.append('-')
 
                         if(sameRain and displayRain):
-                            if(rain==[]):
+                            if(rain is None):
                                 rain = curCatch.subBasinDict[id].rain/curCatch.subBasinDict[id].surfaceDrainedHydro*3.6
                         elif(displayRain):
                             upperPlot = True
@@ -801,7 +801,7 @@ class Comparison:
             if("Measures" in plotDict[basinNames[id]]):
                 Measures = plotDict[basinNames[id]]["Measures"]
                 myMeasure = Measures.myHydro
-                yLabels.append(_("Measures"))
+                yLabels.append(_("Measurement"))
                 catchColorsAddData.append('k')
                 myTraits.append('-')
                 if(Measures.surfaceDrainedHydro>0.0):
@@ -904,6 +904,11 @@ class Comparison:
         else:
             dt = plotDict["General Parameters"]["Dt"]
 
+        if(not("Add Table" in plotDict["General Parameters"])):
+            addTable = False
+        else:
+            addTable = plotDict["General Parameters"]["Add Table"]
+
         # if(envelop and not("Ref Name" in plotDict["General Parameters"])):
         #     refName = "Catchment 1"
 
@@ -1029,7 +1034,7 @@ class Comparison:
             if("Measures" in plotDict[RBNames[id]]):
                 Measures = plotDict[RBNames[id]]["Measures"]
                 myMeasure = Measures.myHydro
-                yLabels.append(_("Measures"))
+                yLabels.append(_("Measurement"))
                 catchColorsAddData.append('k')
                 myTraits.append('--')
             else:
@@ -1052,15 +1057,17 @@ class Comparison:
 
 
             # Plot Rains
-            yTitles = "Hauteurs d'eau [m]"
-            writeFileDef = writeFile + "_H_" + graph_title.replace(".","")
+            yTitles = _("Water level [m]")
+            writeFileDef = os.path.join(writeFile, "H_" + graph_title.replace(".",""))
             if(Measures is not None):
                 ph.plot_hydro(nbCatchment+nbAddData, y1,x_title=x_title, y_titles=yTitles, beginDate=beginDateRB+beginDateAddData,endDate=endDateRB+endDateAddData,dt=dt+dtAddData,graph_title=graph_title, \
                             y_labels=yLabels,rangeData=xRange,y_data_range=yRange,myColors=catchColors+catchColorsAddData,typeOfTraits=myTraits,writeFile=writeFileDef,\
-                            measures=myMeasure,beginDateMeasure=Measures.dateBegin+tzDelta, endDateMeasure=Measures.dateEnd+tzDelta,dtMeasure=Measures.deltaT,deltaMajorTicks=86400/2.0,deltaMinorTicks=3600)
+                            measures=myMeasure,beginDateMeasure=Measures.dateBegin+tzDelta, endDateMeasure=Measures.dateEnd+tzDelta,dtMeasure=Measures.deltaT,deltaMajorTicks=86400/2.0,deltaMinorTicks=3600,
+                            addTable=addTable)
             else:
                 ph.plot_hydro(nbCatchment+nbAddData, y1,x_title=x_title, y_titles=yTitles, beginDate=beginDateRB+beginDateAddData,endDate=endDateRB+endDateAddData,dt=dt+dtAddData,graph_title=graph_title, \
-                            y_labels=yLabels,rangeData=xRange,y_data_range=yRange,myColors=catchColors+catchColorsAddData,typeOfTraits=myTraits,writeFile=writeFileDef,deltaMajorTicks=86400/2.0,deltaMinorTicks=3600)
+                            y_labels=yLabels,rangeData=xRange,y_data_range=yRange,myColors=catchColors+catchColorsAddData,typeOfTraits=myTraits,writeFile=writeFileDef,deltaMajorTicks=86400/2.0,deltaMinorTicks=3600,
+                            addTable=addTable)
 
         if(show):
             plt.show()
@@ -1175,7 +1182,7 @@ class Comparison:
             yLabels = []
             if(not("Catchment traits" in plotDict["General Parameters"])):
                 myTraits = []
-            rain = []
+            rain = None
             z = []
             nbAddRain=0
             y_labelAddRain = []
@@ -1308,7 +1315,7 @@ class Comparison:
             if("Measures" in plotDict[RBNames[id]]):
                 Measures = plotDict[RBNames[id]]["Measures"]
                 myMeasure = Measures.myHydro
-                yLabels.append(_("Measures"))
+                yLabels.append(_("Measurement"))
                 catchColorsAddData.append('k')
                 myTraits.append('-')
                 if(Measures.surfaceDrainedHydro>0.0):
@@ -1387,7 +1394,7 @@ class Comparison:
 
 
 
-    def plot_all_diff_cumulRain_with_lagtime(self, interval, selection_by_iD=[], writeDir=""):
+    def plot_all_diff_cumulRain_with_lagtime(self, interval=0, selection_by_iD=[], writeDir=""):
 
         for idCatch in self.myCatchments:
             curCatch:Catchment = self.myCatchments[idCatch]['Object']
@@ -1529,10 +1536,7 @@ class Comparison:
         self.plotDict[stationKey]["Add Data"]["Dt"] = []
 
         for element in myAddDataObj:
-            if addDataUnits == "mm/h":
-                self.plotDict[stationKey]["Add Data"]["Data"].append(element.myHydro[:])
-            else:
-                self.plotDict[stationKey]["Add Data"]["Data"].append(element.myHydro[:]*element.surfaceDrained/3.6)
+            self.plotDict[stationKey]["Add Data"]["Data"].append(element.get_myHydro(unit=addDataUnits))
             self.plotDict[stationKey]["Add Data"]["Date Begin"].append(element.dateBegin)
             self.plotDict[stationKey]["Add Data"]["Date End"].append(element.dateEnd)
             self.plotDict[stationKey]["Add Data"]["Dt"].append(element.deltaT)
@@ -1579,7 +1583,7 @@ class Comparison:
 
 
     
-    def plot_Nash_and_peak(self, stationKey:list[str, int], measures:list[SubBasin], intervals:list=[]):
+    def plot_Nash_and_peak(self, stationKey:list[str, int], measures:list[SubBasin], intervals:list=[], toShow:bool=True):
         assert len(stationKey) == len(measures)
 
         all_ns = {stationKey[i]: [ self.myCatchments[el]["Object"].get_sub_Nash(measures[i], stationKey[i], intervals) 
@@ -1662,8 +1666,8 @@ class Comparison:
         type_of_data = ["Nash", r"$  \frac{Q^{s}_{max}-Q^{m}_{max}}{Q^{m}_{max}} $ "]
         type_of_data_names = ["Nash", "Exceedance"]
 
-        ph.bar_Nash_n_other(all_data, all_colors, nb_x=len(intervals), nb_data=len(type_of_model), nb_lines=nb_stations, 
-                            y_titles=type_of_data, x_titles=all_names, nameModel=type_of_model, line_names=sorted_keys, toShow=False)
+        # ph.bar_Nash_n_other(all_data, all_colors, nb_x=len(intervals), nb_data=len(type_of_model), nb_lines=nb_stations, 
+        #                     y_titles=type_of_data, x_titles=all_names, nameModel=type_of_model, line_names=sorted_keys, toShow=False)
         
         # =========
         # =========
@@ -1700,5 +1704,5 @@ class Comparison:
                 ph.table_Nash_n_other(cur_data, name_of_data, 
                                     row_names=sorted_keys, column_names=all_names, 
                                     writeFile=file_name, toShow=False)
-
-        plt.show()
+        if toShow:
+            plt.show()