wolfhece 2.2.8__py3-none-any.whl → 2.2.10__py3-none-any.whl

wolfhece/hydrology/Models_characteristics.py

@@ -0,0 +1,223 @@
+from . import constant as cst
+from . import cst_exchanges as cste
+from . import Internal_variables as iv
+
+VHM_VAR = iv.Group_to_Activate(
+    name="VHM",
+    all_params=[
+        iv.Param_to_Activate(
+            key="x", group="Internal variables to save", file="soil", 
+            all_variables=[
+                iv.Internal_Variable(name=f"%xu", file="xu", type_of_var=iv.FRAC_VAR, linked_param=None),
+                iv.Internal_Variable(name=f"%xof", file="xof", type_of_var=iv.FRAC_VAR, linked_param=None),
+                iv.Internal_Variable(name=f"%xif", file="xif", type_of_var=iv.FRAC_VAR, linked_param=None),
+                iv.Internal_Variable(name=f"%xbf", file="xbf", type_of_var=iv.FRAC_VAR, linked_param=None),
+            ]),
+        iv.Param_to_Activate(
+            key="U", group="Internal variables to save", file="soil",
+            all_variables=[
+                iv.Internal_Variable(name="U", file="U", type_of_var=iv.IV_VAR, 
+                                     linked_param=cste.exchange_parameters_VHM_Umax)
+            ]),
+        iv.Param_to_Activate(
+            key=None, group=None, file="",
+            all_variables=[
+                iv.Internal_Variable(name="q_of", file="of", type_of_var=iv.DEFAULT_VAR, linked_param=None),
+                iv.Internal_Variable(name="q_if", file="if", type_of_var=iv.DEFAULT_VAR, linked_param=None),
+                iv.Internal_Variable(name="q_bf", file="bf", type_of_var=iv.DEFAULT_VAR, linked_param=None),
+            ])
+    ])
+
+
+UHDIST_LINBF_VAR = iv.Group_to_Activate(
+    name="2 layers",
+    all_params=[
+        iv.Param_to_Activate(
+            key="x", group="Internal variables to save", file="soil",
+            all_variables=[
+                iv.Internal_Variable(name=f"% xif", file="x", type_of_var=iv.FRAC_VAR, linked_param=None)
+            ]),
+        iv.Param_to_Activate(
+            key="U", group="Internal variables to save", file="soil",
+            all_variables=[
+                iv.Internal_Variable(name=f"%U", file="U", type_of_var=iv.IV_VAR, 
+                                     linked_param=cste.exchange_parameters_Dist_Soil_Umax)
+            ]),
+        iv.Param_to_Activate(
+            key="Reservoir", group="Internal variables to save", file="soil",
+            all_variables=[
+                iv.Internal_Variable(name=f"% xp", file="xp", type_of_var=iv.FRAC_VAR, linked_param=None),
+                iv.Internal_Variable(name=f"S", file="S", type_of_var=iv.IV_VAR, 
+                                     linked_param=cste.exchange_parameters_Dist_RS_Hs)
+            ]),
+        iv.Param_to_Activate(
+            key=None, group=None, file="",
+            all_variables=[
+                iv.Internal_Variable(name="q_of", file="of", type_of_var=iv.DEFAULT_VAR, linked_param=None),
+                iv.Internal_Variable(name="q_if", file="if", type_of_var=iv.DEFAULT_VAR, linked_param=None)
+            ])
+    ]
+)
+
+
+HBV_VAR = iv.Group_to_Activate(
+    name="HBV",
+    all_params=[
+        iv.Param_to_Activate(
+            key="U", group="Internal variables to save", file="soil",
+            all_variables=[
+                iv.Internal_Variable(name="U", file="U", type_of_var=iv.IV_VAR, 
+                                     linked_param=cste.exchange_parameters_HBV_FC),
+            ]),
+        iv.Param_to_Activate(
+            key="Q out", group="Internal variables to save", file="soil",
+            all_variables=[
+                iv.Internal_Variable(name="q recharge", file="qrech", type_of_var=iv.OUT_VAR, linked_param=None),
+                iv.Internal_Variable(name="q capillary", file="qcap", type_of_var=iv.OUT_VAR, linked_param=None),
+                iv.Internal_Variable(name="Evapotranspiration", file="etr", type_of_var=iv.OUT_VAR, linked_param=None)
+            ]),
+        iv.Param_to_Activate(
+            key="Su", group="Internal variables to save", file="UZ",
+            all_variables=[
+                iv.Internal_Variable(name="Su", file="Su", type_of_var=iv.IV_VAR, 
+                                     linked_param=cste.exchange_parameters_HBV_SUmax)
+            ]),
+        iv.Param_to_Activate(
+            key="Q out", group="Internal variables to save", file="UZ",
+            all_variables=[
+                iv.Internal_Variable(name="q_of", file="qr", type_of_var=iv.FINAL_OUT_VAR, linked_param=None),
+                iv.Internal_Variable(name="q_if", file="qif", type_of_var=iv.FINAL_OUT_VAR, linked_param=None),
+                iv.Internal_Variable(name="q percolation", file="qperc", type_of_var=iv.OUT_VAR, linked_param=None),
+                iv.Internal_Variable(name="q cap UZ", file="qcap", type_of_var=iv.OUT_VAR, linked_param=None)
+            ]),
+        iv.Param_to_Activate(
+            key=None, group=None, file="",
+            all_variables=[
+                iv.Internal_Variable(name="q_bf", file="bf", type_of_var=iv.DEFAULT_VAR, linked_param=None)
+            ])
+    ]
+)
+
+SACSMA_VAR = iv.Group_to_Activate(
+    name="SAC-SMA",
+    all_params=[
+        iv.Param_to_Activate(
+            key="IV", group="Internal variables to save", file="UZ",
+            all_variables=[
+                iv.Internal_Variable(name="C_UZ_TW", file="Ctw", type_of_var=iv.IV_VAR, 
+                                     linked_param=cste.exchange_parameters_SAC_M_UZ_TW),
+                iv.Internal_Variable(name="C_UZ_FW", file="Cfw", type_of_var=iv.IV_VAR,
+                                     linked_param=cste.exchange_parameters_SAC_M_UZ_FW),
+                iv.Internal_Variable(name="C_Adimp", file="Cadimp", type_of_var=iv.IV_VAR, linked_param=None)
+            ]),
+        iv.Param_to_Activate(
+            key="Q out", group="Internal variables to save", file="UZ",
+            all_variables=[
+                iv.Internal_Variable(name="E1", file="e1", type_of_var=iv.OUT_VAR, linked_param=None),
+                iv.Internal_Variable(name="E2", file="e2", type_of_var=iv.OUT_VAR, linked_param=None),
+                iv.Internal_Variable(name="E5", file="e5", type_of_var=iv.OUT_VAR, linked_param=None),
+                iv.Internal_Variable(name="q_ft", file="qft", type_of_var=iv.OUT_VAR, linked_param=None),
+                iv.Internal_Variable(name="q_tf", file="qtf", type_of_var=iv.OUT_VAR, linked_param=None),
+                iv.Internal_Variable(name="q_if", file="qif", type_of_var=iv.OUT_VAR, linked_param=None),
+                iv.Internal_Variable(name="q_perc", file="qperc", type_of_var=iv.OUT_VAR, linked_param=None),
+                iv.Internal_Variable(name="q_sr", file="qsr", type_of_var=iv.OUT_VAR, linked_param=None),
+                iv.Internal_Variable(name="q_in Adimp", file="qinadimp", type_of_var=iv.OUT_VAR, linked_param=None),
+                iv.Internal_Variable(name="q_dr Adimp", file="qdr", type_of_var=iv.OUT_VAR, linked_param=None)
+            ]),
+        iv.Param_to_Activate(
+            key="IV", group="Internal variables to save", file="LZ",
+            all_variables=[
+                iv.Internal_Variable(name="C_LZ_TW", file="Ctw", type_of_var=iv.IV_VAR, 
+                                     linked_param=cste.exchange_parameters_SAC_M_LZ_TW),
+                iv.Internal_Variable(name="C_LZ_FP", file="Cfp", type_of_var=iv.IV_VAR, 
+                                     linked_param=cste.exchange_parameters_SAC_M_LZ_FP),
+                iv.Internal_Variable(name="C_LZ_FS", file="Cfs", type_of_var=iv.IV_VAR,
+                                     linked_param=cste.exchange_parameters_SAC_M_LZ_FS)
+            ]),
+        iv.Param_to_Activate(
+            key="Q out", group="Internal variables to save", file="LZ",
+            all_variables=[
+                iv.Internal_Variable(name="E3", file="e3", type_of_var=iv.OUT_VAR, linked_param=None),
+                iv.Internal_Variable(name="q_fp", file="qfp", type_of_var=iv.OUT_VAR, linked_param=None),
+                iv.Internal_Variable(name="q_fs", file="qfs", type_of_var=iv.OUT_VAR, linked_param=None),
+                iv.Internal_Variable(name="q_in tw", file="qintw", type_of_var=iv.OUT_VAR, linked_param=None),
+                iv.Internal_Variable(name="q_in fp", file="qinfp", type_of_var=iv.OUT_VAR, linked_param=None),
+                iv.Internal_Variable(name="q_in fs", file="qinfs", type_of_var=iv.OUT_VAR, linked_param=None),
+                iv.Internal_Variable(name="q_out tw", file="qouttw", type_of_var=iv.OUT_VAR, linked_param=None),
+                iv.Internal_Variable(name="q_out fp", file="qoutfp", type_of_var=iv.OUT_VAR, linked_param=None),
+                iv.Internal_Variable(name="q_out fs", file="qoutfs", type_of_var=iv.OUT_VAR, linked_param=None),
+            ]),
+        iv.Param_to_Activate(
+            key=None, group=None, file="out",
+            all_variables=[
+                iv.Internal_Variable(name="E_tot", file="Etot", type_of_var=iv.DEFAULT_VAR, linked_param=None),
+                iv.Internal_Variable(name="Q_of", file="Qof", type_of_var=iv.DEFAULT_VAR, linked_param=None),
+                iv.Internal_Variable(name="Q_if", file="Qif", type_of_var=iv.DEFAULT_VAR, linked_param=None),
+                iv.Internal_Variable(name="Q_bf", file="Qbf", type_of_var=iv.DEFAULT_VAR, linked_param=None),
+                iv.Internal_Variable(name="Q_subbf", file="Qsubbf", type_of_var=iv.DEFAULT_VAR, linked_param=None),
+                iv.Internal_Variable(name="Q_surf", file="Qsurf", type_of_var=iv.DEFAULT_VAR, linked_param=None),
+                iv.Internal_Variable(name="Q_base", file="Qbase", type_of_var=iv.DEFAULT_VAR, linked_param=None)
+            ])
+    ]
+)
+
+NAM_VAR = iv.Group_to_Activate(
+    name="NAM",
+    all_params=[
+        iv.Param_to_Activate(
+            key="U", group="Internal variables to save", file="SS",
+            all_variables=[
+                iv.Internal_Variable(name="U", file="U", type_of_var=iv.IV_VAR, 
+                                     linked_param=cste.exchange_parameters_NAM_UMAX),
+            ]),
+        iv.Param_to_Activate(
+            key="Q out", group="Internal variables to save", file="SS",
+            all_variables=[
+                iv.Internal_Variable(name="qqof", file="qof", type_of_var=iv.OUT_VAR, linked_param=None),
+                iv.Internal_Variable(name="qqif", file="qif", type_of_var=iv.OUT_VAR, linked_param=None),
+                # iv.Internal_Variable(name="q_infil", file="qinfil", type_of_var=iv.OUT_VAR),
+                iv.Internal_Variable(name="Ea", file="ea", type_of_var=iv.OUT_VAR, linked_param=None),
+            ]),
+        iv.Param_to_Activate(
+            key="IV", group="Internal variables to save", file="RZ",
+            all_variables=[
+                iv.Internal_Variable(name="L", file="L", type_of_var=iv.IV_VAR,
+                                     linked_param=cste.exchange_parameters_NAM_LMAX),
+            ]),
+        iv.Param_to_Activate(
+            key="Q out", group="Internal variables to save", file="RZ",
+            all_variables=[
+                iv.Internal_Variable(name="E_rz", file="erz", type_of_var=iv.OUT_VAR, linked_param=None),
+                iv.Internal_Variable(name="q_g", file="qg", type_of_var=iv.OUT_VAR, linked_param=None),
+            ]),
+        iv.Param_to_Activate(
+            key=None, group=None, file="",
+            all_variables=[
+                iv.Internal_Variable(name="q_of", file="OF", type_of_var=iv.DEFAULT_VAR, linked_param=None),
+                iv.Internal_Variable(name="q_if", file="IF", type_of_var=iv.DEFAULT_VAR, linked_param=None),
+                iv.Internal_Variable(name="q_bf", file="BF", type_of_var=iv.DEFAULT_VAR, linked_param=None)
+            ])
+    ]
+)
+
+
+MODELS_VAR:dict[int, iv.Group_to_Activate] = {
+    cst.tom_VHM: VHM_VAR,
+    cst.tom_2layers_linIF: UHDIST_LINBF_VAR,
+    cst.tom_HBV: HBV_VAR,
+    cst.tom_SAC_SMA: SACSMA_VAR,
+    cst.tom_NAM: NAM_VAR
+}
+
+if __name__ == "__main__":
+    print(f"VHM keys: {VHM_VAR.get_keys()}")
+    print(f"UHDIST_LINBF keys: {UHDIST_LINBF_VAR.get_keys()}")
+    print(f"HBV keys: {HBV_VAR.get_keys()}")
+    print(f"SACSMA keys: {SACSMA_VAR.get_keys()}")
+    print(f"NAM keys: {NAM_VAR.get_keys()}")
+    
+    print(f"VHM files: {VHM_VAR.get_files_per_keys()}")
+    print(f"UHDIST_LINBF files: {UHDIST_LINBF_VAR.get_files_per_keys()}")
+    print(f"HBV files: {HBV_VAR.get_files_per_keys()}")
+    print(f"SACSMA files: {SACSMA_VAR.get_files_per_keys()}")
+    print(f"NAM files: {NAM_VAR.get_files_per_keys()}")

