wolfhece 2.0.43__py3-none-any.whl → 2.0.45__py3-none-any.whl

wolfhece/hydrology/Optimisation.py

@@ -18,6 +18,7 @@ from ..PyGui import GenMapManager,HydrologyModel
 from . import cst_exchanges as cste
 from . import constant as cst
 from ..PyTranslate import _
+import traceback
 
 
 # %% Constants
@@ -37,6 +38,7 @@ class CaseOpti(GenMapManager):
     refCatchment:Catchment
     idToolItem:int
     mydro:HydrologyModel
+    idMenuItem:int
 
     # FIXME : this variable is just there before the seperation between the object optimisation and GUI optimisation
     wx_exists:bool
@@ -111,8 +113,10 @@ class Optimisation(wx.Frame):
 
     myCases:list[CaseOpti]
 
-    myStations:list
-    compareFilesDict:dict
+    myStations:list[str]
+    compareFilesDict:dict[str, str]
+    compareSubBasins:dict[str, SubBasin]
+    all_intervals:list[tuple[datetime.datetime, datetime.datetime]]
 
     # FIXME : this variable is just there before the seperation between the object optimisation and GUI optimisation
     wx_exists:bool
@@ -140,6 +144,7 @@ class Optimisation(wx.Frame):
 
         self.myStations = []
         self.compareFilesDict = {}
+        self.all_intervals = None
 
         self.curParams_vec_F = None
 
@@ -201,7 +206,15 @@ class Optimisation(wx.Frame):
         self.Bind(wx.EVT_MENU, self.plot_all_landuses, landuseClick)
         landuseHydroClick = toolMenu.Append(wx.ID_ANY, 'Plot all hydro landuses')
         self.Bind(wx.EVT_MENU, self.plot_all_landuses_hydro, landuseHydroClick)
-
+        internValClick = toolMenu.Append(wx.ID_ANY, 'Extract internal variables')
+        self.Bind(wx.EVT_MENU, self.extract_internal_variables, internValClick)
+        plotParetoClick = toolMenu.Append(wx.ID_ANY, 'Plot Nash vs Qexcess')
+        self.Bind(wx.EVT_MENU, self.plot_Nash_vs_Qexcess, plotParetoClick)
+        testEquiFinClick = toolMenu.Append(wx.ID_ANY, 'Test equifinality with Nash')
+        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)
+        
 
         # Creation of the Lauch Menu
         launchMenu = wx.Menu()
@@ -356,7 +369,7 @@ class Optimisation(wx.Frame):
         if nbcases>1:
             wx.MessageBox(_('So far, there can only have 1 case! This will change soon.'), _('Error'), wx.OK|wx.ICON_ERROR)
             return
-        # self.launcherDir = []
+        self.launcherDir = []
         for i in range(nbcases):
             newCase = CaseOpti()
             launcherDir = self.optiParam.get_param("Cases","dir_"+str(i+1))
@@ -365,35 +378,35 @@ class Optimisation(wx.Frame):
                 print("ERROR : in path of launcherDir")
             newCase.read_param(launcherDir, copyDefault=False, callback=self.update_parameters_launcher)
             # FIXME TO CHANGE when seperation with the GUI
-            if self.wx_exists:
-                newId = wx.Window.NewControlId()
-                iMenu = self.MenuBar.FindMenu('Param files')
-                paramMenu = self.MenuBar.Menus[iMenu][0]
-                curName = 'Case '+str(i+1)
-                iItem = self.MenuBar.FindMenuItem('Param files', curName)
-                if(iItem==wx.NOT_FOUND):
-                    caseMenu = wx.Menu()
-                    paramCaseFile = caseMenu.Append(wx.ID_ANY, 'launcher.param')
-                    self.Bind(wx.EVT_MENU, newCase.show_launcherParam, paramCaseFile)
-                    guiHydroCase = caseMenu.Append(wx.ID_ANY, 'GUI Hydro')
-                    refDir = newCase.launcherParam.get_param("Calculs","Répertoire simulation de référence")
-                    isOk, refDir = check_path(refDir, prefix=launcherDir, applyCWD=True)
-                    if isOk<0:
-                        print("ERROR : in path of launcherDir")
-                    newCase.mydro = HydrologyModel(dir=refDir)
-                    newCase.mydro.Hide()
-                    self.Bind(wx.EVT_MENU, newCase.show_mydro, guiHydroCase)
-                    curCase = paramMenu.Append(newId, curName, caseMenu)
-                else:
-                    print("WARNING : this scenario was not implemented yet. This might induce an error!")
-                    # iItem = 
-                    curCase = paramMenu.Replace(iItem)
-            else:
-                refDir = newCase.launcherParam.get_param("Calculs","Répertoire simulation de référence")
-                isOk, refDir = check_path(refDir, prefix=launcherDir, applyCWD=True)
-                newCase.mydro = HydrologyModel(dir=refDir)
+            # if self.wx_exists:
+            #     newId = wx.Window.NewControlId()
+            #     iMenu = self.MenuBar.FindMenu('Param files')
+            #     paramMenu = self.MenuBar.Menus[iMenu][0]
+            #     curName = 'Case '+str(i+1)
+            #     iItem = self.MenuBar.FindMenuItem('Param files', curName)
+            #     if(iItem==wx.NOT_FOUND):
+            #         caseMenu = wx.Menu()
+            #         paramCaseFile = caseMenu.Append(wx.ID_ANY, 'launcher.param')
+            #         self.Bind(wx.EVT_MENU, newCase.show_launcherParam, paramCaseFile)
+            #         guiHydroCase = caseMenu.Append(wx.ID_ANY, 'GUI Hydro')
+            #         refDir = newCase.launcherParam.get_param("Calculs","Répertoire simulation de référence")
+            #         isOk, refDir = check_path(refDir, prefix=launcherDir, applyCWD=True)
+            #         if isOk<0:
+            #             print("ERROR : in path of launcherDir")
+            #         newCase.mydro = HydrologyModel(dir=refDir)
+            #         newCase.mydro.Hide()
+            #         self.Bind(wx.EVT_MENU, newCase.show_mydro, guiHydroCase)
+            #         curCase = paramMenu.Append(newId, curName, caseMenu)
+            #     else:
+            #         print("WARNING : this scenario was not implemented yet. This might induce an error!")
+            #         # iItem = 
+            #         curCase = paramMenu.Replace(iItem)
+            # else:
+            #     refDir = newCase.launcherParam.get_param("Calculs","Répertoire simulation de référence")
+            #     isOk, refDir = check_path(refDir, prefix=launcherDir, applyCWD=True)
+            #     newCase.mydro = HydrologyModel(dir=refDir)
             # self.Bind(wx.EVT_MENU, newCase.show_launcherParam, curCase)
-            newCase.idMenuItem = newId
+            # newCase.idMenuItem = newId
             self.myCases.append(newCase)
 
 
@@ -417,7 +430,8 @@ class Optimisation(wx.Frame):
             self.enable_MenuBar("Debug")
     
 
