wolfhece 2.1.128__py3-none-any.whl → 2.2.1__py3-none-any.whl

wolfhece/hydrology/Optimisation.py

@@ -32,8 +32,9 @@ import traceback
 
 
 # %% Constants
-DLL_FILE = "WolfDll.dll"
-DLL_FILE_DEBUG = "WolfDll_debug.dll"
+DLL_FILE = "WolfDll.dll"                # Name of the release DLL
+DLL_FILE_DEBUG = "WolfDll_debug.dll"    # Name of the debug DLL
+DLL_FILE_TEST = "WolfDll_test.dll"      # Name of the test DLL (to deactivate random numbers generation)
 
 
 
@@ -63,7 +64,7 @@ class CaseOpti(GenMapManager):
         # super().__init__(splash=splash, *args, **kw)
 
         self.launcherDir = ""
-        
+
     def read_param(self, dir, copyDefault=False, callback=None, workingDir=""):
 
         self.launcherDir = dir
@@ -131,13 +132,13 @@ class Optimisation(wx.Frame):
     # FIXME : this variable is just there before the seperation between the object optimisation and GUI optimisation
     wx_exists:bool
 
-    def __init__(self, parent=None, title="", w=500, h=500, init_wx=True, debugDLL=False):
+    def __init__(self, parent=None, title="", w=500, h=500, init_wx=True, debugDLL=False, for_test:bool=False):
 
         self.wx_exists = wx.App.Get() is not None # test if wx App is running
 
         if self.wx_exists:
             super(Optimisation, self).__init__(parent, title=title, size=(w,h))
-        
+
         self.debugDLL = debugDLL
 
         self.workingDir = ""
@@ -161,12 +162,15 @@ class Optimisation(wx.Frame):
         if self.debugDLL:
             self.load_dll(self.pathDll, DLL_FILE_DEBUG)
         else:
-            self.load_dll(self.pathDll, DLL_FILE)
+            if for_test:
+                self.load_dll(self.pathDll, DLL_FILE_TEST)
+            else:
+                self.load_dll(self.pathDll, DLL_FILE)
 
         # FIXME
         if self.wx_exists:
             self.initGUI()
-    
+
 
     def initGUI(self):
 
@@ -224,7 +228,7 @@ 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)
-        
+
 
         # Creation of the Lauch Menu
         launchMenu = wx.Menu()
@@ -345,10 +349,10 @@ class Optimisation(wx.Frame):
         self.enable_MenuBar("Param files")
         self.enable_MenuBar("Launch")
 
-    
+
     def load(self, event, workingDir:str="", fileName:str=""):
 
-        # Selection of the main 
+        # Selection of the main
         if workingDir=="":
             idir=wx.FileDialog(None,"Choose an optimatimisation file",wildcard='Fichiers param (*.param)|*.param')
             if idir.ShowModal() == wx.ID_CANCEL:
@@ -369,7 +373,11 @@ class Optimisation(wx.Frame):
         self.optiParam = Wolf_Param(to_read=True, filename=fileOpti, title="test_opti",toShow=False)
         initDir = self.optiParam.get_param("Optimizer","dir")
         isOk, initDir = check_path(initDir, prefix=readDir, applyCWD=True)
-        # 
+
+        if initDir is None:
+            logging.error("ERROR: in path of initDir")
+            return
+        #
         if os.path.samefile(readDir, initDir):
             self.workingDir = initDir
         else:
@@ -409,14 +417,14 @@ class Optimisation(wx.Frame):
                     curCase = paramMenu.Append(newId, curName, caseMenu)
                 else:
                     print("WARNING : this scenario was not implemented yet. This might induce an error!")
-                    # iItem = 
+                    # iItem =
                     curCase = paramMenu.Replace(iItem)
+                self.Bind(wx.EVT_MENU, newCase.show_launcherParam, curCase)
+                newCase.idMenuItem = newId
             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)
 
 