wolfhece/hydrology/Optimisation.py

@@ -27,6 +27,8 @@ from ..wolf_array import *
 from ..PyGui import GenMapManager,HydrologyModel
 from . import cst_exchanges as cste
 from . import constant as cst
+from . import Models_characteristics as mc
+from . import Internal_variables as iv
 from ..PyTranslate import _
 import traceback
 
@@ -228,7 +230,12 @@ class Optimisation(wx.Frame):
         self.Bind(wx.EVT_MENU, self.test_equifinality_with_Nash, testEquiFinClick)
         plotEquiFinClick = toolMenu.Append(wx.ID_ANY, 'Plot equifinality with Nash')
         self.Bind(wx.EVT_MENU, self.plot_equifinality, plotEquiFinClick)
-
+        testEquiFinClick = toolMenu.Append(wx.ID_ANY, 'Models analysis with Nash')
+        self.Bind(wx.EVT_MENU, self.launch_models_propertie_with_Nash, testEquiFinClick)
+        plotEquiFinClick = toolMenu.Append(wx.ID_ANY, 'Plot analysis with Nash')
+        self.Bind(wx.EVT_MENU, self.plot_model_analysis, plotEquiFinClick)
+        
+        
 
         # Creation of the Lauch Menu
         launchMenu = wx.Menu()