-    def apply_optim(self, event, idLauncher:int=0, replace_only_if_better:bool=False, optim_params:np.ndarray=None):
+    def apply_optim(self, event, idLauncher:int=0, 
+                    replace_only_if_better:bool=False, optim_params:np.ndarray=None):
         """
         Apply optimal parameters based on the results file of the optimisation : ".rpt".
 
@@ -575,7 +589,7 @@ class Optimisation(wx.Frame):
         curCatch:Catchment
         self.nbParams = int(self.myCases[idLauncher].launcherParam.get_param("Paramètres à varier", "Nombre de paramètres à varier"))
         curCatch = self.myCases[idLauncher].refCatchment
-
+        launcher_param = self.myCases[idLauncher].launcherParam
 
         for i in range(1,self.nbParams+1):
             curParam = "param_" + str(i)
@@ -585,7 +599,12 @@ class Optimisation(wx.Frame):
             # Check cst_echange.py for the values (only consider the param of the Froude model)
             if self.myParams[i]["type"]>100 and self.myParams[i]["type"]<106:
                 self.myParams[i]["update"] = curCatch.update_timeDelays_from_F
-                self.myParams[i]["junction_name"] = curCatch.junctionOut
+                sorted_id = int(launcher_param.get_param(curParam, "Subbasin id", default_value=0))
+                if sorted_id == 0:
+                    self.myParams[i]["junction_name"] = curCatch.junctionOut
+                else:
+                    cur_id = list(curCatch.dictIdConversion.keys())[list(curCatch.dictIdConversion.values()).index(sorted_id)]                   
+                    self.myParams[i]["junction_name"] = curCatch.subBasinDict[cur_id].name
 
             else:
                 self.myParams[i]["update"] = self.update_nothing
@@ -616,7 +635,7 @@ class Optimisation(wx.Frame):
         if isOk>0:
             optimFile = optimFileBin
             allParams = read_bin(self.workingDir, nameTMP+".rpt.dat", uniform_format=8)
-            matrixData = np.array(allParams[-1]).astype("float")
+            matrixData = np.array(allParams[-1]).astype("double")
         else:
             isOk, optimFileTxt = check_path(optimFileTxt)
             if isOk>0:
@@ -629,7 +648,7 @@ class Optimisation(wx.Frame):
                             if(len(raw)>1):
                                 if raw[0]+" "+raw[1]=="Best run":
                                     list_data.append(raw[3:-1])
-                    matrixData = np.array(list_data[0]).astype("float")
+                    matrixData = np.array(list_data[0]).astype("double")
                 except:
                     wx.MessageBox(_('The best parameters file is not found!'), _('Error'), wx.OK|wx.ICON_ERROR)
 
@@ -833,16 +852,8 @@ class Optimisation(wx.Frame):
         compMeas = []
         if self.myStations==[]:
             self.set_compare_stations(idLauncher=idLauncher)
-            
-        for iOpti in range(len(self.myStations)):
-            dateBegin = refCatch.dateBegin
-            dateEnd = refCatch.dateEnd
-            deltaT = refCatch.deltaT # [sec]
-            stationOut = self.myStations[iOpti]
-            compareFileName = self.compareFilesDict[stationOut]
-            dir_Meas = self.workingDir
-            compMeas.append(SubBasin(dateBegin, dateEnd, deltaT, cst.compare_opti, dir_Meas))
-            _,compMeas[iOpti].myHydro = compMeas[iOpti].get_hydro(1, workingDir=dir_Meas, fileNames=compareFileName)
+        
+        compMeas = list(self.compareSubBasins.values())
 
         # Construction of the wx window for plot
         figure = Figure(figsize=(5, 4), dpi=100)
@@ -925,6 +936,42 @@ class Optimisation(wx.Frame):
             print("ERROR: in the Fotran routine in the optimizer computation!")
 
 
+    def evaluate_model_optimizer(self, parameters:np.array, idOpti:int=1):
+
+        self.dllFortran.evaluate_model_optimizer_py.restype = ct.c_double
+        self.dllFortran.evaluate_model_optimizer_py.argtypes = [ct.POINTER(ct.c_int),
+                                                                ct.POINTER(ct.c_int),
+                                                                ct.POINTER(ct.c_double)]
+
+        dims = np.array([len(parameters)], dtype=ct.c_int, order='F')
+        p = np.array(parameters, dtype=ct.c_double, order='F')
+
+        pointerDims = dims.ctypes.data_as(ct.POINTER(ct.c_int))
+        pointer_p = p.ctypes.data_as(ct.POINTER(ct.c_double))
+
+        print("Launch a Fortran procedure")
+        obj_fct = self.dllFortran.evaluate_model_optimizer_py(ct.byref(ct.c_int(idOpti)), 
+                                                           pointerDims,
+                                                           pointer_p)
+        print("End of Fortran procedure")
+
+        return obj_fct
+
+
+    def write_mesh_results_optimizer(self, idOpti:int=1):
+
+        self.dllFortran.write_mesh_results_optimizer_py.restype = ct.c_int
+        self.dllFortran.write_mesh_results_optimizer_py.argtypes = [ct.POINTER(ct.c_int)]
+
+
+        print("Launch a Fortran procedure")
+        isOk = self.dllFortran.write_mesh_results_optimizer_py(ct.byref(ct.c_int(idOpti)))
+        print("End of Fortran procedure")
+
+        if isOk!=0:
+            print("ERROR: in the Fotran routine in the optimizer computation!")
+
+
     def init_optimizer(self, idForced=-1):
 
         pathPtr = self.workingDir.encode('ansi')
@@ -1227,48 +1274,48 @@ class Optimisation(wx.Frame):
         """
         curCatch:Catchment = self.myCases[idLauncher].refCatchment
 
-        if (self.optiParam.get_group("Semi-Distributed"))is not None:
+        # if (self.optiParam.get_group("Semi-Distributed"))is not None:
+        try:
             nbRefs = self.optiParam.get_param("Semi-Distributed","nb")
             onlyOwnSub = self.optiParam.get_param("Semi-Distributed", "Own_SubBasin")
             if onlyOwnSub is None:
                 onlyOwnSub = False
             doneList = []
-            sortJct = []
-            readDict = {}
             previousLevel = 1
-            # Read all ref data
-            for iRef in range(1, nbRefs+1):
-                stationOut = self.optiParam.get_param("Semi-Distributed","Station measures "+str(iRef))
-                compareFileName = self.optiParam.get_param("Semi-Distributed","File reference "+str(iRef))
-                readDict[stationOut] = compareFileName
-            self.compareFilesDict = readDict
+            # Collect sort and save the compare stations
+            self.set_compare_stations(idLauncher=idLauncher)
+            sortJct = self.myStations
+            readDict = self.compareFilesDict
             # Get the initial number of intervals 
             # -> these can evolve according to the measurement available at each station
-            # FIXME : finish to generalise this part
+            is_ok = self._save_opti_intervals()
+            if is_ok<0:
+                logging.error("Problem in optimisation intervals! Optimisation abort !")
+                return
+            all_intervals = self.all_intervals
+            simul_intervals = curCatch.simulation_intervals
+            # FIXME : to potentially remove
             nb_comparisons = self.comparHowParam.get_param("Comparison global characteristics","nb")
-            nb_intervals_init = [self.comparHowParam.get_param(" ".join(["Comparison",str(i)]),"nb intervals") for i in range(1,nb_comparisons+1)]
+            nb_intervals_init = len(self.all_intervals)
             # Get the number of attempts with random initial conditions and from the best parameters for each station
             # The total number of iterations per station is the product of these two numbers :
             # nb_iter total = nb_iter_from_random * nb_iter_from_best
             nb_iter_from_random = self.optiParam.get_param("Optimizer","nb iter from random initial conditions",default_value=1)
             nb_iter_from_best = self.optiParam.get_param("Optimizer","nb iter from best",default_value=1)
-            # Check the initial parameters and if they are forced 
-            init_params = self.get_initial_parameters()
-            # Sort all the junctions by level
-            sortJct = curCatch.sort_level_given_junctions(list(readDict.keys()), changeNames=False)
-            self.myStations = sortJct
 
             for iOpti in range(len(sortJct)):
                 stationOut = sortJct[iOpti]