@@ -433,14 +441,15 @@ class Optimisation(wx.Frame):
         self.init_with_default_lumped()
 
         # Let all the menu bars be available in GUI
-        self.enable_MenuBar("Param files")
-        self.enable_MenuBar("Launch")
-        self.enable_MenuBar("Tools")
-        if self.debugDLL:
-            self.enable_MenuBar("Debug")
-    
+        if self.wx_exists:
+            self.enable_MenuBar("Param files")
+            self.enable_MenuBar("Launch")
+            self.enable_MenuBar("Tools")
+            if self.debugDLL:
+                self.enable_MenuBar("Debug")
 
-    def apply_optim(self, event, idLauncher:int=0, 
+
+    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".
@@ -474,7 +483,7 @@ class Optimisation(wx.Frame):
             return bestParams
         else:
             return None
-        
+
 
 
     # Initialisation of the Optimizer from Fortran
@@ -483,7 +492,7 @@ class Optimisation(wx.Frame):
         self.init_optimizer()
 
 
-    
+
     def init_with_default_lumped(self, replace:bool=False):
         # if replace:
         #     r = wx.ID_NO
@@ -613,7 +622,7 @@ class Optimisation(wx.Frame):
                 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)]                   
+                    cur_id = list(curCatch.dictIdConversion.keys())[list(curCatch.dictIdConversion.values()).index(sorted_id)]
                     self.myParams[i]["junction_name"] = curCatch.subBasinDict[cur_id].name
 
             else:
@@ -640,7 +649,7 @@ class Optimisation(wx.Frame):
 
         optimFileTxt = os.path.join(self.workingDir, nameTMP+".rpt")
         optimFileBin = os.path.join(self.workingDir, nameTMP+".rpt.dat")
-        
+
         isOk, optimFileBin = check_path(optimFileBin)
         if isOk>0:
             optimFile = optimFileBin
@@ -671,7 +680,7 @@ class Optimisation(wx.Frame):
 
 
     def init_with_reference(self, idLauncher=0):
-        
+
         curCase = self.myCases[idLauncher]
         refCatch = curCase.refCatchment
 
@@ -728,14 +737,19 @@ class Optimisation(wx.Frame):
             isOk, defaultPath = check_path(defaultPath, launcherDir)
             if isOk<0:
                 defaultPath = ""
-            idir=wx.FileDialog(None,"Choose a reference file",wildcard='Fichiers post-processing (*.postPro)|*.postPro',defaultDir=defaultPath)
-            if idir.ShowModal() == wx.ID_CANCEL:
-                print("Post process cancelled!")
+            if self.wx_exists:
+                idir=wx.FileDialog(None,"Choose a reference file",wildcard='Fichiers post-processing (*.postPro)|*.postPro',defaultDir=defaultPath)
+                if idir.ShowModal() == wx.ID_CANCEL:
+                    print("Post process cancelled!")
+                    idir.Destroy()
+                refFileName = idir.GetPath()
+                refDir = idir.GetDirectory()
                 idir.Destroy()
-                
-            refFileName = idir.GetPath()
-            refDir = idir.GetDirectory()
-            idir.Destroy()
+            else:
+                refDir = defaultPath
+                refFileName = join(refDir, "Input.postPro")
+
+
 
         myPostPro = PostProcessHydrology(postProFile=refFileName)
         # Recover the Catchment object
@@ -855,14 +869,14 @@ class Optimisation(wx.Frame):
 
     def plot_optim_jct(self, event, idLauncher=0):
         # this function will plot the hydrographs with the optimal parameters compared to the objective
-        
+
         refCatch:Catchment = self.myCases[idLauncher].refCatchment
 
         # Construction of the Measures, in other words the references
         compMeas = []
         if self.myStations==[]:
             self.set_compare_stations(idLauncher=idLauncher)
-        
+
         compMeas = list(self.compareSubBasins.values())
 
         # Construction of the wx window for plot