@@ -1990,24 +1997,31 @@ class Optimisation(wx.Frame):
                         if cur_sub.iDSorted != refCatch.myEffSortSubBasins[cur_effsub]:
                             continue
                     self.myParams[i+1]["value"] = params[i]
-                    if "Convertion Factor" in myModelDict[int(myType)]:
-                        convFact = myModelDict[int(myType)]["Convertion Factor"]
-                    else:
-                        convFact = 1.0
+
                     all_files = myModelDict[int(myType)]["File"]
                     if type(all_files) is not list:
+                        # Extract the unit conversion factor
+                        if "Convertion Factor" in myModelDict[int(myType)]:
+                            convFact = myModelDict[int(myType)]["Convertion Factor"]
+                        else:
+                            convFact = 1.0
                         fileName = myModelDict[int(myType)]["File"]
                         myGroup = myModelDict[int(myType)]["Group"]
                         myKey = myModelDict[int(myType)]["Key"]
                         self.write_one_opti_param(filePath, fileName, myGroup, myKey, params[i], convers_factor=convFact)
                     else:
+                        # Extract the unit conversion factor in a list which is the same size as the number of files
+                        if "Convertion Factor" in myModelDict[int(myType)]:
+                            convFact = myModelDict[int(myType)]["Convertion Factor"]
+                        else:
+                            convFact = [1.0]*len(all_files)
+                        # Iterate over all the files to fill for one parameter
                         for iFile in range(len(all_files)):
                             fileName = all_files[iFile]
                             myGroup = myModelDict[int(myType)]["Group"][iFile]
                             myKey = myModelDict[int(myType)]["Key"][iFile]