-                compareFileName = readDict[stationOut]
-                # Copy the correct compare.txt file
-                shutil.copyfile(os.path.join(self.workingDir,compareFileName), os.path.join(self.workingDir,"compare.txt"))
+                # 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
-                # self.select_opti_intervals(stationOut)
+                # 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)
+                is_ok = self._save_opti_intervals(stationOut=stationOut, intervals=cur_intervals)
+                
                 # Rename the result file
                 self.optiParam.change_param("Optimizer", "fname", stationOut)
                 self.optiParam.SavetoFile(None)
@@ -1276,6 +1323,11 @@ class Optimisation(wx.Frame):
                 self.update_myParams(idLauncher)
                 # Prepare the paramPy dictionnary before calibration
                 self.prepare_calibration_timeDelay(stationOut=stationOut)
+                # Prepare the potential discontinuous simulation
+                # FIXME : to potentially uncomment or removed : probably remove because we want to generate the complete event simulations to progress in the optimisation
+                # self.prepare_simulation(opti_intervals=cur_intervals, idLauncher=idLauncher)
+                # Check the initial parameters and if they are forced 
+                init_params = self.get_initial_parameters()
                 ## loop on the number of different optimisation attempt we would like for each station
                 best_params_overall = None
                 cur_i = 0
@@ -1309,6 +1361,8 @@ class Optimisation(wx.Frame):
                         cur_i += 1
                 # Apply the best parameters overall attemps
                 self.apply_optim(None,optim_params=best_params_overall)
+                # Reset the init parameters
+                self.reset_init_params(init_params)
                 # copy the optimisation results to save it on the disk
                 shutil.copyfile(os.path.join(self.workingDir, stationOut+"_"+str(i_best_overal+1)+".rpt.dat"), 
                                 os.path.join(self.workingDir, stationOut+".rpt.dat"))
@@ -1318,16 +1372,36 @@ class Optimisation(wx.Frame):
                 
                 # Simulation with the best parameters
                 self.compute_distributed_hydro_model()