@@ -870,7 +884,7 @@ class Optimisation(wx.Frame):
 
         self.axes = figure.add_subplot(111)
 
-        
+
         r = wx.MessageDialog(
             None, "Do you want to add a table?", "Plot question",
             wx.YES_NO | wx.NO_DEFAULT | wx.ICON_QUESTION
@@ -960,7 +974,7 @@ class Optimisation(wx.Frame):
         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)), 
+        obj_fct = self.dllFortran.evaluate_model_optimizer_py(ct.byref(ct.c_int(idOpti)),
                                                            pointerDims,
                                                            pointer_p)
         print("End of Fortran procedure")
@@ -1296,7 +1310,7 @@ class Optimisation(wx.Frame):
             self.set_compare_stations(idLauncher=idLauncher)
             sortJct = self.myStations
             readDict = self.compareFilesDict
-            # Get the initial number of intervals 
+            # Get the initial number of intervals
             # -> these can evolve according to the measurement available at each station
             is_ok = self._save_opti_intervals()
             if is_ok<0:
@@ -1325,7 +1339,7 @@ class Optimisation(wx.Frame):
                 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)
@@ -1336,7 +1350,7 @@ class Optimisation(wx.Frame):
                 # 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 
+                # 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
@@ -1361,12 +1375,12 @@ class Optimisation(wx.Frame):
                             if best_params_overall is None:
                                 best_params_overall = best_params
                             elif best_params[-1] > best_params_overall[-1]:
-                                best_params_overall = best_params 
-                                i_best_overal = cur_i                  
+                                best_params_overall = best_params
+                                i_best_overal = cur_i
                         # copy the optimisation results to save it on the disk