-                            self.write_one_opti_param(filePath, fileName, myGroup, myKey, params[i], convers_factor=convFact)
-                else:
-
+                            self.write_one_opti_param(filePath, fileName, myGroup, myKey, params[i], convers_factor=convFact[iFile])
+                else:               
                     self.curParams_vec_F[i] = params[i]
                     self.update_timeDelay(i+1)
                     refCatch.save_timeDelays([self.myParams[i+1]["junction_name"]])
@@ -2662,10 +2676,10 @@ class Optimisation(wx.Frame):
         logging.info("The equifinality test is finished!")
 
 
-    def get_best_params(self, stationOut:str,
-                        criterion:str="Nash", quantile:float=0.99, std:float=0.05, eps:float=0.1,
-                        objective_fct:bool= True, apply_clustering:bool=False):
-        from sklearn.cluster import DBSCAN
+    def get_best_params(self, stationOut:str, 
+                        criterion:str="Nash", quantile:float=0.99, std:float=0.05, eps:float=0.2, rmv_near_max=1e-4, nb_rand_close:int=10,
+                        objective_fct:bool= True, apply_clustering:bool=False, objective_weight:float=1.0):
+        from sklearn.cluster import DBSCAN        
         """
         Get the best parameters for a given station.
 
@@ -2685,12 +2699,26 @@ class Optimisation(wx.Frame):
 
         quantile_cond = (all_obj_fct > np.quantile(all_obj_fct, quantile))
         std_cond = (all_obj_fct > best_objfct*(1-std))
-        all_cond = np.where(np.logical_and(quantile_cond, std_cond))[0]
+        tooclose_cond = (all_obj_fct < best_objfct*(1-rmv_near_max)) | (all_obj_fct == best_objfct)
+        all_cond = np.where(quantile_cond & std_cond & tooclose_cond)[0]
         eff_params = all_params[all_cond]
         eff_obj = all_obj_fct[all_cond]
 
         if objective_fct:
             eff_params = np.column_stack((eff_params, eff_obj))
+        # Select randomly the parameters that are close to the best one
+        if nb_rand_close>0:
+            close_params = all_params[~tooclose_cond]
+            if np.shape(close_params)[0]>0:
+                close_obj = all_obj_fct[~tooclose_cond]
+                # random selection of the parameters that are close to the best one
+                idx = np.random.choice(np.shape(close_params)[0], size=nb_rand_close, replace=False)
+                selected_params = close_params[idx]
+                selected_obj = close_obj[idx]
+                tot_add_params = np.column_stack((selected_params, selected_obj))
+                # Add the selected parameters to the eff_params
+                eff_params = np.vstack((eff_params, tot_add_params))
+            # add to the eff_params
 
         # In this part we filter abd remove the parameters that are almost equivalent
         # To do so, we use the DBSCAN clustering algorithm to group the parameters that are close to each other
@@ -2701,6 +2729,10 @@ class Optimisation(wx.Frame):
             min_param = np.min(eff_params, axis=0)
             max_param = np.max(eff_params, axis=0)
             norm_params = (eff_params-min_param)/(max_param-min_param)
+            # Add weight to the objective function to make it more important in the clustering
+            # FIXME : to be improved
+            norm_params[:,-1] = norm_params[:,-1]*objective_weight
+            # Apply the DBSCAN clustering algorithm to group the parameters
             db = DBSCAN(eps=eps).fit(norm_params)
             labels = db.labels_
             # Extraction of the number of groups and particular cases
@@ -2800,6 +2832,35 @@ class Optimisation(wx.Frame):
             return None
         cur_fracts = curBasin.get_volume_fractions(interval=intervals)
         return cur_fracts
+    
+    def _get_flow_fractions(self, idLauncher:int=0, stationOut:str="", 
+                         intervals:list[tuple[datetime.datetime, datetime.datetime]]=[]) -> dict[list[str], list[float]]:
+        
+        curCatch:Catchment = self.myCases[idLauncher].refCatchment
+        cur_key = curCatch.get_key_catchmentDict(stationOut)
+        curBasin: SubBasin = curCatch.catchmentDict[cur_key]
+        if type(curBasin) != SubBasin:
+            logging.warning("The current module is not a SubBasin object!")
+            return None
+        cur_fracts = curBasin.get_flow_fractions(interval=intervals, summary="mean")
+        return cur_fracts
+    
+
+    def _get_punctual_reservoir_fractions(self, eval_date:datetime.datetime, 
+                                          idLauncher:int=0, stationOut:str="") -> dict[list[str], list[float]]:
+        
+        curCatch:Catchment = self.myCases[idLauncher].refCatchment
+        cur_key = curCatch.get_key_catchmentDict(stationOut)
+        curBasin: SubBasin = curCatch.catchmentDict[cur_key]
+        if type(curBasin) != SubBasin:
+            logging.warning("The current module is not a SubBasin object!")
+            return None
+        linked_params = mc.MODELS_VAR[curBasin.model].get_all_linked_params()
+        i_params = self._get_key_from_type_all_parameters(list(linked_params.values()))    
+        max_params = {var_name: self.myParams[i_params[param_id]]["value"] for var_name, param_id in linked_params.items()}
+        cur_fracts = curBasin.get_iv_fractions_one_date(max_params=max_params, eval_date=eval_date)
+        return cur_fracts
+
 
     # FIXME :  to improve and generalise
     def _get_max_runoff(self, idLauncher:int=0, stationOut:str="",
@@ -2855,7 +2916,6 @@ class Optimisation(wx.Frame):
             for i in range(nbInlets):
                 names.append("TimeDelay "+inletsNames[i])
 
-
         return names
 
     # Plot the equifinalty test for each station
@@ -2938,6 +2998,63 @@ class Optimisation(wx.Frame):
 
         plt.show()
 
+    # Plot the equifinalty test for each station
+    def plot_model_analysis(self, event, idLauncher:int=0):
+
+        physical_properties = ["%q_of", "%q_if", "%q_bf"]
+        # physical_properties_vol = [el+" volume" for el in physical_properties]
+        colors_properties = ["b", "g", "k"]
+        y_label = "Nash"
+
+        if self.myStations==[]:
+            self.set_compare_stations(idLauncher=idLauncher)
+        sortJct = self.myStations
+
+        for iOpti in range(len(sortJct)):
+            stationOut = sortJct[iOpti]
+            filename = os.path.join(self.workingDir, stationOut+"_tests.xlsx")
+            if os.path.isfile(filename):
+                df = pd.read_excel(filename, sheet_name=stationOut)
+                # Plot the physical properties
+                fig, ax = plt.subplots()
+                for cur_prop, cur_color in zip(physical_properties, colors_properties):
+                    cur_columns = [col for col in df.columns if cur_prop in col.replace(" ", "")]
+                    if cur_columns != []:
+                        corr_prop = cur_columns[0]
+                        ax.scatter(df.loc[:,corr_prop], df.loc[:,y_label], s=0.5, c=cur_color, 
+                                   marker='o', label=cur_prop, alpha=0.4)
+                ax.set_xlabel("% of the rain [-]")
+                ax.set_ylabel(y_label+" [-]")
+                ax.set_title("Proportion of rain : "+stationOut)
+                ax.legend()
+                fig.savefig(os.path.join(self.workingDir, "Equifinality_physical_prop_"+stationOut+".png"))
+                # Plot the Probability of exceedance
+                cur_color = colors_properties[0]
+                x_label = "P. of exceedance"
+                fig, ax = plt.subplots()
+                if x_label in df.columns:
+                    ax.scatter(df.loc[:,x_label], df.loc[:,y_label], s=0.5, c=cur_color, marker='o', label=x_label)
+                ax.set_xlabel(x_label +" [-]")
+                ax.set_ylabel(y_label+" [-]")
+                ax.set_title("Probability of Q_sim > Q_meas : "+stationOut)
+                ax.legend()
+                fig.savefig(os.path.join(self.workingDir, "Equifinality_prob_excess_"+stationOut+".png"))
+                # Plot Q_sim/Q_max
+                x_label = "Qmax_simul/Q_max_measure"
+                fig, ax = plt.subplots()
+                if x_label in df.columns:
+                    ax.scatter(df.loc[:,x_label], df.loc[:,y_label], s=0.5, c=cur_color, marker='o', label=x_label)
+                ax.set_xlabel(x_label +" [-]")
+                ax.set_ylabel(y_label+" [-]")
+                ax.set_title("Peak analysis : "+stationOut)
+                ax.legend()
+                fig.savefig(os.path.join(self.workingDir, "Equifinality_peaks_ratio_"+stationOut+".png"))
+                
+            else:
+                logging.error("The file "+filename+" does not exist!")
+                
+        plt.show()
+
 
     def add_Case(self, idLauncher:int=0):
 
@@ -3093,6 +3210,169 @@ class Optimisation(wx.Frame):
         tmpWolf = None
 
 
+    # FIXME : this function has been dashed off -> functionnal but not well written!!
+    # TODO : to improve !!!!!!
+    def launch_models_propertie_with_Nash(self, event, idLauncher:int=0, idOpti:int=1, quantile_Nash:float=0.01, std_Nash:float=0.03, clustering_Nash:bool=True, 
+                                          save_every:int=100, restart_from_file:bool=True):
+        """
+        Analyse the properties of the model and compare them with the Nash coefficient.
+
+        Args:
+            idLauncher (int, optional): The id of the launcher. Defaults to 0.
+
+        Returns:
+            None
+
+        Raises:
+            None
+        """
+        curCatch:Catchment = self.myCases[idLauncher].refCatchment
+
+        onlyOwnSub = self.optiParam.get_param("Semi-Distributed", "Own_SubBasin")
+        if onlyOwnSub is None:
+            onlyOwnSub = False
+        doneList = []
+        previousLevel = 1 
+        # Collect sort and save the compare stations
+        self.set_compare_stations(idLauncher=idLauncher)
+        sortJct = self.myStations
+        # Get the initial number of intervals 
+        # -> these can evolve according to the measurement available at each station
+        is_ok = self._save_opti_intervals()
+        all_intervals = self.all_intervals
+        # Activate the writing of the internal variables
+        curCatch.activate_all_internal_variables()
+        # Prepare the Excel writer
+        writer_tot = pd.ExcelWriter(os.path.join(self.workingDir, "all_best_tests.xlsx"), engine = 'xlsxwriter')
+
+        for iOpti in range(len(sortJct)):
+            stationOut = sortJct[iOpti]
+            logging.info("==================")
+            logging.info("Station : "+stationOut)
+            # Build the current compare.txt file and replace all nan values by 0.0
+            self.save_current_compare_file(stationOut=stationOut)
+            # Save the name of the station that will be the output
+            curCatch.define_station_out(stationOut)
+            # Activate all the useful subs and write it in the param file
+            curCatch.activate_usefulSubs(blockJunction=doneList, onlyItself=onlyOwnSub)
+            # Select correct calibration intervals -> remove the intervals with NaN
+            cur_intervals = self.select_opti_intervals(all_intervals=all_intervals, stationOut=stationOut, filter_nan=True)
+            self.save_opti_dates_to_file(cur_intervals)
+            # Rename the result file
+            self.optiParam.change_param("Optimizer", "fname", stationOut)
+            self.optiParam.SavetoFile(None)
+            self.optiParam.Reload(None)
+            self.update_myParams(idLauncher)
+            # Prepare the paramPy dictionnary before calibration
+            self.prepare_calibration_timeDelay(stationOut=stationOut)
+            # Reload the useful modules
+            self.reload_hydro(idCompar=0, fromStation=stationOut, lastLevel=previousLevel, updateAll=True)
+            ## =======
+            ## Init 
+            ## =======
+            self.init_optimizer(idOpti)
+            self.associate_ptr(None, idOpti=idOpti)
+            # Get the best parameters to test
+            all_params = self.get_best_params(stationOut=stationOut, quantile=quantile_Nash, std=std_Nash, rmv_near_max=1e-4, apply_clustering=clustering_Nash)
+            ## =======
+            ## Compute 
+            ## =======
+            all_frac = []
+            # Check if the excel file already exists and load it to check if some parameters have already been tested
+            if restart_from_file:
+                all_frac, all_params = self._reload_model_analysis(stationOut=stationOut, all_params=all_params)
+            # Get param names
+            names = self.get_param_names(idLauncher=idLauncher, stationOut=stationOut)
+            logging.info("The number of sets of parameters to test are : "+str(len(all_params)))
+            for i in tqdm(range(len(all_params))):
+                cur_p = all_params[i, :-1]
+                cur_obj = all_params[i, -1]
+                cur_obj2 = self.evaluate_model_optimizer(cur_p, idOpti=idOpti)
+                print("cur_obj : ", cur_obj, " ; cur_obj2 : ", cur_obj2)
+                if cur_obj != cur_obj2:
+                    logging.error("The objective function is not the same as the one computed by the model!")
+                    logging.error("cur_obj : "+str(cur_obj)+" ; cur_obj2 : "+str(cur_obj2))
+                # assert cur_obj == cur_obj2, "The objective function is not the same as the one computed by the model!"
+                self.write_mesh_results_optimizer(idOpti=idOpti)
+                # Save all the variables/evaluations desired
+                frac_flow_dict = self._get_flow_fractions(idLauncher=idLauncher, stationOut=stationOut, intervals=cur_intervals)
+                init_iv =  self._get_punctual_reservoir_fractions(eval_date=cur_intervals[0][0], idLauncher=idLauncher, stationOut=stationOut)
+                p_excess = self._get_exceedance(idLauncher=idLauncher, stationOut=stationOut, intervals=cur_intervals)
+                max_sim_obs = self._get_ratio_max_sim_obs(idLauncher=idLauncher, stationOut=stationOut, intervals=cur_intervals)
+                # Extract the time delays
+                all_timeDelays = curCatch.get_timeDelays_inlets(ref=stationOut)
+                all_timeDelays_str = {key : str(datetime.timedelta(seconds=all_timeDelays[key])) for key in all_timeDelays}
+                cur_timeDelays = list(all_timeDelays_str.values())
+                # Concatenate all the informations
+                cur_all_frac = (list(cur_p)
+                                + cur_timeDelays
+                                + list(frac_flow_dict.values())
+                                + list(init_iv.values()) 
+                                + [p_excess, max_sim_obs, cur_obj])
+                all_frac.append(cur_all_frac)
+                # Periodically save the evaluations in case of trouble
+                if (i + 1) % save_every == 0:
+                    # Save the evaluations
+                    var_names = names \
+                                + list(all_timeDelays_str.keys()) \
+                                + list(frac_flow_dict.keys()) \
+                                + list(init_iv.keys()) \
+                                + ["P. of exceedance", "Qmax_simul/Q_max_measure", "Nash"]
+                    cur_df = pd.DataFrame(all_frac, columns=var_names)
+                    # write first the tempory results for each station
+                    writer_stat = pd.ExcelWriter(os.path.join(self.workingDir, stationOut+"_tests.xlsx"), engine = 'xlsxwriter')
+                    cur_df.to_excel(writer_stat, sheet_name=stationOut, columns=var_names)
+                    writer_stat.sheets[stationOut].autofit()
+                    writer_stat.close()
+
+            # Save the evaluations
+            var_names = names \
+                        + list(all_timeDelays_str.keys()) \
+                        + list(frac_flow_dict.keys()) \
+                        + list(init_iv.keys()) \
+                        + ["P. of exceedance", "Qmax_simul/Q_max_measure", "Nash"]
+            cur_df = pd.DataFrame(all_frac, columns=var_names)
+            # write first the tempory results for each station
+            writer_stat = pd.ExcelWriter(os.path.join(self.workingDir, stationOut+"_tests.xlsx"), engine = 'xlsxwriter')
+            cur_df.to_excel(writer_stat, sheet_name=stationOut, columns=var_names)
+            writer_stat.sheets[stationOut].autofit()
+            writer_stat.close()
+            # write now the informations for all the stations in the same excel file
+            cur_df.to_excel(writer_tot, sheet_name=stationOut, columns=var_names)
+            writer_tot.sheets[stationOut].autofit()
+
+            ## =======
+            ## =======
+            # Collect the best parameters and their objective function(s)
+            best_params = self.apply_optim(None)
+            # Simulation with the best parameters
+            self.compute_distributed_hydro_model()
+            # Update myHydro of all effective subbasins to get the best configuration upstream
+            curCatch.read_hydro_eff_subBasin()
+            # Update timeDelays according to time wolf_array
+            self.apply_timeDelay_dist(idOpti=idOpti, idLauncher=idLauncher, junctionKey=stationOut)
+            # Update the outflows
+            curCatch.update_hydro(idCompar=0)
+
+            # All upstream elements of a reference will be fixed
+            doneList.append(stationOut)
+            previousLevel = curCatch.levelOut
+
+        writer_tot.close()
+        logging.info("The equifinality test is finished!")
+
+    # FIXME : it might be better to pass the myParams to the CaseOpti object instead to allow parallelisation
+    def _build_type_to_key_index(self) -> dict[int, int]:
+        return {param["type"]: i for i, param in self.myParams.items()}
+    
+    def _get_key_from_type_all_parameters(self, list_type_param: list[int]) -> dict[int | None]:
+        type_to_key = self._build_type_to_key_index()
+        return {cur_key: type_to_key.get(cur_key) for cur_key in list_type_param}
+
+    def _get_key_from_type_parameter(self, type_param:int) -> int:
+        return next((i for i, param in self.myParams.items() if param["type"] == type_param), 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
 
@@ -3109,3 +3389,33 @@ class Optimisation(wx.Frame):
             return arr.copy()
         else:
             return arr
+
+    def _reload_model_analysis(self, stationOut:str, all_params:np.ndarray):
+        """
+        Reload the model analysis for a given station.
+
+        Args:
+            stationOut (str): The name of the station.
+            all_params (np.ndarray): The parameters to be tested.
+
+        Returns:
+            None
+
+        Raises:
+            None
+        """
+        # Check if the excel file already exists and load it to check if some parameters have already been tested
+        filename = os.path.join(self.workingDir, stationOut+"_tests.xlsx")
+        # just_params = all_params[:, :-1]
+        nb_params = np.shape(all_params)[1] - 1
+        if os.path.isfile(filename):
+            df = pd.read_excel(os.path.join(self.workingDir, stationOut+"_tests.xlsx"), sheet_name=stationOut)
+            # Extract all the values of the dataframe in a list
+            all_data_tested = df.iloc[:, 1:].values.tolist()
+            # Extract all the values of the dataframe in a numpy array
+            all_params_tested = df.iloc[:, 1:nb_params+1].values
+            # Remove the parameters that have already been tested
+            new_params = np.array([el for el in all_params if ~np.any(np.all(np.isclose(all_params_tested, el[:-1], atol=1e-6), axis=1))])
+            return all_data_tested, new_params
+        
+        return [], all_params