+                cur_p = best_params_overall[:-1]
+                cur_obj = best_params_overall[-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")
                 # 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)
+                # reset the simulation intervals to their initial values
+                # FIXME : to potentially uncomment or removed : probably remove because we want to generate the complete event simulations to progress in the optimisation
+                # self.reset_simulation_intervals(simul_intervals, idLauncher=idLauncher)
                 # All upstream elements of a reference will be fixed
                 doneList.append(stationOut)
                 previousLevel = curCatch.levelOut
 
+            # Reset the optimisation file
+            self.save_opti_dates_to_file(self.all_intervals)
+        except:
+            print(traceback.format_exc())
+            logging.error("A problem occured ! Semi-distributed optimisation abort !")
+            # Reset the optimisation file
+            self.save_opti_dates_to_file(self.all_intervals)
+            # reset the simulation intervals to their initial values
+            # FIXME : to potentially uncomment or removed : probably remove because we want to generate the complete event simulations to progress in the optimisation
+            self.reset_simulation_intervals(simul_intervals, idLauncher=idLauncher)
+
         # Possibility to use the optimisation results enabled
         self.enable_MenuBar("Tools")
 
@@ -1606,13 +1680,21 @@ class Optimisation(wx.Frame):
         curCatch:Catchment
 
         curCatch = self.myCases[idLauncher].refCatchment
+        launcher_param = self.myCases[idLauncher].launcherParam
+
         for i in range(1,self.nbParams+1):
             curParam = "param_" + str(i)
-            self.myParams[i]["junction_name"] = curCatch.junctionOut
+
+            sorted_id = int(launcher_param.get_param(curParam, "Subbasin id", default_value=0))
+            if sorted_id == 0:
+                self.myParams[i]["junction_name"] = curCatch.junctionOut
+            else:
+                cur_id = list(curCatch.dictIdConversion.keys())[list(curCatch.dictIdConversion.values()).index(sorted_id)]                   
+                self.myParams[i]["junction_name"] = curCatch.subBasinDict[cur_id].name
 
     
 
-    ## Function to determine the 
+    ## Function to determine the compare stations, compare files and the compare station SubBasin objects for each station
     def set_compare_stations(self, idLauncher):
 
         if (self.optiParam.get_group("Semi-Distributed"))!=None:
@@ -1628,6 +1710,19 @@ class Optimisation(wx.Frame):
             self.compareFilesDict = readDict
             # Sort all the junctions by level
             self.myStations = refCatch.sort_level_given_junctions(list(readDict.keys()), changeNames=False)
+            # Prepare the SubBasin compare objects for each station.
+            self.compareSubBasins = {stationOut: SubBasin(name=stationOut, _model=cst.compare_opti, _workingDir=self.workingDir) 
+                                     for stationOut in self.myStations}
+            # This loop read all the measure and init the hydro surface of each SubBasin element
+            for key, cur_obj in self.compareSubBasins.items():
+                tmp, cur_obj.myHydro = cur_obj.get_hydro(1, workingDir=self.workingDir, fileNames=readDict[key])
+                keyBasin = refCatch.get_key_catchmentDict(key)
+                cur_basin = refCatch.catchmentDict[keyBasin]
+                cur_obj.surfaceDrained = cur_basin.surfaceDrainedHydro
+                cur_obj.surfaceDrainedHydro = cur_basin.surfaceDrainedHydro
+                cur_obj.compute_hydro()
+                # FIXME : generalise this verification or allow the measurements to adapt or build themselves correctly !!!
+                # assert cur_obj.dateBegin==refCatch.dateBegin and cur_obj.dateEnd==refCatch.dateEnd, "The measures and simulations does not have compatible intervals!"
 
 
     def destroyOpti(self, event):
@@ -1774,43 +1869,69 @@ class Optimisation(wx.Frame):
                 doneList.append(stationOut)
 
 
-    def read_all_attempts_SA(self, format="rpt"):
+    def read_all_attempts_SA(self, format="rpt", all_attempts=False, filter_repetitions=True):
+
         nameTMP = self.optiParam.get_param("Optimizer","fname")
+        if all_attempts:
+            nb_iter_from_random = self.optiParam.get_param("Optimizer","nb iter from random initial conditions",
+                                                       default_value=1)
+            nb_iter_from_best = self.optiParam.get_param("Optimizer","nb iter from best",
+                                                     default_value=1)
+            nb_attempts = nb_iter_from_random * nb_iter_from_best
+            all_names = [nameTMP+"_"+str(i+1) for i in range(nb_attempts)]
+        else:
+            all_names = [nameTMP]
+
+        matrixParam = np.empty((0, self.nbParams), dtype="double")
+        vectorObjFct = np.empty((0,), dtype="double")
 
         if format=="rpt":
-            optimFile = os.path.join(self.workingDir, nameTMP+".rpt")
+            for cur_file in all_names:
+                optimFile = os.path.join(self.workingDir, cur_file+".rpt")
 
-            try:
-                with open(optimFile, newline = '') as fileID:
-                    data_reader = csv.reader(fileID, delimiter='|',skipinitialspace=True, )
-                    list_param = []
-                    list_ObjFct = []
-                    line = 0
-                    for raw in data_reader:
-                        if(line<3): 
+                try:
+                    with open(optimFile, newline = '') as fileID:
+                        data_reader = csv.reader(fileID, delimiter='|',skipinitialspace=True, )
+                        list_param = []
+                        list_ObjFct = []
+                        line = 0
+                        for raw in data_reader:
+                            if(line<3): 
+                                line += 1
+                                continue
+                            if(len(raw)<=1):
+                                break
+                            else:
+                                usefulData = raw[2:-2]
+                                list_param.append(usefulData)
+                                list_ObjFct.append(raw[-2])
                             line += 1
-                            continue
-                        if(len(raw)<=1):
-                            break
-                        else:
-                            usefulData = raw[2:-2]
-                            list_param.append(usefulData)
-                            list_ObjFct.append(raw[-2])
-                        line += 1
-                matrixParam = np.array(list_param).astype("float")
-                vectorObjFct = np.array(list_ObjFct).astype("float")
-            except:
-                wx.MessageBox(_('The best parameters file is not found!'), _('Error'), wx.OK|wx.ICON_ERROR)
+                    matrixParam = np.vstack((matrixParam,
+                                            np.array(list_param).astype("double")))
+                    vectorObjFct = np.append(vectorObjFct, 
+                                            np.array(list_ObjFct).astype("double"))
+                except:
+                    wx.MessageBox(_('The best parameters file is not found!'), _('Error'), wx.OK|wx.ICON_ERROR)
         
         elif format==".dat":
-            optimFile = os.path.join(self.workingDir, nameTMP+".rpt.dat")
-            isOk, optimFile = check_path(optimFile)
-            if isOk>0:
-                allData = read_bin(self.workingDir, nameTMP+".rpt.dat", uniform_format=8)
-                allData = np.array(allData).astype("float")
-                matrixParam = allData[:-1,:-1]
-                vectorObjFct = allData[:-1,-1]
-
+            for cur_file in all_names:
+                optimFile = os.path.join(self.workingDir, cur_file+".rpt.dat")
+                isOk, optimFile = check_path(optimFile)
+                if isOk>0:
+                    allData = read_bin(self.workingDir, cur_file+".rpt.dat", uniform_format=8)
+                    allData = np.array(allData).astype("double")
+                    matrixParam = np.vstack((matrixParam, allData[:-1,:-1]))
+                    vectorObjFct = np.append(vectorObjFct, allData[:-1,-1])
+
+        if filter_repetitions:
+            logging.info("Filtering the repetitions in the attempts!")
+            filter_matrix, indices, inverse, counts = np.unique(matrixParam, axis=0, 
+                                                                return_index=True, 
+                                                                return_inverse=True, 
+                                                                return_counts=True)
+            vectorObjFct = vectorObjFct[indices]
+            matrixParam = filter_matrix
+            logging.info("The max number of repetitions = "+ str(np.max(counts)))
         
         return matrixParam, vectorObjFct
     
@@ -1819,36 +1940,46 @@ class Optimisation(wx.Frame):
 
         refCatch:Catchment = self.myCases[idLauncher].refCatchment
         myModel = refCatch.myModel
-        filePath = os.path.join(refCatch.workingDir, "Subbasin_" + str(refCatch.myEffSortSubBasins[0]) + "\\")
-
-        myModelDict = cste.modelParamsDict[myModel]["Parameters"]
 
         if self.curParams_vec_F is None \
-           or len(self.curParams_vec_F) != self.nbParams:
+            or len(self.curParams_vec_F) != self.nbParams:
+
             self.curParams_vec_F = np.empty((self.nbParams,), dtype=ct.c_double, order='F')
+        
+        myModelDict = cste.modelParamsDict[myModel]["Parameters"]
+        
+        for cur_effsub in range(len(refCatch.myEffSubBasins)):
 
-        for i in range(self.nbParams):
-            myType = self.myParams[i+1]["type"]
-            if(int(myType)>0):
-                self.myParams[i+1]["value"] = params[i]
-                fileName = myModelDict[int(myType)]["File"]
-                myGroup = myModelDict[int(myType)]["Group"]
-                myKey = myModelDict[int(myType)]["Key"]
-                if "Convertion Factor" in myModelDict[int(myType)]:
-                    convFact = myModelDict[int(myType)]["Convertion Factor"]
+            filePath = os.path.join(refCatch.workingDir, "Subbasin_" + str(refCatch.myEffSortSubBasins[cur_effsub]))
+
+            for i in range(self.nbParams):
+                myType = self.myParams[i+1]["type"]
+                if(int(myType)>0):
+                    # If the parameter is not for the current effective subbasin
+                    # then we skip it
+                    if "junction_name" in self.myParams[i+1]:
+                        cur_sub = refCatch.catchmentDict[refCatch.get_key_catchmentDict(self.myParams[i+1]["junction_name"])]
+                        if cur_sub.iDSorted != refCatch.myEffSortSubBasins[cur_effsub]:
+                            continue
+                    self.myParams[i+1]["value"] = params[i]
+                    fileName = myModelDict[int(myType)]["File"]
+                    myGroup = myModelDict[int(myType)]["Group"]
+                    myKey = myModelDict[int(myType)]["Key"]
+                    if "Convertion Factor" in myModelDict[int(myType)]:
+                        convFact = myModelDict[int(myType)]["Convertion Factor"]
+                    else:
+                        convFact = 1.0
+                    tmpWolf = Wolf_Param(to_read=True, filename=os.path.join(filePath,fileName),toShow=False, init_GUI=False)
+                    tmpWolf.change_param(myGroup, myKey, params[i]/convFact)
+                    tmpWolf.SavetoFile(None)
+                    # tmpWolf.OnClose(None)
+                    tmpWolf = None
                 else:
-                    convFact = 1.0
-                tmpWolf = Wolf_Param(to_read=True, filename=filePath+fileName,toShow=False)
-                tmpWolf.myparams[myGroup][myKey]["value"] = params[i]/convFact
-                tmpWolf.SavetoFile(None)
-                tmpWolf.OnClose(None)
-                tmpWolf = None
-            else:
-                
-                self.curParams_vec_F[i] = params[i]
-                self.update_timeDelay(i+1)
-                refCatch.save_timeDelays([self.myParams[i+1]["junction_name"]])
-                print("TO DO : Complete the python parameter dict!!!!!!!")
+                    
+                    self.curParams_vec_F[i] = params[i]
+                    self.update_timeDelay(i+1)
+                    refCatch.save_timeDelays([self.myParams[i+1]["junction_name"]])
+                    print("TO DO : Complete the python parameter dict!!!!!!!")
 
 
 
@@ -1884,7 +2015,7 @@ class Optimisation(wx.Frame):
             nb_params = int(paramDict.get_param("Paramètres à varier", "Nombre de paramètres à varier"))
 
             myModel = self.myCases[idLauncher].refCatchment.myModel
-            nbParamsModel = cste.modelParamsDict[myModel]["Nb"]
+            nbParamsModel = cste.modelParamsDict[myModel]["Nb"]*len(cur_opti.refCatchment.myEffSubBasins)
             
             for i in range(1,nb_params+1):
                 curParam = "param_" + str(i)
@@ -1894,41 +2025,214 @@ class Optimisation(wx.Frame):
                     nb_params -= 1
 
             # Test
+            # assert nb_params > nbParamsModel, "The number of parameters to optimize is not equal to the number of parameters of the model!"
             if nb_params >  nbParamsModel:
                 logging.error("The number of to optimise are greater than the number of max parameter of the model!! ")
+                assert nb_params > nbParamsModel, "The number of parameters to optimize is not equal to the number of parameters of the model!"
                 return
 
             self.myCases[idLauncher].launcherParam.change_param("Paramètres à varier", "Nombre de paramètres à varier", nb_params)
 
             return
     
+
+    def _read_opti_intervals(self, idLauncher:int=0)->list[tuple[datetime.datetime, datetime.datetime]]:
+        """
+        .. todo::
+            - Add the measure of the comparison file in properties of the object opti
+            - Check according to the current Observation, which comparision intervals are posssible -> and sort them
+            - Save the comparison intervals somewhere
+            - Save the useful comparison intervals somewhere
+            - Return the useful intervals.
+        """
+        # file_compare = os.path.join(self.workingDir,"compare.txt")
+        # isOk, file_compare = check_path(file_compare)
+        # if isOk<0:
+        #     logging.error("The file compare.txt is not found!")
+        #     return
+        
+        # Read the comparison file
+        if self.myStations==[]:
+            self.set_compare_stations(idLauncher=idLauncher)
+
+        nb_comparison = self.comparHowParam.get_param("Comparison global characteristics", "nb")
+        str_di = "date begin"
+        str_df = "date end"
+        
+        intervals = []
+        for icomp in range(1, nb_comparison+1):
+            cur_key = " ".join(["Comparison", str(icomp)])
+            nb_intervals = self.comparHowParam.get_param(cur_key, "nb intervals")
+            for i_inter in range(1,nb_intervals+1):
+                str_read = self.comparHowParam.get_param(cur_key, " ".join([str_di,str(i_inter)]))
+                di = datetime.datetime.strptime(str_read, cst.DATE_FORMAT_HYDRO).replace(tzinfo=datetime.timezone.utc)
+                str_read = self.comparHowParam.get_param(cur_key," ".join([str_df,str(i_inter)]))
+                df = datetime.datetime.strptime(str_read, cst.DATE_FORMAT_HYDRO).replace(tzinfo=datetime.timezone.utc)
+                # Check that di is a timestamp lower than other date #FIXME : to be transfer in a test function !!!!
+                if di>df:
+                    logging.error("The date end is lower than the date begin!")
+                    return None
+                else:
+                    intervals.append((di,df))
+
+
+        return intervals
+    
+
+    def _save_opti_intervals(self, idLauncher:int=0, stationOut:str="", 
+                             intervals:list[tuple[datetime.datetime, datetime.datetime]]=None)->int:
+        if stationOut == "":
+            suffix = "0"
+        else:
+            suffix = stationOut
+        
+        if intervals is None:
+            self.all_intervals = self._read_opti_intervals(idLauncher=idLauncher)
+
+        compare_file = os.path.join(self.workingDir,"compare.how.param")
+
+        # In case of a problem, the initial compare file is copied
+        compare_file_cp = os.path.join(self.workingDir,"compare.how_"+suffix+"_tmp.param")
+        isOk, compare_file_cp = check_path(compare_file_cp)
+        if isOk<0 and stationOut=="":
+            compare_file_cp = os.path.join(self.workingDir,"compare.how_"+suffix+".param")
+            shutil.copyfile(compare_file, compare_file_cp)
+            print("The following file has been copied : ", compare_file_cp)
+        else:
+            shutil.copyfile(compare_file, compare_file_cp)
+            print("The following file has been copied : ", compare_file_cp)
+
+        if self.all_intervals is None:
+            return -1
+        else:
+            return 0
     
-    def select_opti_intervals(self, idLauncher:int=0, stationOut=""):
+
+    def select_opti_intervals(self, all_intervals:list[tuple[datetime.datetime, datetime.datetime]]=None,
+                              idLauncher:int=0, stationOut="", filter_nan:bool=True)->list[tuple]:
+        """
+        .. todo::
+            - Add the measure of the comparison file in properties of the object opti
+            - Check according to the current Observation, which comparision intervals are posssible -> and sort them
+            - Save the comparison intervals somewhere
+            - Save the useful comparison intervals somewhere
+            - Return the useful intervals.
+        """
         cur_opti = self.myCases[idLauncher]
         cur_ref = cur_opti.refCatchment
+        
         if stationOut == "":
             stationOut = cur_ref.junctionOut
-        file_compare = os.path.join(self.workingDir,"compare.txt")
-        isOk, file_compare = check_path(file_compare)
-        if isOk<0:
-            logging.error("The file compare.txt is not found!")
-            return 
-        meas_hydro = SubBasin()
+
+        if all_intervals is None:
+            if self.all_intervals is None:
+                logging.error("The intervlas are not defined! Please add them in the function arguments or use the funcion '_save_opti_intervals()' to save them internally (at your own risk!)")
+                # id_ok= self._save_opti_intervals(idLauncher=idLauncher)
+                # if id_ok<0:
+                #     return None
+                
+            else:
+                all_intervals = self.all_intervals
+
+        if self.myStations==[]:
+            self.set_compare_stations(idLauncher=idLauncher)
+        
+        keyBasin = cur_ref.get_key_catchmentDict(stationOut)
+        cur_basin = cur_ref.catchmentDict[keyBasin]
+
+        # Select the optimisation intervals that are relevant according to the available measures
+        effective_intv = [interv for interv in all_intervals if interv[0]>=cur_basin.dateBegin and interv[1]<=cur_basin.dateEnd]
+        if filter_nan:
+            effective_intv = self._define_intervals_with_nan_measures(effective_intv, self.compareSubBasins, 
+                                                                      idLauncher=idLauncher, stationOut=stationOut)
+
+        return effective_intv
+    
+    
+    def _define_intervals_with_nan_measures(self, intervals: list[tuple[datetime.datetime, datetime.datetime]], measures: dict[str, SubBasin], 
+                                            idLauncher: int = 0, stationOut: str = ""):
+        """
+        Defines new intervals excluding all NaN measures based on the given intervals and measures dictionary.
+        For instance, if there is continuous NaN measures within a given interval, the function will split  
+        that interval into smaller that do not contain NaN measures.
+
+        Args:
+            intervals (list[tuple[datetime.datetime, datetime.datetime]]): A list of intervals represented as tuples of start and end datetime objects.
+            measures (dict[str, SubBasin]): A dictionary of measures where the keys are station names and the values are SubBasin objects.
+            idLauncher (int, optional): The id of the launcher. Defaults to 0.
+            stationOut (str, optional): The station name. Defaults to "".
+
+        Returns:
+            list[tuple[datetime.datetime, datetime.datetime]]: A list of intervals with NaN measures.
+
+        Raises:
+            None
+
+        """
+        if stationOut not in measures:
+            logging.error("The stationOut is not in the measures dictionary!")
+            return None
+        
+        cur_el = measures[stationOut]
+        hydro = cur_el.get_myHydro()
+        time = cur_el.time
+        # get the indices of the nan values
+        non_nan_locations = ~np.isnan(hydro)
+        within_intervals = np.sum(
+            [(time >= datetime.datetime.timestamp(interv[0])) * 
+             (time <= datetime.datetime.timestamp(interv[1])) 
+             for interv in intervals],
+            axis=0) > 0
+        # Both conditions should be satisfied
+        all_conditions = np.where(non_nan_locations * within_intervals)[0]
+
+        # Check all the discontinuities and the indices they start
+        # i.e. when the index difference is not 1
+        # +1 as the np.diff is one element sooner than nan_locations: diff[0]=v[1]-v[0]
+        group_starts = np.where(np.diff(all_conditions) != 1)[0] + 1
+        
+        # Add 0 as it is the first index of the first group
+        group_starts = np.insert(group_starts, 0, 0)
+
+        # Identify where the groups stop.
+        group_ends = np.append(group_starts[1:] - 1, len(all_conditions)-1)
+
+        # Get the timestamps of the first and last nan element and form groups of discontinuities
+        iterv_timestamp = [(time[all_conditions[i_i]], time[all_conditions[i_f]]) for i_i, i_f in zip(group_starts, group_ends)]
+        interv_dates = [(datetime.datetime.fromtimestamp(iterv[0],tz=datetime.timezone.utc), 
+                         datetime.datetime.fromtimestamp(iterv[1], tz=datetime.timezone.utc))
+                         for iterv in iterv_timestamp]
+
+        return interv_dates
+    
+
+    def save_opti_dates_to_file(self, opti_dates:list[tuple[datetime.datetime,datetime.datetime]]):
+        """
+        Here the procedure is saving the intervals of dates for calibration in the compare.how.param
+        """
+        # Verifications 
+        assert len(opti_dates)>0, "The list of dates is empty!"
+        for i_opti in opti_dates:
+            assert i_opti[1]>i_opti[0], "The start date is not lower than the end date!"
 
         nb_comparison = self.comparHowParam.get_param("Comparison global characteristics", "nb")
+
         str_di = "date begin"
         str_df = "date end"
-        for icomp in range(1, nb_comparison):
-            cur_key = " ".join("Comparison", str(icomp))
-            nb_intervals = self.comparHowParam.get_param(cur_key, "nb_intervals")
-            for i_inter in range(1,nb_intervals):
-                str_read = self.comparHowParam.get_param(" ".join(str_di,str(i_inter)))
-                di = datetime.datetime.timestamp(
-                    datetime.datetime.strptime(str_read, cst.DATE_FORMAT_HYDRO).replace(tzinfo=datetime.timezone.utc))
-                str_read = self.comparHowParam.get_param(" ".join(str_df,str(i_inter)))
-                df = datetime.datetime.timestamp(
-                    datetime.datetime.strptime(str_read, cst.DATE_FORMAT_HYDRO).replace(tzinfo=datetime.timezone.utc))
-                # Check that di is a timestamp lower than other date 
+
+        for icomp in range(1, nb_comparison+1):
+            cur_key = " ".join(["Comparison", str(icomp)])
+            nb_intervals = len(opti_dates)
+            self.comparHowParam.change_param(cur_key, "nb intervals", nb_intervals)
+            for i_inter in range(1,nb_intervals+1):
+                di = datetime.datetime.strftime(opti_dates[i_inter-1][0], cst.DATE_FORMAT_HYDRO)
+                df = datetime.datetime.strftime(opti_dates[i_inter-1][1], cst.DATE_FORMAT_HYDRO)
+                # FIXME : Change addparam to add_param
+                self.comparHowParam.addparam(cur_key, " ".join([str_di,str(i_inter)]), di, type="str")
+                self.comparHowParam.addparam(cur_key, " ".join([str_df,str(i_inter)]), df, type="str")
+
+        self.comparHowParam.SavetoFile(None)
+        self.comparHowParam.Reload(None)
 
 
     def prepare_init_params_from_best(self, best_params:np.array, idLauncher:int=0):
@@ -1959,8 +2263,635 @@ class Optimisation(wx.Frame):
             init_params = None
         
         return init_params
+    
+
+    def reset_init_params(self, init_params:np.array):
+        if init_params is None:
+            return
+        for i in range(self.nbParams):
+            self.saParam.change_param("Initial parameters", " ".join(["Parameter",str(i+1)]), init_params[i])
+        print("Reset init params : ", init_params)
+        self.saParam.SavetoFile(None)
+        self.saParam.Reload(None)
+    
+
+    def extract_internal_variables(self, event, idLauncher:int=0, to_plot:bool=True):
+        curCatch:Catchment = self.myCases[idLauncher].refCatchment
+
+        ## Check the relevance to launch the detailed simulation to extract the internal variables
+        all_x = curCatch.get_all_x_production()
+        all_iv = curCatch.get_all_iv_production()
+        # Graphical interface to ask the user if he wants to launch the detailed simulation
+        if all_x=={} or all_iv=={}:
+            to_generate = True
+            if self.wx_exists:
+                dlg = wx.MessageDialog(None, "No internal variables were detected! Do you want to launch a detailed simulation ?", "Warning", wx.YES_NO | wx.NO_DEFAULT | wx.ICON_QUESTION)
+                r = dlg.ShowModal()
+                if r == wx.ID_YES:
+                    to_generate = True
+                    dlg.Destroy()
+                else:
+                    dlg.Destroy()
+                    return None
+            else:
+                to_generate = True
+        else:
+            to_generate = False
+            if self.wx_exists:
+                dlg = wx.MessageDialog(None, "Internal variables were detected! Do you still want to launch a detailed simulation ?", "Warning", wx.YES_NO | wx.NO_DEFAULT | wx.ICON_QUESTION)
+                r = dlg.ShowModal()
+                if r == wx.ID_YES:
+                    to_generate = True                
+                dlg.Destroy()
+                # FIXME :  ADD the terminal
+            else:
+                to_generate = False
+        # Enter here if a detailed simulation is required
+        if to_generate:
+            curCatch.activate_all_internal_variables()
+            self.generate_semiDist_optim_simul(None, idLauncher=idLauncher)           
+            all_x = curCatch.get_all_x_production()
+            all_iv = curCatch.get_all_iv_production()
+
+        effective_intv = self.select_opti_intervals(idLauncher=idLauncher, stationOut="")
+        all_Nash = {"Nash" : self.get_all_Nash()}
+        all_frac = curCatch.get_all_fractions(summary="mean", summary_interval=effective_intv, add_info=all_Nash)
+
+
+        if to_plot:
+            for interv in effective_intv:
+                all_frac = curCatch.plot_all_fractions(all_fractions=all_frac, to_show=True, range_data=list(interv))
+
+        return all_x, all_iv, all_frac
+        
+
+    def _check_presence_of_iv(self, idLauncher:int=0):
+        curCatch:Catchment = self.myCases[idLauncher].refCatchment
+        return curCatch.check_presence_of_iv()
+        
+    
+    def plot_Nash_vs_Qexcess(self, event, idLauncher:int=0):
+        curCatch:Catchment = self.myCases[idLauncher].refCatchment
+        all_params, all_nash = self.read_all_attempts_SA(format=".dat")
+        nb_tests = np.shape(all_nash)[0]
+        
+        if self.myStations==[]:
+            self.set_compare_stations(idLauncher=idLauncher)
+
+        compMeas = []
+        for iOpti in range(len(self.myStations)):
+            dateBegin = curCatch.dateBegin
+            dateEnd = curCatch.dateEnd
+            deltaT = curCatch.deltaT # [sec]
+            stationOut = self.myStations[iOpti]
+            compareFileName = self.compareFilesDict[stationOut]
+            dir_Meas = self.workingDir
+            compMeas.append(SubBasin(dateBegin, dateEnd, deltaT, cst.compare_opti, dir_Meas))
+            _,cur_comp = compMeas[iOpti].get_hydro(1, workingDir=dir_Meas, fileNames=compareFileName)
+            keyBasin = curCatch.get_key_catchmentDict(stationOut)
+            cur_basin = curCatch.catchmentDict[keyBasin] 
+            cur_comp = cur_comp*cur_basin.surfaceDrained/3.6
+            all_qtests = curCatch.get_all_Qtest(nb_atttempts=nb_tests, selection_by_iD=[stationOut])
+            # FIXME : Check the type of interpolation to use
+            interp_qcomp = np.interp(curCatch.time, compMeas[iOpti].time, cur_comp)
+            q_diff = np.array([np.count_nonzero((qtest-interp_qcomp <0.0) & (qtest != 0.0))/np.count_nonzero((qtest != 0.0)) 
+                               for qtest in all_qtests[0]])
+            fig, ax = plt.subplots()
+            for i in range(nb_tests-1):
+                ax.scatter(q_diff[i], all_nash[i], s=0.5, c='b', marker='o', alpha=i/nb_tests)
+            ax.scatter(q_diff[-1], all_nash[-1], s=0.5, c='b', marker='o', label="test", alpha=1)  
+            # ax.scatter(q_diff, all_nash, s=0.5, c='b', marker='o', label="test")
+            ax.set_xlabel("Non-exceedance fraction. Portion of the observations below the simulated series (Qs>Qo)")
+            ax.set_ylabel("Nash-Sutcliffe efficiency")
+            ax.set_ylim(1.0, -1.0)
+            ax.set_xlim(0.0, 1.0)
+
+            i_best = np.argmax(all_nash)
+
+            ax.scatter(q_diff[i_best], all_nash[i_best], color='red', s=30, label="Best Nash")
+            ax.set_title("2000-2011 GR4H "+stationOut)
+            ax.legend()
+            fig.savefig(os.path.join(curCatch.workingDir, "PostProcess/Nash_vs_Qexcess_"+stationOut+".png"))
+
         
+        plt.show()
+
+
+    def get_all_Nash(self):
                 
+        return {cur_file: self.collect_optim(cur_file)[-1] for cur_file in self.myStations}
+    
+    # FIXME this function is not correct -> to be corrected and delete the remove_py_params and updtate_myParams calls
+    def get_all_params(self, idLauncher:int=0):
+        curCatch:Catchment = self.myCases[idLauncher].refCatchment
+
+        hydro_model = curCatch.myModel
+        
+        # Read the comparison file
+        if self.myStations==[]:
+            self.set_compare_stations(idLauncher=idLauncher)
+
+        calibrate_timeDelay = bool(int(self.optiParam.get_param("Semi-Distributed", "Calibrate_times")))
+        myModelDict = cste.modelParamsDict[hydro_model]["Parameters"]
+
+        all_names = {}
+        for stationOut in self.myStations:
+            curCatch.define_station_out(stationOut)
+            self.remove_py_params(idLauncher)
+            self.update_myParams(idLauncher)
+
+            id_params = [self.myParams[i]["type"] for i in range(1,self.nbParams+1)]
+            names = [myModelDict[cur_id]["Name"] for cur_id in id_params if cur_id>0]
+            all_names[stationOut] = names
+            if calibrate_timeDelay:
+                # Get_nb inlets 
+                inletsNames = self.myCases[idLauncher].refCatchment.get_inletsName(stationOut)
+                nbInlets = len(inletsNames)
+                for i in range(nbInlets):
+                    names.append("TimeDelay "+inletsNames[i])
+            # Complete the names according to the stations concerned
+                    
+        optim = {cur_file: self.collect_optim(cur_file) for cur_file in self.myStations}
+
+        # all_params = {}
+        # for key, value in optim.items():
+        #     all_params[key] = {}
+        #     for i, cur_name in enumerate(all_names):
+        #         all_params[key][cur_name] = value[i]
+        
+        all_params = {key: 
+                      {cur_name : value[i] for i, cur_name in enumerate(all_names)}
+                      for key, value in optim.items()}
+
+        return all_params
+    
+    
+    def save_all_params(self, all_params:dict={}, idLauncher:int=0):
+        
+        all_keys = list(all_params.keys())
+       
+        return 
+    
+
+    def save_current_compare_file(self, stationOut: str):
+        """
+        Save the current compare file for a given station to prepare optimisation with Fortran.
+
+        Args:
+            stationOut (str): The station identifier.
+
+        Returns:
+            None
+
+        Raises:
+            None
+        """
+        compare_file_name = self.compareFilesDict[stationOut]
+        cur_sub = self.compareSubBasins[stationOut]
+
+        time = cur_sub.time
+        hydro = cur_sub.get_myHydro()
+        hydro = np.nan_to_num(hydro, nan=0.0)
+
+        data = np.column_stack((time, hydro))
+        # Define header
+        header = f"{data.shape[0]:d}\t{data.shape[1]:d}"
+        # Write to file
+        np.savetxt(
+            os.path.join(self.workingDir, "compare.txt"),
+            data,
+            header=header,
+            fmt=["%d", "%e"],
+            comments="",
+            delimiter="\t",
+        )
+    
+    
+    def prepare_simulation(self, opti_intervals:list[tuple[datetime.datetime, datetime.datetime]],
+                           idLauncher:int=0):
+        
+        cur_catch = self.myCases[idLauncher].refCatchment
+        # TODO : Create an object hydro intervals with activate property and a method to retrun a list of tuples
+        simul_intevals = cur_catch.simulation_intervals
+        # See which simulation intervals should be activated
+        eff_simul_intervals = []
+        for simul_intrv in simul_intevals:
+            to_activate = False
+            for cur_opti_intrv in opti_intervals:
+                if cur_opti_intrv[0]>simul_intrv[0] and cur_opti_intrv[1]<simul_intrv[1]:
+                    to_activate = True
+                    break
+            if to_activate:
+                eff_simul_intervals.append(simul_intrv)
+        
+        cur_catch.simulation_intervals = eff_simul_intervals
+        
+        return
+    
+
+    def reset_simulation_intervals(self, default_interval:list[tuple[datetime.datetime, datetime.datetime]], 
+                                   idLauncher:int=0):
+        
+        cur_catch = self.myCases[idLauncher].refCatchment
+        cur_catch.simulation_intervals = default_interval
+
+        return
+        
+    # FIXME : this function has been dashed off -> functionnal but not well written!!
+    # TODO : to improve !!!!!!
+    def test_equifinality_with_Nash(self, event, idLauncher:int=0, idOpti:int=1, quantile_Nash:float=0.6, std_Nash:float=0.02, clustering_Nash:bool=True):
+        """
+        Test the equifinality of the model.
+
+        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, apply_clustering=clustering_Nash)
+            ## =======
+            ## Compute 
+            ## =======
+            all_frac = []
+
+            for i in 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_dict = self._get_cur_fractions(idLauncher=idLauncher, stationOut=stationOut, intervals=cur_intervals)
+                cur_all_frac = list(frac_dict.values())
+                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 + cur_all_frac + [p_excess, max_sim_obs, cur_obj]
+                all_frac.append(cur_all_frac)
+
+            # Get param names
+            names = self.get_param_names(idLauncher=idLauncher, stationOut=stationOut)
+            # Save the evaluations
+            var_names = names + list(all_timeDelays_str.keys()) + list(frac_dict.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!")
+        
+
+    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        
+        """
+        Get the best parameters for a given station.
+
+        Args:
+            stationOut (str): The station identifier.
+            idLauncher (int, optional): The id of the launcher. Defaults to 0.
+
+        Returns:
+            np.array: The best parameters.
+
+        Raises:
+            None
+        """
+
+        best_objfct = self.collect_optim()[-1]
+        all_params, all_obj_fct = self.read_all_attempts_SA(format=".dat", all_attempts=True)
+
+        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]
+        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))
+
+        # 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
+        # and only keep the set of parameter that has the best Nash-Sutcliffe efficiency per group
+        # The parameters that are not grouped are considered had "particular" and are still kept in the final set
+        if apply_clustering:
+            # "Normalise" or scale btw [0;1] the parameter vector to make the clustering more efficient
+            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)
+            db = DBSCAN(eps=eps).fit(norm_params)
+            labels = db.labels_
+            # Extraction of the number of groups and particular cases
+            n_clusters = len(set(labels)) - (1 if -1 in labels else 0)
+            n_noise = list(labels).count(-1)
+            noise_ind = np.where(labels==-1)[0]
+
+            # First extract all the vectors that are grouped and their indices
+            grouped_ind = db.core_sample_indices_
+            grouped_params = eff_params[grouped_ind]
+            grouped_labels = labels[grouped_ind]
+            
+            # Init of the filtered parameters vector
+            filtered_params = np.zeros((n_clusters+n_noise, np.shape(eff_params)[1]))
+            # Loop to determine the best set of parameter per group
+            best_indices_per_group = np.zeros(n_clusters, dtype=int)
+            for i in range(n_clusters):
+                cur_indices = np.where(grouped_labels==i)[0]
+                cur_group = grouped_params[cur_indices]
+                best_indices_per_group[i] = np.argmax(cur_group[:,-1])
+
+            # Keep the best set of parameters per group
+            filtered_params[:n_clusters] = grouped_params[best_indices_per_group]
+            # Keep all the element that could not be grouped
+            filtered_params[n_clusters:] = eff_params[noise_ind]
+
+            return filtered_params
+
+        return eff_params
+    
+
+    # FIXME :  interp function used -> add the method of interpolation as an argument
+    def _get_exceedance(self, idLauncher:int=0, stationOut:str="", 
+                         intervals:list[tuple[datetime.datetime, datetime.datetime]]=[]) -> float:
+        curCatch:Catchment = self.myCases[idLauncher].refCatchment
+        cur_key = curCatch.get_key_catchmentDict(stationOut)
+        curBasin: SubBasin = curCatch.catchmentDict[cur_key]
+
+        simul = curBasin.outFlow
+        measure = self.compareSubBasins[stationOut]
+        compare = np.interp(curCatch.time, measure.time, measure.outFlow)
+
+        if intervals != []:
+            interv = np.zeros(len(curCatch.time), dtype=bool)
+            for el in intervals:
+                date_i = datetime.datetime.timestamp(el[0])
+                date_f = datetime.datetime.timestamp(el[1])
+                interv += (curCatch.time>=date_i) & (curCatch.time<=date_f)
+        else:
+            interv = np.ones(len(curCatch.time), dtype=bool)
+
+        eff_simul = simul[interv]
+        eff_compare = compare[interv]
+
+        q_diff = np.count_nonzero((eff_simul-eff_compare <0.0) & (eff_simul != 0.0))/np.count_nonzero((eff_simul != 0.0))
+
+        return q_diff
+
+    
+    # FIXME :  to improve and generalise
+    def _get_cur_fractions(self, idLauncher:int=0, stationOut:str="", 
+                         intervals:list[tuple[datetime.datetime, datetime.datetime]]=[]) -> dict[list[str], list[float]]:
+        """
+        Save the evaluations of the model.
+
+        Args:
+            idOpti (int, optional): The id of the optimisation. Defaults to 1.
+            stationOut (str, optional): The station identifier. Defaults to "".
+            fct_list (list[str], optional): A list of functions. Defaults to [].
+
+        Returns:
+            None
+
+        Raises:
+            None
+        """
+        curCatch:Catchment = self.myCases[idLauncher].refCatchment
+        cur_key = curCatch.get_key_catchmentDict(stationOut)
+        curBasin: SubBasin = curCatch.catchmentDict[cur_key]
+        cur_fracts = curBasin.get_summary_fractions(summary="mean", interval=intervals)
+
+        return cur_fracts
+    
+
+    def _get_ratio_max_sim_obs(self, idLauncher:int=0, stationOut:str="", 
+                         intervals:list[tuple[datetime.datetime, datetime.datetime]]=[]) -> float:
+        
+        curCatch:Catchment = self.myCases[idLauncher].refCatchment
+        cur_key = curCatch.get_key_catchmentDict(stationOut)
+        curBasin: SubBasin = curCatch.catchmentDict[cur_key]
+        measure = self.compareSubBasins[stationOut]
+
+        if intervals != []:
+            interv_simul = np.zeros(len(curCatch.time), dtype=bool)
+            interv_meas = np.zeros(len(measure.time), dtype=bool)
+            for el in intervals:
+                date_i = datetime.datetime.timestamp(el[0])
+                date_f = datetime.datetime.timestamp(el[1])
+                interv_simul += (curCatch.time>=date_i) & (curCatch.time<=date_f)
+                interv_meas += (measure.time>=date_i) & (measure.time<=date_f)
+        else:
+            interv_simul = np.ones(len(curCatch.time), dtype=bool)
+            interv_meas = np.ones(len(measure.time), dtype=bool)
+
+        simul = curBasin.outFlow[interv_simul]
+        compare = measure.outFlow[interv_meas]
+        ratio = np.nanmax(simul)/np.nanmax(compare)
+        
+        return ratio
+    
+
+    # Here, we condider that the parameters were already sorted, i.e. model parameters first and Python parameters (<0) after
+    def get_param_names(self, idLauncher:int=0, stationOut:str=""):
+        curCatch:Catchment = self.myCases[idLauncher].refCatchment
+        myModelDict = cste.modelParamsDict[curCatch.myModel]["Parameters"]
+        id_params = [self.myParams[i]["type"] for i in range(1,self.nbParams+1)]
+        names = [myModelDict[cur_id]["Name"] for cur_id in id_params if cur_id>0]
+
+        calibrate_timeDelay = bool(int(self.optiParam.get_param("Semi-Distributed", "Calibrate_times")))
+        if calibrate_timeDelay:
+            # Get_nb inlets 
+            inletsNames = self.myCases[idLauncher].refCatchment.get_inletsName(stationOut)
+            nbInlets = len(inletsNames)
+            for i in range(nbInlets):
+                names.append("TimeDelay "+inletsNames[i])
+
+
+        return names
+    
+    # Plot the equifinalty test for each station
+    def plot_equifinality(self, event, idLauncher:int=0):
+
+        physical_properties = ["%qof", "%qif", "%qbf", "%loss"]
+        colors_properties = ["b", "g", "k", "orange"]
+        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):
+
+        i = idLauncher
+        newCase = CaseOpti()
+        launcherDir = self.optiParam.get_param("Cases","dir_"+str(i+1))
+        isOk, launcherDir = check_path(launcherDir, prefix=self.workingDir, applyCWD=True)
+        if isOk<0:
+            print("ERROR : in path of launcherDir")
+        newCase.read_param(launcherDir, copyDefault=False, callback=self.update_parameters_launcher)
+        # FIXME TO CHANGE when seperation with the GUI
+        if self.wx_exists:
+            newId = wx.Window.NewControlId()
+            iMenu = self.MenuBar.FindMenu('Param files')
+            paramMenu = self.MenuBar.Menus[iMenu][0]
+            curName = 'Case '+str(i+1)
+            iItem = self.MenuBar.FindMenuItem('Param files', curName)
+            if(iItem==wx.NOT_FOUND):
+                caseMenu = wx.Menu()
+                paramCaseFile = caseMenu.Append(wx.ID_ANY, 'launcher.param')
+                self.Bind(wx.EVT_MENU, newCase.show_launcherParam, paramCaseFile)
+                guiHydroCase = caseMenu.Append(wx.ID_ANY, 'GUI Hydro')
+                refDir = newCase.launcherParam.get_param("Calculs","Répertoire simulation de référence")
+                isOk, refDir = check_path(refDir, prefix=launcherDir, applyCWD=True)
+                if isOk<0:
+                    print("ERROR : in path of launcherDir")
+                newCase.mydro = HydrologyModel(dir=refDir)
+                newCase.mydro.Hide()
+                self.Bind(wx.EVT_MENU, newCase.show_mydro, guiHydroCase)
+                curCase = paramMenu.Append(newId, curName, caseMenu)
+            else:
+                print("WARNING : this scenario was not implemented yet. This might induce an error!")
+                # iItem = 
+                curCase = paramMenu.Replace(iItem)
+        else:
+            refDir = newCase.launcherParam.get_param("Calculs","Répertoire simulation de référence")
+            isOk, refDir = check_path(refDir, prefix=launcherDir, applyCWD=True)
+            newCase.mydro = HydrologyModel(dir=refDir)
+
+        self.Bind(wx.EVT_MENU, newCase.show_launcherParam, curCase)
+        newCase.idMenuItem = newId
+        self.myCases.append(newCase)
+
+
+
     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
 
@@ -1977,3 +2908,4 @@ class Optimisation(wx.Frame):
             return arr.copy()
         else:
             return arr
+