-                        shutil.copyfile(os.path.join(self.workingDir, stationOut+".rpt.dat"), 
+                        shutil.copyfile(os.path.join(self.workingDir, stationOut+".rpt.dat"),
                                         os.path.join(self.workingDir, stationOut+"_"+str(cur_i+1)+".rpt.dat"))
-                        shutil.copyfile(os.path.join(self.workingDir, stationOut+".rpt"), 
+                        shutil.copyfile(os.path.join(self.workingDir, stationOut+".rpt"),
                                         os.path.join(self.workingDir, stationOut+"_"+str(cur_i+1)+".rpt"))
                         cur_i += 1
                 # Apply the best parameters overall attemps
@@ -1374,12 +1388,12 @@ class Optimisation(wx.Frame):
                 # 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"), 
+                shutil.copyfile(os.path.join(self.workingDir, stationOut+"_"+str(i_best_overal+1)+".rpt.dat"),
                                 os.path.join(self.workingDir, stationOut+".rpt.dat"))
-                shutil.copyfile(os.path.join(self.workingDir, stationOut+"_"+str(i_best_overal+1)+".rpt"), 
+                shutil.copyfile(os.path.join(self.workingDir, stationOut+"_"+str(i_best_overal+1)+".rpt"),
                                 os.path.join(self.workingDir, stationOut+".rpt"))
-                
-                
+
+
                 # Simulation with the best parameters
                 self.compute_distributed_hydro_model()
                 cur_p = best_params_overall[:-1]
@@ -1448,8 +1462,8 @@ class Optimisation(wx.Frame):
         tf = time_mod.process_time()
         print("Time in update_hydro() : ", tf-t0)
         return isOk
-    
-    
+
+
     def reload_hydro(self, idCompar, firstLevel:int=1, lastLevel:int=-1, fromStation:str="", updateAll:bool=False):
 
         curCatch:Catchment = self.myCases[0].refCatchment
@@ -1683,7 +1697,7 @@ class Optimisation(wx.Frame):
 
         return isOk
 
-    
+
     ## Update the dictionnaries of myParams if any changes is identified
     # TODO : Generalised for all type of changes and all the necessary tests -> So far just update the junction name
     def update_myParams(self, idLauncher=0):
@@ -1699,10 +1713,10 @@ class Optimisation(wx.Frame):
             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)]                   
+                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 compare stations, compare files and the compare station SubBasin objects for each station
     def set_compare_stations(self, idLauncher):
@@ -1721,7 +1735,7 @@ class Optimisation(wx.Frame):
             # 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) 
+            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():
@@ -1742,11 +1756,11 @@ class Optimisation(wx.Frame):
         self.Destroy()
 
         wx.Exit()
-        
-    
+
+
     def get_all_outlets(self, event, idLauncher:int=0):
         # this function will save all the hydrographs with the optimal parameters
-        
+
         refCatch:Catchment = self.myCases[idLauncher].refCatchment
         refCatch.save_ExcelFile_noLagTime()
 
@@ -1756,7 +1770,7 @@ class Optimisation(wx.Frame):
         refCatch:Catchment = self.myCases[idLauncher].refCatchment
         refCatch.save_ExcelFile_inlets_noLagTime()
 
-    
+
     def plot_all_landuses(self, event, idLauncher:int=0):
         # this function plots the landuses of all hydro subbasins
         refCatch:Catchment = self.myCases[idLauncher].refCatchment
@@ -1773,7 +1787,7 @@ class Optimisation(wx.Frame):
     #   - the ".rpt" file of the results of an optimisation should be present
     #   - the optimal paramters will be replaced in their respective param files
     #   - the timeDelays will then be updated either with :
-    #           - Python paramters itself 
+    #           - Python paramters itself
     #           - an estimation from the runnof model
     # Once all the optimal parameters are applied, a new simulation is launched to generate the "best" hydrograph
     def generate_semiDist_optim_simul(self, event, idOpti=1,idLauncher:int=0):
@@ -1811,7 +1825,7 @@ class Optimisation(wx.Frame):
                 self.optiParam.change_param("Optimizer", "fname", stationOut)
                 self.optiParam.SavetoFile(None)
                 self.optiParam.Reload(None)
-                # 
+                #
                 self.update_myParams(idLauncher)
                 # Preparing the dictionnaries of Parameters to be updated -> not just useful for calibration here !
                 self.prepare_calibration_timeDelay(stationOut=stationOut)
@@ -1828,7 +1842,7 @@ class Optimisation(wx.Frame):
                 # All upstream elements of a reference will be fixed
                 doneList.append(stationOut)
 
-    
+
     def generate_semiDist_debug_simul(self, event, idOpti=1,idLauncher:int=0):
 
         curCatch:Catchment = self.myCases[idLauncher].refCatchment
@@ -1864,7 +1878,7 @@ class Optimisation(wx.Frame):
                 self.optiParam.change_param("Optimizer", "fname", stationOut)
                 self.optiParam.SavetoFile(None)
                 self.optiParam.Reload(None)
-                # 
+                #
                 self.update_myParams(idLauncher)
                 # TO DO -> adapt all the debug_info files
                 # write it here !!!!
@@ -1879,9 +1893,13 @@ class Optimisation(wx.Frame):
                 doneList.append(stationOut)
 
 
-    def read_all_attempts_SA(self, format="rpt", all_attempts=False, filter_repetitions=True):
+    def read_all_attempts_SA(self, format="rpt", all_attempts=False, filter_repetitions=True, stationOut:str=""):
+
+        if stationOut=="":
+            nameTMP = self.optiParam.get_param("Optimizer","fname")
+        else:
+            nameTMP = stationOut
 
-        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)
@@ -1906,7 +1924,7 @@ class Optimisation(wx.Frame):
                         list_ObjFct = []
                         line = 0
                         for raw in data_reader:
-                            if(line<3): 
+                            if(line<3):
                                 line += 1
                                 continue
                             if(len(raw)<=1):
@@ -1918,11 +1936,11 @@ class Optimisation(wx.Frame):
                             line += 1
                     matrixParam = np.vstack((matrixParam,
                                             np.array(list_param).astype("double")))
-                    vectorObjFct = np.append(vectorObjFct, 
+                    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":
             for cur_file in all_names:
                 optimFile = os.path.join(self.workingDir, cur_file+".rpt.dat")
@@ -1935,17 +1953,17 @@ class Optimisation(wx.Frame):
 
         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, 
+            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
-    
-    
+
+
     def apply_optim_2_params(self, params:np.array, idLauncher=0):
 
         refCatch:Catchment = self.myCases[idLauncher].refCatchment
@@ -1955,9 +1973,9 @@ class Optimisation(wx.Frame):
             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)):
 
             filePath = os.path.join(refCatch.workingDir, "Subbasin_" + str(refCatch.myEffSortSubBasins[cur_effsub]))
@@ -1972,20 +1990,24 @@ class Optimisation(wx.Frame):
                         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
+                    all_files = myModelDict[int(myType)]["File"]
+                    if type(all_files) is not list:
+                        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:
+                        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.curParams_vec_F[i] = params[i]
                     self.update_timeDelay(i+1)
                     refCatch.save_timeDelays([self.myParams[i+1]["junction_name"]])
@@ -2026,7 +2048,7 @@ class Optimisation(wx.Frame):
 
             myModel = self.myCases[idLauncher].refCatchment.myModel
             nbParamsModel = cste.modelParamsDict[myModel]["Nb"]*len(cur_opti.refCatchment.myEffSubBasins)
-            
+
             for i in range(1,nb_params+1):
                 curParam = "param_" + str(i)
                 curType = int(paramDict.get_param(curParam, "type_of_data"))
@@ -2044,7 +2066,7 @@ class Optimisation(wx.Frame):
             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]]:
         """
@@ -2060,7 +2082,7 @@ class Optimisation(wx.Frame):
         # 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)
@@ -2068,7 +2090,7 @@ class Optimisation(wx.Frame):
         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)])
@@ -2087,15 +2109,15 @@ class Optimisation(wx.Frame):
 
 
         return intervals
-    
 
-    def _save_opti_intervals(self, idLauncher:int=0, stationOut:str="", 
+
+    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)
 
@@ -2116,7 +2138,7 @@ class Optimisation(wx.Frame):
             return -1
         else:
             return 0
-    
+
 
     def select_opti_intervals(self, all_intervals:list[tuple[datetime.datetime, datetime.datetime]]=None,
                               idLauncher:int=0, stationOut="", filter_nan:bool=True)->list[tuple]:
@@ -2130,7 +2152,7 @@ class Optimisation(wx.Frame):
         """
         cur_opti = self.myCases[idLauncher]
         cur_ref = cur_opti.refCatchment
-        
+
         if stationOut == "":
             stationOut = cur_ref.junctionOut
 
@@ -2140,30 +2162,30 @@ class Optimisation(wx.Frame):
                 # 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, 
+            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], 
+
+
+    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  
+        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:
@@ -2182,15 +2204,15 @@ class Optimisation(wx.Frame):
         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])) 
+            [(time >= datetime.datetime.timestamp(interv[0])) *
+             (time <= datetime.datetime.timestamp(interv[1]))
              for interv in intervals],
             axis=0) > 0
         # Both conditions should be satisfied
@@ -2200,7 +2222,7 @@ class Optimisation(wx.Frame):
         # 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)
 
@@ -2209,18 +2231,18 @@ class Optimisation(wx.Frame):
 
         # 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), 
+        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 
+        # 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!"
@@ -2251,16 +2273,16 @@ class Optimisation(wx.Frame):
             # Force the initial parameters to be defined randomly
             self.saParam.change_param("Initial parameters", "Read initial parameters?", 0)
             return
-        
+
         # In the following code, we apply the best parameters to the initial parameters
         self.saParam.change_param("Initial parameters", "Read initial parameters?", 1)
         for i in range(self.nbParams):
             self.saParam.change_param("Initial parameters", " ".join(["Parameter",str(i+1)]), best_params[i])
-        
+
         self.saParam.SavetoFile(None)
         self.saParam.Reload(None)
 
-    
+
     def get_initial_parameters(self)-> np.array:
         read_IP = self.saParam.get_param("Initial parameters", "Read initial parameters?")
         if read_IP == 1:
@@ -2268,12 +2290,12 @@ class Optimisation(wx.Frame):
             init_params = np.zeros(self.nbParams+1)
             for i in range(self.nbParams):
                 init_params[i] = self.saParam.get_param("Initial parameters", " ".join(["Parameter",str(i+1)]))
-            init_params[-1] = -sys.float_info.max              
+            init_params[-1] = -sys.float_info.max
         else:
             init_params = None
-        
+
         return init_params
-    
+
 
     def reset_init_params(self, init_params:np.array):
         if init_params is None:
@@ -2283,7 +2305,7 @@ class Optimisation(wx.Frame):
         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
@@ -2311,7 +2333,7 @@ class Optimisation(wx.Frame):
                 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                
+                    to_generate = True
                 dlg.Destroy()
                 # FIXME :  ADD the terminal
             else:
@@ -2319,7 +2341,7 @@ class Optimisation(wx.Frame):
         # Enter here if a detailed simulation is required
         if to_generate:
             curCatch.activate_all_internal_variables()
-            self.generate_semiDist_optim_simul(None, idLauncher=idLauncher)           
+            self.generate_semiDist_optim_simul(None, idLauncher=idLauncher)
             all_x = curCatch.get_all_x_production()
             all_iv = curCatch.get_all_iv_production()
 
@@ -2333,18 +2355,18 @@ class Optimisation(wx.Frame):
                 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)
 
@@ -2359,17 +2381,17 @@ class Optimisation(wx.Frame):
             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_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)) 
+            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[-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")
@@ -2383,20 +2405,20 @@ class Optimisation(wx.Frame):
             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)
@@ -2414,13 +2436,13 @@ class Optimisation(wx.Frame):
             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 
+                # 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 = {}
@@ -2428,20 +2450,20 @@ class Optimisation(wx.Frame):
         #     all_params[key] = {}
         #     for i, cur_name in enumerate(all_names):
         #         all_params[key][cur_name] = value[i]
-        
-        all_params = {key: 
+
+        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 
-    
+
+        return
+
 
     def save_current_compare_file(self, stationOut: str):
         """
@@ -2475,11 +2497,11 @@ class Optimisation(wx.Frame):
             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
@@ -2493,20 +2515,20 @@ class Optimisation(wx.Frame):
                     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]], 
+
+    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.01, std_Nash:float=0.3, clustering_Nash:bool=True):
@@ -2528,11 +2550,11 @@ class Optimisation(wx.Frame):
         if onlyOwnSub is None:
             onlyOwnSub = False
         doneList = []
-        previousLevel = 1 
+        previousLevel = 1
         # Collect sort and save the compare stations
         self.set_compare_stations(idLauncher=idLauncher)
         sortJct = self.myStations
-        # Get the initial number of intervals 
+        # 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
@@ -2564,14 +2586,14 @@ class Optimisation(wx.Frame):
             # Reload the useful modules
             self.reload_hydro(idCompar=0, fromStation=stationOut, lastLevel=previousLevel, updateAll=True)
             ## =======
-            ## Init 
+            ## 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 
+            ## Compute
             ## =======
             all_frac = []
 
@@ -2608,7 +2630,7 @@ class Optimisation(wx.Frame):
                         + list(frac_dict.keys()) \
                         + list(frac_vol_dict.keys()) \
                         + ["% max runoff", "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')
@@ -2638,12 +2660,12 @@ class Optimisation(wx.Frame):
 
         writer_tot.close()
         logging.info("The equifinality test is finished!")
-        
 
-    def get_best_params(self, stationOut:str, 
+
+    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        
+        from sklearn.cluster import DBSCAN
         """
         Get the best parameters for a given station.
 
@@ -2662,7 +2684,7 @@ class Optimisation(wx.Frame):
         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)) 
+        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]
@@ -2670,7 +2692,7 @@ class Optimisation(wx.Frame):
         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 
+        # 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
@@ -2690,7 +2712,7 @@ class Optimisation(wx.Frame):
             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
@@ -2708,10 +2730,10 @@ class Optimisation(wx.Frame):
             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="", 
+    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)
@@ -2737,9 +2759,9 @@ class Optimisation(wx.Frame):
 
         return q_diff
 
-    
+
     # FIXME :  to improve and generalise
-    def _get_cur_fractions(self, idLauncher:int=0, stationOut:str="", 
+    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.
@@ -2764,12 +2786,12 @@ class Optimisation(wx.Frame):
         cur_fracts = curBasin.get_summary_fractions(summary="mean", interval=intervals)
 
         return cur_fracts
-    
+
 
     # TODO : to finish this function
-    def _get_volume_fractions(self, idLauncher:int=0, stationOut:str="", 
+    def _get_volume_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]
@@ -2780,7 +2802,7 @@ class Optimisation(wx.Frame):
         return cur_fracts
 
     # FIXME :  to improve and generalise
-    def _get_max_runoff(self, idLauncher:int=0, stationOut:str="", 
+    def _get_max_runoff(self, idLauncher:int=0, stationOut:str="",
                          intervals:list[tuple[datetime.datetime, datetime.datetime]]=[]) -> dict[list[str], list[float]]:
 
         curCatch:Catchment = self.myCases[idLauncher].refCatchment
@@ -2789,11 +2811,11 @@ class Optimisation(wx.Frame):
         cur_fracts = curBasin.get_summary_fractions(summary="max", interval=intervals)
 
         return cur_fracts["% qof"]
-    
 
-    def _get_ratio_max_sim_obs(self, idLauncher:int=0, stationOut:str="", 
+
+    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]
@@ -2814,9 +2836,9 @@ class Optimisation(wx.Frame):
         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=""):
@@ -2827,7 +2849,7 @@ class Optimisation(wx.Frame):
 
         calibrate_timeDelay = bool(int(self.optiParam.get_param("Semi-Distributed", "Calibrate_times")))
         if calibrate_timeDelay:
-            # Get_nb inlets 
+            # Get_nb inlets
             inletsNames = self.myCases[idLauncher].refCatchment.get_inletsName(stationOut)
             nbInlets = len(inletsNames)
             for i in range(nbInlets):
@@ -2835,7 +2857,7 @@ class Optimisation(wx.Frame):
 
 
         return names
-    
+
     # Plot the equifinalty test for each station
     def plot_equifinality(self, event, idLauncher:int=0):
 
@@ -2860,7 +2882,7 @@ class Optimisation(wx.Frame):
                     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, 
+                        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+" [-]")
@@ -2873,7 +2895,7 @@ class Optimisation(wx.Frame):
                     cur_columns = [col for col in df.columns if cur_prop.replace(" ", "") 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, 
+                        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 volume [-]")
                 ax.set_ylabel(y_label+" [-]")
@@ -2913,10 +2935,10 @@ class Optimisation(wx.Frame):
                 fig.savefig(os.path.join(self.workingDir, "Equifinality_max_runoff_"+stationOut+".png"))
             else:
                 logging.error("The file "+filename+" does not exist!")
-                
+
         plt.show()
 
-    
+
     def add_Case(self, idLauncher:int=0):
 
         i = idLauncher
@@ -2948,7 +2970,7 @@ class Optimisation(wx.Frame):
                 curCase = paramMenu.Append(newId, curName, caseMenu)
             else:
                 print("WARNING : this scenario was not implemented yet. This might induce an error!")
-                # iItem = 
+                # iItem =
                 curCase = paramMenu.Replace(iItem)
         else:
             refDir = newCase.launcherParam.get_param("Calculs","Répertoire simulation de référence")
@@ -2960,6 +2982,116 @@ class Optimisation(wx.Frame):
         self.myCases.append(newCase)
 
 
+    def launch_semi_dist_parameters(self, idLauncher:int=0, idOpti:int=1,
+                                    params_to_test:dict[str, np.ndarray]={},
+                                    return_outflows:bool=False) -> dict[str, np.ndarray]:
+        # Return variable
+        all_outlets = {}
+        # Useful variables
+        curCatch:Catchment = self.myCases[idLauncher].refCatchment
+        doneList = []
+        previousLevel = 1
+        # Get if the optimisation or the set of parameters is only for 1 subbasin severals
+        onlyOwnSub = self.optiParam.get_param("Semi-Distributed", "Own_SubBasin")
+        if onlyOwnSub is None:
+            onlyOwnSub = False
+        # 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
+        # Extract the number of time steps to initialise the matrices
+        nb_time_steps = len(curCatch.time)
+        # Loop over all stations to apply the set of parameters
+        for stationOut in sortJct:
+            if not stationOut in list(params_to_test.keys()):
+                continue
+            # Definition of the current subbasin
+            cur_key = curCatch.get_key_catchmentDict(stationOut)
+            curBasin: SubBasin = curCatch.catchmentDict[cur_key]
+            # Extract all the parameters to test
+            all_params = params_to_test[stationOut]
+            logging.info("==================")
+            logging.info("Station : "+stationOut)
+            # Prepare all the file in the hydrology optimisation and simulation directories
+            self._prepare_opti_hydro_files(stationOut=stationOut, idLauncher=idLauncher,
+                                          onlyOwnSub=onlyOwnSub, doneList=doneList, previousLevel=previousLevel)
+            # 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)
+            ## ===================================================================================================================
+            ## Init
+            ## ===================================================================================================================
+            self.init_optimizer(idOpti)
+            self.associate_ptr(None, idOpti=idOpti)
+            ## ===================================================================================================================
+            ## Compute
+            ## ===================================================================================================================
+            all_outlets[stationOut] = np.zeros((len(all_params), nb_time_steps))
+            for i in range(len(all_params)):
+                cur_p = all_params[i, :-1]
+                cur_obj2 = self.evaluate_model_optimizer(cur_p, idOpti=idOpti)
+                all_outlets[stationOut][i,:] = curBasin.outFlow
+                # Small test
+                cur_obj = all_params[i, -1]
+                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))
+            ## ===================================================================================================================
+            ## ===================================================================================================================
+            # 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
+
+        logging.info("All the parameters have been tested!")
+        if return_outflows:
+            return all_outlets
+
+
+    def _prepare_opti_hydro_files(self, stationOut:str, idLauncher:int=0, onlyOwnSub:bool=False,
+                                 doneList:list[str]=[], previousLevel:int=1):
+        # Useful variables
+        curCatch:Catchment = self.myCases[idLauncher].refCatchment
+
+        # 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)
+        # 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)
+
+
+
+    def write_one_opti_param(self, filPath:Path, fileName:Path, myGroup:str, myKey:str, value:float, convers_factor:int=1.0):
+        tmpWolf = Wolf_Param(to_read=True, filename=os.path.join(filPath,fileName),toShow=False, init_GUI=False)
+        tmpWolf.change_param(myGroup, myKey, value/convers_factor)
+        tmpWolf.SavetoFile(None)
+        # tmpWolf.OnClose(None)
+        tmpWolf = 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
@@ -2977,4 +3109,3 @@ class Optimisation(wx.Frame):
             return arr.copy()
         else:
             return arr
-