wolfhece 2.2.38__py3-none-any.whl → 2.2.39__py3-none-any.whl

wolfhece/hydrology/Optimisation.py

@@ -33,6 +33,7 @@ from . import Models_characteristics as mc
 from . import Internal_variables as iv
 from ..PyTranslate import _
 import traceback
+import gc
 
 
 # %% Constants
@@ -41,7 +42,6 @@ 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)
 
 
-
 # %% Classes
 class CaseOpti(GenMapManager):
 
@@ -69,25 +69,26 @@ class CaseOpti(GenMapManager):
 
         self.launcherDir = ""
 
-    def read_param(self, dir, copyDefault=False, callback=None, workingDir=""):
+    def read_param(self, dir, copyDefault=False, callback=None, workingDir:Path = ""):
 
-        self.launcherDir = dir
+        self.launcherDir = Path(dir)
+        workingDir = Path(workingDir)
 
         if not os.path.exists(self.launcherDir):
             try:
                 os.mkdir(self.launcherDir)
-                shutil.copyfile(workingDir+"launcher.param.default", os.path.join(self.launcherDir,"launcher.param"))
-                shutil.copyfile(workingDir+"launcher.param.default", os.path.join(self.launcherDir,"launcher.param.default"))
+                shutil.copyfile(workingDir / "launcher.param.default", self.launcherDir / "launcher.param")
+                shutil.copyfile(workingDir / "launcher.param.default", self.launcherDir / "launcher.param.default")
             except OSError:
                 print ("Creation of the directory %s failed" % self.launcherDir)
             else:
                 print ("Successfully created the directory %s" % self.launcherDir)
 
         if copyDefault:
-            shutil.copyfile(workingDir+"launcher.param.default", os.path.join(self.launcherDir,"launcher.param"))
-            shutil.copyfile(workingDir+"launcher.param.default", os.path.join(self.launcherDir,"launcher.param.default"))
+            shutil.copyfile(workingDir / "launcher.param.default", self.launcherDir / "launcher.param")
+            shutil.copyfile(workingDir / "launcher.param.default", self.launcherDir / "launcher.param.default")
 
-        self.launcherParam = Wolf_Param(to_read=True, filename=os.path.join(self.launcherDir,"launcher.param"),title="launcher", toShow=False)
+        self.launcherParam = Wolf_Param(to_read=True, filename=self.launcherDir / "launcher.param",title="launcher", toShow=False)
 
 
     def show_launcherParam(self, event):
@@ -151,7 +152,6 @@ class Optimisation(wx.Frame):
         self.myParamsPy = {}
         self.nbParams = 0
 
-        #self.pathDll = Path(os.path.dirname(__file__)).parent
         # point to the wolf_libs package directory
         self.pathDll = wolf_libs.__path__[0]
 
@@ -236,12 +236,11 @@ class Optimisation(wx.Frame):
         plotEquiFinClick = toolMenu.Append(wx.ID_ANY, 'Plot equifinality with Nash')
         self.Bind(wx.EVT_MENU, self.plot_equifinality, plotEquiFinClick)
         testEquiFinClick = toolMenu.Append(wx.ID_ANY, 'Models analysis with Nash')
-        self.Bind(wx.EVT_MENU, self.launch_models_propertie_with_Nash, testEquiFinClick)
+        self.Bind(wx.EVT_MENU, self.launch_models_properties_with_Nash, testEquiFinClick)
         plotEquiFinClick = toolMenu.Append(wx.ID_ANY, 'Plot analysis with Nash')
         self.Bind(wx.EVT_MENU, self.plot_model_analysis, plotEquiFinClick)
 
 
-
         # Creation of the Lauch Menu
         launchMenu = wx.Menu()
         normalLaunchClick = launchMenu.Append(wx.ID_ANY, '1 Basin')
@@ -284,50 +283,54 @@ class Optimisation(wx.Frame):
 
 
     def new(self, event):
+        """ Create a new optimisation directory and files. """
 
         launcherDir = "simul_1"
 
         # Selection of the working directory
         idir=wx.DirDialog(None,"Choose an optimisation directory")
         if idir.ShowModal() == wx.ID_CANCEL:
-            print("Optimisation cancelled!")
+            logging.info("Optimisation cancelled!")
             idir.Destroy()
+            return
 
-        self.workingDir = idir.GetPath()+"\\"
-        launcherDir = os.path.join(self.workingDir,launcherDir)
+        self.workingDir = Path(idir.GetPath())
+        launcherDir = self.workingDir / launcherDir
         idir.Destroy()
 
         # Launch the Fortran code a first time to generate the default files
-        self.default_files(None)
+        self.default_files()
 
         # Copy and reading of the optiParam file
-        shutil.copyfile(self.workingDir+"test_opti.param.default", os.path.join(self.workingDir,"test_opti.param"))
-        shutil.copyfile(self.workingDir+"sa.param.default", os.path.join(self.workingDir,"sa.param"))
-        shutil.copyfile(self.workingDir+"compare.how.param.default", os.path.join(self.workingDir,"compare.how.param"))
-        if not os.path.exists(launcherDir):
+        shutil.copyfile(self.workingDir / "test_opti.param.default", self.workingDir / "test_opti.param")
+        shutil.copyfile(self.workingDir / "sa.param.default", self.workingDir / "sa.param")
+        shutil.copyfile(self.workingDir / "compare.how.param.default", self.workingDir / "compare.how.param")
+
+        if not launcherDir.exists():
             try:
-                os.mkdir(launcherDir)
+                launcherDir.mkdir(parents=True, exist_ok=True)
             except OSError:
                 print ("Creation of the directory %s failed" % launcherDir)
             else:
                 print ("Successfully created the directory %s" % launcherDir)
-        shutil.copyfile(self.workingDir+"launcher.param.default", os.path.join(launcherDir,"launcher.param"))
-        shutil.copyfile(self.workingDir+"launcher.param.default", os.path.join(launcherDir,"launcher.param.default"))
+        shutil.copyfile(self.workingDir / "launcher.param.default", launcherDir /"launcher.param")
+        shutil.copyfile(self.workingDir / "launcher.param.default", launcherDir / "launcher.param.default")
 
 
         # Read the main opti file
-        self.optiParam = Wolf_Param(to_read=True, filename=os.path.join(self.workingDir,"test_opti.param"),title="test_opti",toShow=False)
+        self.optiParam = Wolf_Param(to_read=True, filename= self.workingDir / "test_opti.param", title = "test_opti", toShow = False)
         # # Update all the paths and read all simul
         # self.init_dir_in_params()
         # Read all the param files and init the Case objects and then read the param files associated
         newCase = CaseOpti()
-        newCase.read_param(launcherDir, copyDefault=True, callback=self.update_parameters_launcher, workingDir=self.workingDir)
+        newCase.read_param(launcherDir, copyDefault=True, callback=self.update_parameters_launcher, workingDir = self.workingDir)
         self.myCases.append(newCase)
+
         # Update all the paths and read all simul
         self.init_dir_in_params()
 
-        self.comparHowParam = Wolf_Param(to_read=True,filename=os.path.join(self.workingDir,"compare.how.param"),title="compare.how",toShow=False)
-        self.saParam = Wolf_Param(to_read=True,filename=os.path.join(self.workingDir,"sa.param"), title="sa",toShow=False)
+        self.comparHowParam = Wolf_Param(to_read=True,filename= self.workingDir / "compare.how.param",title="compare.how",toShow=False)
+        self.saParam = Wolf_Param(to_read=True,filename= self.workingDir / "sa.param", title="sa",toShow=False)
         self.saParam._callback = self.update_parameters_SA
         # initialise all param files according to the reference characteristics
         self.init_with_reference()
@@ -347,13 +350,13 @@ class Optimisation(wx.Frame):
             curDir = newCase.launcherParam.get_param("Calculs","Répertoire simulation de référence")
             isOk, curDir = check_path(curDir, prefix=self.workingDir, applyCWD=True)
             if isOk<0:
-                print("ERROR : in path of launcherDir")
-            newCase.mydro = HydrologyModel(dir=curDir)
+                logging.error("ERROR : in path of launcherDir")
+            newCase.mydro = HydrologyModel(directory=curDir)
             newCase.mydro.Hide()
             self.Bind(wx.EVT_MENU, newCase.show_mydro, guiHydroCase)
             curCase = paramMenu.Append(newId, curName, caseMenu)
         except:
-            print("ERROR: launch again the app and apply 'load' files.")
+            logging.error("ERROR: launch again the app and apply 'load' files.")
 
 
 
@@ -368,7 +371,7 @@ class Optimisation(wx.Frame):
         if workingDir=="":
             idir=wx.FileDialog(None,"Choose an optimatimisation file",wildcard='Fichiers param (*.param)|*.param')
             if idir.ShowModal() == wx.ID_CANCEL:
-                print("Post process cancelled!")
+                logging.info(_("Post process cancelled!"))
                 idir.Destroy()
                 return
                 # sys.exit()
@@ -405,7 +408,7 @@ class Optimisation(wx.Frame):
             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")
+                logging.error("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:
@@ -422,13 +425,13 @@ class Optimisation(wx.Frame):
                     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)
+                        logging.error("ERROR : in path of launcherDir")
+                    newCase.mydro = HydrologyModel(directory=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!")
+                    logging.Warning(_("WARNING : this scenario was not implemented yet. This might induce an error!"))
                     # iItem =
                     curCase = paramMenu.Replace(iItem)
                 self.Bind(wx.EVT_MENU, newCase.show_launcherParam, curCase)
@@ -436,7 +439,7 @@ class Optimisation(wx.Frame):
             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)
+                newCase.mydro = HydrologyModel(directory=refDir)
             self.myCases.append(newCase)
 
 
@@ -705,7 +708,7 @@ class Optimisation(wx.Frame):
         # Selection of the working directory
         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!")
+            logging.info(_("Post process cancelled!"))
             idir.Destroy()
 
         refFileName = idir.GetPath()
@@ -752,7 +755,7 @@ class Optimisation(wx.Frame):
             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!")
+                    logging.info(_("Post process cancelled!"))
                     idir.Destroy()
                 refFileName = idir.GetPath()
                 refDir = idir.GetDirectory()
@@ -813,7 +816,7 @@ class Optimisation(wx.Frame):
 
     def checkIntervals(self):
 
-        print("So far do nothing to check intervals!")
+        logging.info(_("So far do nothing to check intervals!"))
         # self.comparHowParam[]
 
 
@@ -938,38 +941,53 @@ class Optimisation(wx.Frame):
         self.Fit()
 
 
-    def load_dll(self, path, fileName):
-        libpath = os.path.join(path,'libs',fileName)
+    def load_dll(self, path:str, fileName:str = "WolfDLL.dll"):
+        """ Load the Fortran DLL for optimization.
+
+        :param path: The directory where the DLL is located.
+        :param fileName: The name of the DLL file to load.
+        """
+
+        libpath = os.path.join(path, fileName)
+
+        if not Path(libpath).exists():
+            # try libs subdirectory
+            libpath = os.path.join(path, "libs", fileName)
+            if not Path(libpath).exists():
+                logging.error(f"Library not found: {libpath}")
+                return
+
         try:
             self.dllFortran = ct.CDLL(libpath)
         except:
-            print('Erreur de chargement de la librairie WolfDLL.dll')
+            logging.error(_('Error during loading of WolfDLL.dll -- Please check if all Fortran DLL dependencies are met !'))
 
-    def default_files(self, event):
+    def default_files(self):
+        """ Create the default optimizer files in the working directory. """
 
-        pathPtr = self.workingDir.encode('ansi')
+        pathPtr = str(self.workingDir).encode('ansi')
         fileNamePtr = "test_opti.param".encode('ansi')
         self.dllFortran.new_optimizer_files_py.restype = ct.c_int
         self.dllFortran.new_optimizer_files_py.argtypes = [ct.c_char_p, ct.c_char_p, ct.c_int, ct.c_int]
 
-        print("Launch a Fortran procedure")
+        logging.info(_("Launch a Fortran procedure"))
         id = self.dllFortran.new_optimizer_files_py(pathPtr,fileNamePtr,ct.c_int(len(pathPtr)),ct.c_int(len(fileNamePtr)))
 
-        print("id optimizer = ", id)
+        logging.info(_("id optimizer = "), id)
 
-        print("End of Fortran procedure")
+        logging.info(_("End of Fortran procedure"))
 
     def compute_optimizer(self, idOpti=1):
 
         self.dllFortran.compute_optimizer_py.restype = ct.c_int
         self.dllFortran.compute_optimizer_py.argtypes = [ct.POINTER(ct.c_int)]
 
-        print("Launch a Fortran procedure")
+        logging.info(_("Launch a Fortran procedure"))
         isOk = self.dllFortran.compute_optimizer_py(ct.byref(ct.c_int(idOpti)))
-        print("End of Fortran procedure")
+        logging.info(_("End of Fortran procedure"))
 
         if isOk!=0:
-            print("ERROR: in the Fotran routine in the optimizer computation!")
+            logging.error("ERROR: in the Fotran routine in the optimizer computation!")
 
 
     def evaluate_model_optimizer(self, parameters:np.array, idOpti:int=1):
@@ -985,11 +1003,11 @@ class Optimisation(wx.Frame):
         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")
+        logging.info(_("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")
+        logging.info(_("End of Fortran procedure"))
 
         return obj_fct
 
@@ -1000,17 +1018,17 @@ class Optimisation(wx.Frame):
         self.dllFortran.write_mesh_results_optimizer_py.argtypes = [ct.POINTER(ct.c_int)]
 
 
-        print("Launch a Fortran procedure")
+        logging.info(_("Launch a Fortran procedure"))
         isOk = self.dllFortran.write_mesh_results_optimizer_py(ct.byref(ct.c_int(idOpti)))
-        print("End of Fortran procedure")
+        logging.info(_("End of Fortran procedure"))
 
         if isOk!=0:
-            print("ERROR: in the Fotran routine in the optimizer computation!")
+            logging.error("ERROR: in the Fotran routine in the optimizer computation!")
 
 
     def init_optimizer(self, idForced=-1):
 
-        pathPtr = self.workingDir.encode('ansi')
+        pathPtr = str(self.workingDir).encode('ansi')
         fileNamePtr = "test_opti.param".encode('ansi')
         self.dllFortran.init_optimizer_py.restype = ct.c_int
         self.dllFortran.init_optimizer_py.argtypes = [ct.c_char_p, ct.c_char_p, ct.c_int, ct.c_int,ct.POINTER(ct.c_int)]
@@ -1019,17 +1037,17 @@ class Optimisation(wx.Frame):
             opt_id = None
         else:
             opt_id = ct.byref(ct.c_int(idForced))
-        print("Launch a Fortran procedure")
+        logging.info(_("Launch a Fortran procedure"))
         id = self.dllFortran.init_optimizer_py(pathPtr,fileNamePtr,ct.c_int(len(pathPtr)),ct.c_int(len(fileNamePtr)), opt_id)
 
-        print("id optimizer = ", id)
+        logging.info(_("id optimizer = "), id)
 
-        print("End of Fortran procedure")
+        logging.info(_("End of Fortran procedure"))
 
 
     def init_optimizer_again(self, event, idForced=1):
 
-        pathPtr = self.workingDir.encode('ansi')
+        pathPtr = str(self.workingDir).encode('ansi')
         fileNamePtr = "test_opti.param".encode('ansi')
         self.dllFortran.init_optimizer_py.restype = ct.c_int
         self.dllFortran.init_optimizer_py.argtypes = [ct.c_char_p, ct.c_char_p, ct.c_int, ct.c_int,ct.POINTER(ct.c_int)]
@@ -1038,12 +1056,12 @@ class Optimisation(wx.Frame):
             opt_id = None
         else:
             opt_id = ct.byref(ct.c_int(idForced))
-        print("Launch a Fortran procedure")
+        logging.info(_("Launch a Fortran procedure"))
         id = self.dllFortran.init_optimizer_py(pathPtr,fileNamePtr,ct.c_int(len(pathPtr)),ct.c_int(len(fileNamePtr)), opt_id)
 
-        print("id optimizer = ", id)
+        logging.info(_("id optimizer = "), id)
 
-        print("End of Fortran procedure")
+        logging.info(_("End of Fortran procedure"))
 
 
 
@@ -1054,9 +1072,9 @@ class Optimisation(wx.Frame):
 
         pathPtr = self.myCases[idLauncher].refCatchment.workingDir.encode('ansi')
 
-        print("Compute distributed hydro model ...")
+        logging.info(_("Compute distributed hydro model ..."))
         isOk = self.dllFortran.compute_dist_hydro_model_py(pathPtr, ct.c_int(len(pathPtr)))
-        print("End of distributed hydro model.")
+        logging.info(_("End of distributed hydro model."))
 
 
     def compute0_distributed_hydro_model(self, event):
@@ -1066,16 +1084,16 @@ class Optimisation(wx.Frame):
 
         idir=wx.DirDialog(None,"Choose an hydrology directory")
         if idir.ShowModal() == wx.ID_CANCEL:
-            print("Hydro computation cancelled!")
+            logging.info(_("Hydrology computation cancelled!"))
             idir.Destroy()
             return
         pathPtr = idir.GetPath().encode('ansi')
         idir.Destroy()
 
 
-        print("Compute distributed hydro model ...")
+        logging.info(_("Compute distributed hydro model ..."))
         isOk = self.dllFortran.compute_dist_hydro_model_py(pathPtr, ct.c_int(len(pathPtr)))
-        print("End of distributed hydro model.")
+        logging.info(_("End of distributed hydro model."))
 
 
 
@@ -1108,7 +1126,7 @@ class Optimisation(wx.Frame):
 
 
     def associate_callback_fct(self):
-        print("")
+        logging.info(_("Associate callback function ..."))
 
 
     def associate_callback_fct_update(self, idOpti=1, idLauncher=0):
@@ -1133,7 +1151,7 @@ class Optimisation(wx.Frame):
         self.dllFortran.associate_callback_fct(ct.byref(ct.c_int(idOpti)),ct.byref(ct.c_int(idLauncher+1)),
                                             ct.c_int(cste.fptr_update),pointerDims,update_ptr)
 
-        print("End of update pointer association!")
+        logging.info(_("End of update pointer association!"))
 
 
 
@@ -1158,7 +1176,7 @@ class Optimisation(wx.Frame):
         self.dllFortran.associate_callback_fct(ct.byref(ct.c_int(idOpti)),ct.byref(ct.c_int(idLauncher+1)),
                                             ct.c_int(cste.fptr_get_cvg),pointerDims,getcvg_ptr)
 
-        print("End of pointer association!")
+        logging.info(_("End of pointer association!"))
 
 
     def associate_ptr_q_all(self, idOpti=1, idLauncher=0):
@@ -1192,6 +1210,31 @@ class Optimisation(wx.Frame):
             counter += 1
 
 
+    def associate_ptr_iv_saved(self, idOpti=1, idLauncher=0):
+        # nb of arguments in the dimensions vector (dims)
+        ndims = 3
+        # init of the dimensions vector
+        dims = np.zeros((ndims,), dtype=ct.c_int, order='F')
+        pointerDims = dims.ctypes.data_as(ct.POINTER(ct.c_int))
+
+        counter = 1
+        for iSub in self.myCases[idLauncher].refCatchment.myEffSortSubBasins:
+            # curSub = self.refCatchment.subBasinDict[iSub]
+            mydict = self.myCases[idLauncher].refCatchment.dictIdConversion
+            idIP= list(mydict.keys())[list(mydict.values()).index(iSub)]
+            curSub = self.myCases[idLauncher].refCatchment.subBasinDict[idIP]
+            dims[2] = counter
+            dims[0] = len(self.myCases[idLauncher].refCatchment.time)
+            # call of the Fortran function
+            curSub.ptr_iv_saved = None
+            curSub.ptr_iv_saved = self.dllFortran.get_cptr_py(ct.byref(ct.c_int(idOpti)),ct.byref(ct.c_int(idLauncher+1)),
+                                            ct.c_int(cste.ptr_iv_saved), pointerDims)
+            curSub.saved_iv = None
+            curSub.saved_iv = self.make_nd_array(curSub.ptr_iv_saved, shape=(dims[0],dims[1]), dtype=ct.c_double, order='F', own_data=False)
+
+            counter += 1
+
+
     def associate_ptr_time_delays(self, idOpti=1, idLauncher=0):
         # nb of arguments in the dimensions vector (dims)
         ndims = 1
@@ -1226,7 +1269,7 @@ class Optimisation(wx.Frame):
         isOk = self.dllFortran.associate_ptr_py(ct.byref(ct.c_int(idOpti)),ct.byref(ct.c_int(idLauncher+1)), ct.c_int(cste.ptr_params),
                                         pointerDims, pointerParam)
 
-        print("End of param pointer association.")
+        logging.info(_("End of parameter pointer association."))
 
 
 
@@ -1244,22 +1287,88 @@ class Optimisation(wx.Frame):
         isOk = self.dllFortran.associate_ptr_py(ct.byref(ct.c_int(idOpti)),ct.byref(ct.c_int(idLauncher+1)), ct.c_int(cste.ptr_opti_factors),
                                         pointerDims, ct.byref(self.optiFactor_F))
 
-        print("End of factor pointer association.")
+        logging.info(_("End of factor pointer association."))
+
+
+    def get_all_activated_iv(self, idOpti:int=1, idLauncher:int=0,
+                             iv_variables:tuple[np.ndarray, np.ndarray]=None)-> tuple[np.ndarray, np.ndarray]:
+        def check_iv_variables(iv_ids, iv_values, expected_nb_iv):
+            assert iv_ids.dtype == np.dtype(ct.c_int), "The vector of ids iv_ids dtype is not ct.c_int (float64)"
+            assert iv_ids.flags['F_CONTIGUOUS'], "The vector of ids iv_ids is not Fortran-ordered (order='F')"
+            assert iv_ids.shape[0] == expected_nb_iv, f"Expected {expected_nb_iv} ids, got {iv_ids.shape[0]}"
+            assert iv_values.dtype == np.dtype(ct.c_double), "Array of i.v. dtype is not ct.c_double (float64)"
+            assert iv_values.flags['F_CONTIGUOUS'], "Array of i.v. is not Fortran-ordered (order='F')"
+            assert iv_values.shape[1] == expected_nb_iv, f"Expected {expected_nb_iv} values per id, got {iv_values.shape[1]}"
+
+        self.dllFortran.get_nb_activated_iv_py.restype = ct.c_int
+        self.dllFortran.get_nb_activated_iv_py.argtypes = [ct.POINTER(ct.c_int),
+                                                           ct.POINTER(ct.c_int),
+                                                           ct.POINTER(ct.c_int)]
+
+        self.dllFortran.get_all_activated_iv_py.restype = ct.c_int
+        self.dllFortran.get_all_activated_iv_py.argtypes = [ct.POINTER(ct.c_int),
+                                                           ct.POINTER(ct.c_int),
+                                                           ct.POINTER(ct.c_int),
+                                                           ct.POINTER(ct.c_int),
+                                                           ct.POINTER(ct.c_int),
+                                                           ct.POINTER(ct.c_double)]
+
+        nb_iv = ct.c_int()
+        logging.info(_("Launch a Fortran procedure"))
+        isOk = self.dllFortran.get_nb_activated_iv_py(ct.byref(ct.c_int(idOpti)),
+                                                      ct.byref(ct.c_int(idLauncher+1)),
+                                                      ct.byref(nb_iv))
+        if isOk!=0:
+            logging.error("Problem in the Fortran routine in get_nb_activated_iv_py!")
+            return None, None
+        if nb_iv.value == 0:
+            logging.warning("No activated input variables found in the Fortran routine in get_nb_activated_iv_py!")
+            return None, None
+
+        curCatch:Catchment = self.myCases[idLauncher].refCatchment
+        nb_t = ct.c_int(len(curCatch.time))
+        if iv_variables is not None:
+            # If iv_variables is provided, use its shape to determine the number of intervals
+            iv_ids, iv_values = iv_variables
+            check_iv_variables(iv_ids, iv_values, nb_iv.value)
+        else:
+            iv_ids = np.zeros((nb_iv.value,), dtype=ct.c_int, order='F')
+            iv_values = np.zeros((nb_t.value, nb_iv.value), dtype=ct.c_double, order='F')
+        ptr_ids = iv_ids.ctypes.data_as(ct.POINTER(ct.c_int))
+        ptr_values = iv_values.ctypes.data_as(ct.POINTER(ct.c_double))
+        # FIXME: consider all effective sub-basin
+        # TODO: generalise for when several effective subbasins
+        id_sub_eff = ct.c_int(0)
+
+        isOk = self.dllFortran.get_all_activated_iv_py(ct.byref(ct.c_int(idOpti)),
+                                                        ct.byref(ct.c_int(idLauncher+1)),
+                                                        ct.byref(nb_t),
+                                                        ct.byref(nb_iv),
+                                                        ptr_ids,
+                                                        ptr_values,
+                                                        id_sub_eff)
+        if isOk<0:
+            logging.error("Problem in the Fortran routine in get_all_activated_iv_py!")
+            return None, None
+
+        logging.info(_("End of Fortran procedure"))
+
+        return iv_ids, iv_values
 
 
     def init_distributed_hydro_model(self, event):
 
-        pathPtr = self.workingDir.encode('ansi')
+        pathPtr = str(self.workingDir).encode('ansi')
         fileNamePtr = "test_opti.param".encode('ansi')
         self.dllFortran.init_dist_hydro_model_py.restype = ct.c_int
         self.dllFortran.init_dist_hydro_model_py.argtypes = []
 
-        print("Launch a Fortran procedure")
+        logging.info(_("Launch a Fortran procedure"))
         id = self.dllFortran.init_dist_hydro_model_py()
 
-        print("id distributed_hydro_model = ", id)
+        logging.info(_("id distributed_hydro_model = %d"), id)
 
-        print("End of Fortran procedure")
+        logging.info(_("End of Fortran procedure"))
 
 
     def launch_lumped_optimisation(self, event, idOpti=1):
@@ -1273,8 +1382,8 @@ class Optimisation(wx.Frame):
         # Launch Fortran routine to compute optimisation and write the best results
         self.compute_optimizer(idOpti=idOpti)
 
-        print("Best parameters : ", self.curParams_vec_F)
-        print("Best Factor = ", self.optiFactor_F)
+        logging.info(_("Best parameters : %s"), self.curParams_vec_F)
+        logging.info(_("Best Factor = %s"), self.optiFactor_F)
 
         # Apply the best parameters
         self.apply_optim(None)
@@ -1390,30 +1499,29 @@ class Optimisation(wx.Frame):
                                 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"),
-                                        os.path.join(self.workingDir, stationOut+"_"+str(cur_i+1)+".rpt.dat"))
-                        shutil.copyfile(os.path.join(self.workingDir, stationOut+".rpt"),
-                                        os.path.join(self.workingDir, stationOut+"_"+str(cur_i+1)+".rpt"))
+                        shutil.copyfile(self.workingDir / (stationOut+".rpt.dat"),
+                                        self.workingDir / (stationOut+"_"+str(cur_i+1)+".rpt.dat"))
+                        shutil.copyfile(self.workingDir / (stationOut+".rpt"),
+                                        self.workingDir / (stationOut+"_"+str(cur_i+1)+".rpt"))
                         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"))
-                shutil.copyfile(os.path.join(self.workingDir, stationOut+"_"+str(i_best_overal+1)+".rpt"),
-                                os.path.join(self.workingDir, stationOut+".rpt"))
-
+                shutil.copyfile(self.workingDir / (stationOut+"_"+str(i_best_overal+1)+".rpt.dat"),
+                                self.workingDir / (stationOut+".rpt.dat"))
+                shutil.copyfile(self.workingDir/ (stationOut+"_"+str(i_best_overal+1)+".rpt"),
+                                self.workingDir / (stationOut+".rpt"))
 
                 # 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)
+                logging.info(_("cur_obj : %s ; cur_obj2 : %s"), cur_obj, cur_obj2)
                 if cur_obj != cur_obj2:
-                    logging.error("The objective function is not the same as the one computed")
+                    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
@@ -1441,7 +1549,7 @@ class Optimisation(wx.Frame):
         # Possibility to use the optimisation results enabled
         self.enable_MenuBar("Tools")
 
-        print("End of semi-distributed optimisation!")
+        logging.info(_("End of semi-distributed optimisation!"))
 
 
     # TO DO : Change this function to Case -> to make it compatible with several cases.
@@ -1468,11 +1576,11 @@ class Optimisation(wx.Frame):
 
         isOk = self.myCases[0].refCatchment.update_hydro(idCompar, fromLevel=False)
         tf = time_mod.process_time()
-        print("Time in update_hydro() : ", tf-t0)
-        print("curParam = ", self.curParams_vec_F)
-        print("All timeDelays = ", self.myCases[0].refCatchment.get_all_timeDelay())
+        logging.info(_("Time in update_hydro() : %s"), tf-t0)
+        logging.info(_("curParam = %s"), self.curParams_vec_F)
+        logging.info(_("All timeDelays = %s"), self.myCases[0].refCatchment.get_all_timeDelay())
         tf = time_mod.process_time()
-        print("Time in update_hydro() : ", tf-t0)
+        logging.info(_("Time in update_hydro() : %s"), tf-t0)
         return isOk
 
 
@@ -1583,32 +1691,32 @@ class Optimisation(wx.Frame):
                     self.saParam.change_param("Lowest values", paramName, 0.0)
                 else:
                     if float(cur_param) != 0.0:
-                        logging.warning("The parameters applied to timeDelays are different than the ones recommanded!")
-                        logging.warning("This procedure can be dangerous in semi distributed optimisation! Do it at your own risk!")
+                        logging.warning(_("The parameters applied to timeDelays are different than the ones recommanded!"))
+                        logging.warning(_("This procedure can be dangerous in semi distributed optimisation! Do it at your own risk!"))
 
                 cur_param = self.saParam.get_param("Highest values",paramName)
                 if cur_param is None:
                     self.saParam.change_param("Highest values", paramName, 5.0*24.0*3600.0)
                 else:
                     if float(cur_param) != 5.0*24.0*3600.0:
-                        logging.warning("The parameters applied to timeDelays are different than the ones recommanded!")
-                        logging.warning("This procedure can be dangerous in semi distributed optimisation! Do it at your own risk!")
+                        logging.warning(_("The parameters applied to timeDelays are different than the ones recommanded!"))
+                        logging.warning(_("This procedure can be dangerous in semi distributed optimisation! Do it at your own risk!"))
 
                 cur_param = self.saParam.get_param("Steps",paramName)
                 if cur_param is None:
                     self.saParam.change_param("Steps", paramName, self.myCases[idLauncher].refCatchment.deltaT)
                 else:
                     if float(cur_param) != self.myCases[idLauncher].refCatchment.deltaT:
-                        logging.warning("The parameters applied to timeDelays are different than the ones recommanded!")
-                        logging.warning("This procedure can be dangerous in semi distributed optimisation! Do it at your own risk!")
+                        logging.warning(_("The parameters applied to timeDelays are different than the ones recommanded!"))
+                        logging.warning(_("This procedure can be dangerous in semi distributed optimisation! Do it at your own risk!"))
 
                 cur_param = self.saParam.get_param("Initial parameters",paramName)
                 if cur_param is None:
                     self.saParam.change_param("Initial parameters", paramName, 1.0*3600.0)
                 else:
                     if float(cur_param) != 1.0*3600.0:
-                        logging.warning("The parameters applied to timeDelays are different than the ones recommanded!")
-                        logging.warning("This procedure can be dangerous in semi distributed optimisation! Do it at your own risk!")
+                        logging.warning(_("The parameters applied to timeDelays are different than the ones recommanded!"))
+                        logging.warning(_("This procedure can be dangerous in semi distributed optimisation! Do it at your own risk!"))
 
         else:
             self.nbParams = nbParamsModel
@@ -1828,7 +1936,7 @@ class Optimisation(wx.Frame):
                 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"))
+                shutil.copyfile(self.workingDir / compareFileName, self.workingDir /"compare.txt")
                 # 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
@@ -1881,7 +1989,7 @@ class Optimisation(wx.Frame):
                 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"))
+                shutil.copyfile(self.workingDir / compareFileName, self.workingDir /"compare.txt")
                 # 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
@@ -1927,7 +2035,7 @@ class Optimisation(wx.Frame):
 
         if format=="rpt":
             for cur_file in all_names:
-                optimFile = os.path.join(self.workingDir, cur_file+".rpt")
+                optimFile = self.workingDir / (cur_file+".rpt")
 
                 try:
                     with open(optimFile, newline = '') as fileID:
@@ -1955,7 +2063,7 @@ class Optimisation(wx.Frame):
 
         elif format==".dat":
             for cur_file in all_names:
-                optimFile = os.path.join(self.workingDir, cur_file+".rpt.dat")
+                optimFile = 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)
@@ -2140,18 +2248,18 @@ class Optimisation(wx.Frame):
         if intervals is None:
             self.all_intervals = self._read_opti_intervals(idLauncher=idLauncher)
 
-        compare_file = os.path.join(self.workingDir,"compare.how.param")
+        compare_file = 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")
+        compare_file_cp = 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")
+            compare_file_cp = self.workingDir / ("compare.how_"+suffix+".param")
             shutil.copyfile(compare_file, compare_file_cp)
-            print("The following file has been copied : ", compare_file_cp)
+            logging.info(_("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)
+            logging.info(_("The following file has been copied : %s"), compare_file_cp)
 
         if self.all_intervals is None:
             return -1
@@ -2192,16 +2300,17 @@ class Optimisation(wx.Frame):
         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]
+        # effective_intv = [interv for interv in all_intervals if interv[0]>=cur_basin.dateBegin and interv[1]<=cur_basin.dateEnd]
+        effective_intv = self._intersect_intervals(all_intervals, (cur_basin.dateBegin, cur_basin.dateEnd))
         if filter_nan:
             effective_intv = self._define_intervals_with_nan_measures(effective_intv, self.compareSubBasins,
                                                                       idLauncher=idLauncher, stationOut=stationOut)
-
+            effective_intv = self._define_intervals_with_nan_inlets(effective_intv, {cur_basin.name: cur_basin},
+                                                                    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 = ""):
+    def _define_intervals_with_ts(self, intervals: list[tuple[datetime.datetime, datetime.datetime]], time:np.ndarray, ts:np.ndarray, idLauncher: int = 0):
         """
         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
@@ -2209,7 +2318,7 @@ class Optimisation(wx.Frame):
 
         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.
+            ts (dict[str, SubBasin]): A dictionary of time series where the keys are station names and the values are vectors of numpy array.
             idLauncher (int, optional): The id of the launcher. Defaults to 0.
             stationOut (str, optional): The station name. Defaults to "".
 
@@ -2220,15 +2329,9 @@ class Optimisation(wx.Frame):
             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)
+        non_nan_locations = ~np.isnan(ts)
         within_intervals = np.sum(
             [(time >= datetime.datetime.timestamp(interv[0])) *
              (time <= datetime.datetime.timestamp(interv[1]))
@@ -2257,6 +2360,68 @@ class Optimisation(wx.Frame):
         return interv_dates
 
 
+    def _define_intervals_with_nan_inlets(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_inlets()
+        time = cur_el.time
+
+        return self._define_intervals_with_ts(intervals, time, hydro, idLauncher=idLauncher)
+
+
+    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
+
+        return self._define_intervals_with_ts(intervals, time, hydro, idLauncher=idLauncher)
+
+
     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
@@ -2321,7 +2486,7 @@ class Optimisation(wx.Frame):
             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)
+        logging.info(_("Reset init params : %s"), init_params)
         self.saParam.SavetoFile(None)
         self.saParam.Reload(None)
 
@@ -2509,7 +2674,7 @@ class Optimisation(wx.Frame):
         header = f"{data.shape[0]:d}\t{data.shape[1]:d}"
         # Write to file
         np.savetxt(
-            os.path.join(self.workingDir, "compare.txt"),
+            self.workingDir / "compare.txt",
             data,
             header=header,
             fmt=["%d", "%e"],
@@ -2580,7 +2745,7 @@ class Optimisation(wx.Frame):
         # 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')
+        writer_tot = pd.ExcelWriter(self.workingDir / "all_best_tests.xlsx", engine = 'xlsxwriter')
 
         for iOpti in range(len(sortJct)):
             stationOut = sortJct[iOpti]
@@ -2592,9 +2757,6 @@ class Optimisation(wx.Frame):
             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)
@@ -2604,6 +2766,9 @@ class Optimisation(wx.Frame):
             self.prepare_calibration_timeDelay(stationOut=stationOut)
             # Reload the useful modules
             self.reload_hydro(idCompar=0, fromStation=stationOut, lastLevel=previousLevel, updateAll=True)
+            # 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
             ## =======
@@ -2620,7 +2785,7 @@ class Optimisation(wx.Frame):
                 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)
+                logging.info(_("cur_obj : %s ; cur_obj2 : %s"), cur_obj, 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))
@@ -2652,7 +2817,7 @@ class Optimisation(wx.Frame):
 
             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')
+            writer_stat = pd.ExcelWriter(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()
@@ -2682,7 +2847,7 @@ class Optimisation(wx.Frame):
 
 
     def get_best_params(self, stationOut:str,
-                        criterion:str="Nash", quantile:float=0.99, std:float=0.05, eps:float=0.2, rmv_near_max=1e-4, nb_rand_close:int=10,
+                        criterion:str="Nash", quantile:float=None, std:float=None, eps:float=0.2, rmv_near_max=None, nb_rand_close:int=10,
                         objective_fct:bool= True, apply_clustering:bool=False, objective_weight:float=1.0):
         from sklearn.cluster import DBSCAN
         """
@@ -2701,10 +2866,19 @@ class Optimisation(wx.Frame):
 
         best_objfct = self.collect_optim()[-1]
         all_params, all_obj_fct = self.read_all_attempts_SA(format=".dat", all_attempts=True)
+        if quantile is not None:
+            quantile_cond = (all_obj_fct > np.quantile(all_obj_fct, quantile))
+        else:
+            quantile_cond = np.ones_like(all_obj_fct, dtype=bool)
+        if std is not None:
+            std_cond = (all_obj_fct > best_objfct*(1-std))
+        else:
+            std_cond = np.ones_like(all_obj_fct, dtype=bool)
+        if rmv_near_max is not None:
+            tooclose_cond = (all_obj_fct < best_objfct*(1-rmv_near_max)) | (all_obj_fct == best_objfct)
+        else:
+            tooclose_cond = np.ones_like(all_obj_fct, dtype=bool)
 
-        quantile_cond = (all_obj_fct > np.quantile(all_obj_fct, quantile))
-        std_cond = (all_obj_fct > best_objfct*(1-std))
-        tooclose_cond = (all_obj_fct < best_objfct*(1-rmv_near_max)) | (all_obj_fct == best_objfct)
         all_cond = np.where(quantile_cond & std_cond & tooclose_cond)[0]
         eff_params = all_params[all_cond]
         eff_obj = all_obj_fct[all_cond]
@@ -2723,13 +2897,19 @@ class Optimisation(wx.Frame):
                 tot_add_params = np.column_stack((selected_params, selected_obj))
                 # Add the selected parameters to the eff_params
                 eff_params = np.vstack((eff_params, tot_add_params))
-            # add to the eff_params
 
         # In this part we filter abd remove the parameters that are almost equivalent
         # To do so, we use the DBSCAN clustering algorithm to group the parameters that are close to each other
         # 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:
+            # If the number of lines of the parameters is higher than 500_000, we select a random sample of 500_000 lines
+            if np.shape(eff_params)[0] > 100_000:
+                logging.warning("The number of parameters is higher than 500_000. A random sample of 500_000 parameters will be selected.")
+                # Select a random sample of 500_000 lines
+                idx = np.random.choice(np.shape(eff_params)[0], size=100_000, replace=False)
+                eff_params = eff_params[idx]
+                return eff_params
             # "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)
@@ -2737,8 +2917,8 @@ class Optimisation(wx.Frame):
             # Add weight to the objective function to make it more important in the clustering
             # FIXME : to be improved
             norm_params[:,-1] = norm_params[:,-1]*objective_weight
-            # Apply the DBSCAN clustering algorithm to group the parameters
-            db = DBSCAN(eps=eps).fit(norm_params)
+            # Apply the DBSCAN clustering algorithm to group the parameters and conversion to float32 to avoid memory issues
+            db = DBSCAN(eps=eps,metric='euclidean').fit(norm_params.astype(np.float32))
             labels = db.labels_
             # Extraction of the number of groups and particular cases
             n_clusters = len(set(labels)) - (1 if -1 in labels else 0)
@@ -2785,7 +2965,8 @@ class Optimisation(wx.Frame):
             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)
+                interv += (curCatch.time>=date_i) & (curCatch.time<=date_f) & \
+                        (~np.isnan(compare)) & (~np.isnan(simul)) & (~np.isinf(simul))
         else:
             interv = np.ones(len(curCatch.time), dtype=bool)
 
@@ -2839,7 +3020,23 @@ class Optimisation(wx.Frame):
         return cur_fracts
 
     def _get_flow_fractions(self, idLauncher:int=0, stationOut:str="",
-                         intervals:list[tuple[datetime.datetime, datetime.datetime]]=[]) -> dict[list[str], list[float]]:
+                         intervals:list[tuple[datetime.datetime, datetime.datetime]]=[],
+                         from_full_matrix:tuple[np.ndarray, np.ndarray]=None) -> dict[list[str], list[float]]:
+        """This function retrieves the flow fractions for a given sub-basin.
+        It can also take a "full matrix" of internal variables to compute the fractions.
+        This "full matrix" is a tuple containing the ids of the internal variables and the matrix itself.
+
+        :param idLauncher: ID of the launcher, defaults to 0
+        :type idLauncher: int, optional
+        :param stationOut: Name of the outlet station, defaults to ""
+        :type stationOut: str, optional
+        :param intervals: List of start date and end date for the intervals to evaluate the flow fractions, defaults to []
+        :type intervals: list[tuple[datetime.datetime, datetime.datetime]], optional
+        :param from_full_matrix: Containing the matrix (nb_t, nb_iv) of I.V. coming from the Fortran code directly (not read in files), defaults to None
+        :type from_full_matrix: tuple[np.ndarray, np.ndarray], optional
+        :return: Dictionary containing the flow fractions for each type of flow with their names as keys and the fractions as values.
+        :rtype: dict[list[str], list[float]]
+        """
 
         curCatch:Catchment = self.myCases[idLauncher].refCatchment
         cur_key = curCatch.get_key_catchmentDict(stationOut)
@@ -2847,12 +3044,39 @@ class Optimisation(wx.Frame):
         if type(curBasin) != SubBasin:
             logging.warning("The current module is not a SubBasin object!")
             return None
-        cur_fracts = curBasin.get_flow_fractions(interval=intervals, summary="mean")
+        if from_full_matrix is not None:
+            ids, iv_matrix = from_full_matrix
+            all_f = mc.MODELS_VAR[curBasin.model].get_dict_from_matrix_and_ids(iv_matrix, list(ids),type_of_var=iv.FINAL_OUT_VAR)
+            all_f.update(mc.MODELS_VAR[curBasin.model].get_dict_from_matrix_and_ids(iv_matrix, list(ids),type_of_var=iv.DEFAULT_VAR))
+        else:
+            all_f = {}
+        cur_fracts = curBasin.get_flow_fractions(all_f=all_f, interval=intervals, summary="mean")
+        return cur_fracts
+
+    def _get_max_flow_fractions(self, idLauncher:int=0, stationOut:str="",
+                         intervals:list[tuple[datetime.datetime, datetime.datetime]]=[],
+                         from_full_matrix:tuple[np.ndarray, np.ndarray]=None) -> dict[list[str], list[float]]:
+
+        curCatch:Catchment = self.myCases[idLauncher].refCatchment
+        cur_key = curCatch.get_key_catchmentDict(stationOut)
+        curBasin: SubBasin = curCatch.catchmentDict[cur_key]
+        if type(curBasin) != SubBasin:
+            logging.warning("The current module is not a SubBasin object!")
+            return None
+        if from_full_matrix is not None:
+            ids, iv_matrix = from_full_matrix
+            all_f = mc.MODELS_VAR[curBasin.model].get_dict_from_matrix_and_ids(iv_matrix, list(ids),type_of_var=iv.FINAL_OUT_VAR)
+            all_f.update(mc.MODELS_VAR[curBasin.model].get_dict_from_matrix_and_ids(iv_matrix, list(ids),type_of_var=iv.DEFAULT_VAR))
+        else:
+            all_f = {}
+        cur_fracts = curBasin.get_flow_fractions(all_f=all_f, interval=intervals, summary="max")
+        cur_fracts = {"max"+key: value for key, value in cur_fracts.items()}
         return cur_fracts
 
 
     def _get_punctual_reservoir_fractions(self, eval_date:datetime.datetime,
-                                          idLauncher:int=0, stationOut:str="") -> dict[list[str], list[float]]:
+                                          idLauncher:int=0, stationOut:str="",
+                                          from_full_matrix:tuple[np.ndarray, np.ndarray]=None) -> dict[list[str], list[float]]:
 
         curCatch:Catchment = self.myCases[idLauncher].refCatchment
         cur_key = curCatch.get_key_catchmentDict(stationOut)
@@ -2860,10 +3084,15 @@ class Optimisation(wx.Frame):
         if type(curBasin) != SubBasin:
             logging.warning("The current module is not a SubBasin object!")
             return None
+        if from_full_matrix is not None:
+            ids, iv_matrix = from_full_matrix
+            all_iv = mc.MODELS_VAR[curBasin.model].get_dict_from_matrix_and_ids(iv_matrix, list(ids),type_of_var=iv.IV_VAR)
+        else:
+            all_iv = {}
         linked_params = mc.MODELS_VAR[curBasin.model].get_all_linked_params()
         i_params = self._get_key_from_type_all_parameters(list(linked_params.values()))
         max_params = {var_name: self.myParams[i_params[param_id]]["value"] for var_name, param_id in linked_params.items()}
-        cur_fracts = curBasin.get_iv_fractions_one_date(max_params=max_params, eval_date=eval_date)
+        cur_fracts = curBasin.get_iv_fractions_one_date(all_iv=all_iv,max_params=max_params, eval_date=eval_date)
         return cur_fracts
 
 
@@ -2938,7 +3167,7 @@ class Optimisation(wx.Frame):
 
         for iOpti in range(len(sortJct)):
             stationOut = sortJct[iOpti]
-            filename = os.path.join(self.workingDir, stationOut+"_tests.xlsx")
+            filename = self.workingDir / (stationOut+"_tests.xlsx")
             if os.path.isfile(filename):
                 df = pd.read_excel(filename, sheet_name=stationOut)
                 # Plot the physical properties
@@ -2953,7 +3182,7 @@ class Optimisation(wx.Frame):
                 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"))
+                fig.savefig( self.workingDir / ("Equifinality_physical_prop_"+stationOut+".png"))
                 # Plot the physical property volumes
                 fig, ax = plt.subplots()
                 for cur_prop, cur_color in zip(physical_properties_vol, colors_properties):
@@ -2966,7 +3195,7 @@ class Optimisation(wx.Frame):
                 ax.set_ylabel(y_label+" [-]")
                 ax.set_title("Proportion of rain volume : "+stationOut)
                 ax.legend()
-                fig.savefig(os.path.join(self.workingDir, "Equifinality_physical_prop_volumes_"+stationOut+".png"))
+                fig.savefig(self.workingDir / ("Equifinality_physical_prop_volumes_"+stationOut+".png"))
                 # Plot the Probability of exceedance
                 cur_color = colors_properties[0]
                 x_label = "P. of exceedance"
@@ -2977,7 +3206,7 @@ class Optimisation(wx.Frame):
                 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"))
+                fig.savefig(self.workingDir / ("Equifinality_prob_excess_"+stationOut+".png"))
                 # Plot Q_sim/Q_max
                 x_label = "Qmax_simul/Q_max_measure"
                 fig, ax = plt.subplots()
@@ -2987,7 +3216,7 @@ class Optimisation(wx.Frame):
                 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"))
+                fig.savefig(self.workingDir / ("Equifinality_peaks_ratio_"+stationOut+".png"))
                 # Plot % of the max runoff
                 x_label = "% max runoff"
                 fig, ax = plt.subplots()
@@ -2997,7 +3226,7 @@ class Optimisation(wx.Frame):
                 ax.set_ylabel(y_label+" [-]")
                 ax.set_title("Max runoff [%] : "+stationOut)
                 ax.legend()
-                fig.savefig(os.path.join(self.workingDir, "Equifinality_max_runoff_"+stationOut+".png"))
+                fig.savefig(self.workingDir / ("Equifinality_max_runoff_"+stationOut+".png"))
             else:
                 logging.error("The file "+filename+" does not exist!")
 
@@ -3017,13 +3246,13 @@ class Optimisation(wx.Frame):
 
         for iOpti in range(len(sortJct)):
             stationOut = sortJct[iOpti]
-            filename = os.path.join(self.workingDir, stationOut+"_tests.xlsx")
+            filename = 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(" ", "")]
+                    cur_columns = [col for col in df.columns if cur_prop in col.replace(" ", "").lower()]
                     if cur_columns != []:
                         corr_prop = cur_columns[0]
                         ax.scatter(df.loc[:,corr_prop], df.loc[:,y_label], s=0.5, c=cur_color,
@@ -3032,7 +3261,7 @@ class Optimisation(wx.Frame):
                 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"))
+                fig.savefig(self.workingDir / ("Equifinality_physical_prop_"+stationOut+".png"))
                 # Plot the Probability of exceedance
                 cur_color = colors_properties[0]
                 x_label = "P. of exceedance"
@@ -3043,7 +3272,7 @@ class Optimisation(wx.Frame):
                 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"))
+                fig.savefig(self.workingDir / ("Equifinality_prob_excess_"+stationOut+".png"))
                 # Plot Q_sim/Q_max
                 x_label = "Qmax_simul/Q_max_measure"
                 fig, ax = plt.subplots()
@@ -3053,7 +3282,7 @@ class Optimisation(wx.Frame):
                 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"))
+                fig.savefig(self.workingDir / ("Equifinality_peaks_ratio_"+stationOut+".png"))
 
             else:
                 logging.error("The file "+filename+" does not exist!")
@@ -3068,7 +3297,7 @@ class Optimisation(wx.Frame):
         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")
+            logging.error("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:
@@ -3085,19 +3314,19 @@ class Optimisation(wx.Frame):
                 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)
+                    logging.error("ERROR : in path of launcherDir")
+                newCase.mydro = HydrologyModel(directory=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!")
+                logging.warning(_("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)
+            newCase.mydro = HydrologyModel(directory=refDir)
 
         self.Bind(wx.EVT_MENU, newCase.show_launcherParam, curCase)
         newCase.idMenuItem = newId
@@ -3158,7 +3387,7 @@ class Optimisation(wx.Frame):
                 all_outlets[stationOut][i,:] = curBasin.outFlow
                 # Small test
                 cur_obj = all_params[i, -1]
-                print("cur_obj : ", cur_obj, " ; cur_obj2 : ", cur_obj2)
+                logging.info(_("cur_obj : %s ; cur_obj2 : %s"), cur_obj, 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))
@@ -3217,7 +3446,7 @@ class Optimisation(wx.Frame):
 
     # FIXME : this function has been dashed off -> functionnal but not well written!!
     # TODO : to improve !!!!!!
-    def launch_models_propertie_with_Nash(self, event, idLauncher:int=0, idOpti:int=1, quantile_Nash:float=0.01, std_Nash:float=0.03, clustering_Nash:bool=True,
+    def launch_models_propertie_with_Nash_old(self, event, idLauncher:int=0, idOpti:int=1, quantile_Nash:float=0.01, std_Nash:float=0.03, clustering_Nash:bool=True,
                                           save_every:int=100, restart_from_file:bool=True):
         """
         Analyse the properties of the model and compare them with the Nash coefficient.
@@ -3248,7 +3477,7 @@ class Optimisation(wx.Frame):
         # 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')
+        writer_tot = pd.ExcelWriter(self.workingDir / "all_best_tests.xlsx", engine = 'xlsxwriter')
 
         for iOpti in range(len(sortJct)):
             stationOut = sortJct[iOpti]
@@ -3293,7 +3522,7 @@ class Optimisation(wx.Frame):
                 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)
+                logging.info(_("cur_obj : %s ; cur_obj2 : %s"), cur_obj, 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))
@@ -3301,6 +3530,7 @@ class Optimisation(wx.Frame):
                 self.write_mesh_results_optimizer(idOpti=idOpti)
                 # Save all the variables/evaluations desired
                 frac_flow_dict = self._get_flow_fractions(idLauncher=idLauncher, stationOut=stationOut, intervals=cur_intervals)
+                max_flow_dict = self._get_max_flow_fractions(idLauncher=idLauncher, stationOut=stationOut, intervals=cur_intervals)
                 init_iv =  self._get_punctual_reservoir_fractions(eval_date=cur_intervals[0][0], idLauncher=idLauncher, stationOut=stationOut)
                 p_excess = self._get_exceedance(idLauncher=idLauncher, stationOut=stationOut, intervals=cur_intervals)
                 max_sim_obs = self._get_ratio_max_sim_obs(idLauncher=idLauncher, stationOut=stationOut, intervals=cur_intervals)
@@ -3312,6 +3542,7 @@ class Optimisation(wx.Frame):
                 cur_all_frac = (list(cur_p)
                                 + cur_timeDelays
                                 + list(frac_flow_dict.values())
+                                + list(max_flow_dict.values())
                                 + list(init_iv.values())
                                 + [p_excess, max_sim_obs, cur_obj])
                 all_frac.append(cur_all_frac)
@@ -3321,30 +3552,203 @@ class Optimisation(wx.Frame):
                     var_names = names \
                                 + list(all_timeDelays_str.keys()) \
                                 + list(frac_flow_dict.keys()) \
+                                + list(max_flow_dict.keys()) \
                                 + list(init_iv.keys()) \
                                 + ["P. of exceedance", "Qmax_simul/Q_max_measure", "Nash"]
                     cur_df = pd.DataFrame(all_frac, columns=var_names)
                     # write first the tempory results for each station
-                    writer_stat = pd.ExcelWriter(os.path.join(self.workingDir, stationOut+"_tests.xlsx"), engine = 'xlsxwriter')
+                    writer_stat = pd.ExcelWriter(self.workingDir / (stationOut+"_tests.xlsx"), engine = 'xlsxwriter')
                     cur_df.to_excel(writer_stat, sheet_name=stationOut, columns=var_names)
                     writer_stat.sheets[stationOut].autofit()
                     writer_stat.close()
 
             # Save the evaluations
-            var_names = names \
-                        + list(all_timeDelays_str.keys()) \
-                        + list(frac_flow_dict.keys()) \
-                        + list(init_iv.keys()) \
-                        + ["P. of exceedance", "Qmax_simul/Q_max_measure", "Nash"]
-            cur_df = pd.DataFrame(all_frac, columns=var_names)
-            # write first the tempory results for each station
-            writer_stat = pd.ExcelWriter(os.path.join(self.workingDir, stationOut+"_tests.xlsx"), engine = 'xlsxwriter')
-            cur_df.to_excel(writer_stat, sheet_name=stationOut, columns=var_names)
-            writer_stat.sheets[stationOut].autofit()
-            writer_stat.close()
-            # write now the informations for all the stations in the same excel file
-            cur_df.to_excel(writer_tot, sheet_name=stationOut, columns=var_names)
-            writer_tot.sheets[stationOut].autofit()
+            if(len(all_params))>0:
+                var_names = names \
+                            + list(all_timeDelays_str.keys()) \
+                            + list(frac_flow_dict.keys()) \
+                            + list(max_flow_dict.keys()) \
+                            + list(init_iv.keys()) \
+                            + ["P. of exceedance", "Qmax_simul/Q_max_measure", "Nash"]
+                cur_df = pd.DataFrame(all_frac, columns=var_names)
+                # write first the tempory results for each station
+                writer_stat = pd.ExcelWriter(self.workingDir / (stationOut+"_tests.xlsx"), engine = 'xlsxwriter')
+                cur_df.to_excel(writer_stat, sheet_name=stationOut, columns=var_names)
+                writer_stat.sheets[stationOut].autofit()
+                writer_stat.close()
+                # write now the informations for all the stations in the same excel file
+                cur_df.to_excel(writer_tot, sheet_name=stationOut, columns=var_names)
+                writer_tot.sheets[stationOut].autofit()
+
+            ## =======
+            ## =======
+            # Collect the best parameters and their objective function(s)
+            best_params = self.apply_optim(None)
+            # Simulation with the best parameters
+            self.compute_distributed_hydro_model()
+            # Update myHydro of all effective subbasins to get the best configuration upstream
+            curCatch.read_hydro_eff_subBasin()
+            # Update timeDelays according to time wolf_array
+            self.apply_timeDelay_dist(idOpti=idOpti, idLauncher=idLauncher, junctionKey=stationOut)
+            # Update the outflows
+            curCatch.update_hydro(idCompar=0)
+
+            # All upstream elements of a reference will be fixed
+            doneList.append(stationOut)
+            previousLevel = curCatch.levelOut
+
+        writer_tot.close()
+        logging.info("The equifinality test is finished!")
+
+    # FIXME : this function has been dashed off -> functionnal but not well written!!
+    # TODO : to improve !!!!!!
+    def launch_models_propertie_with_Nash_old2(self, event, idLauncher:int=0, idOpti:int=1, quantile_Nash:float=0.01, std_Nash:float=0.03, clustering_Nash:bool=True,
+                                          save_every:int=1000, restart_from_file:bool=True,
+                                          intervals:list[tuple[datetime.datetime, datetime.datetime]]=[]):
+        """
+        Analyse the properties of the model and compare them with the Nash coefficient.
+
+        Args:
+            idLauncher (int, optional): The id of the launcher. Defaults to 0.
+
+        Returns:
+            None
+
+        Raises:
+            None
+        """
+        curCatch:Catchment = self.myCases[idLauncher].refCatchment
+
+        onlyOwnSub = self.optiParam.get_param("Semi-Distributed", "Own_SubBasin")
+        if onlyOwnSub is None:
+            onlyOwnSub = False
+        doneList = []
+        previousLevel = 1
+        # Collect sort and save the compare stations
+        self.set_compare_stations(idLauncher=idLauncher)
+        sortJct = self.myStations
+        # Get the initial number of intervals
+        # -> these can evolve according to the measurement available at each station
+        is_ok = self._save_opti_intervals()
+        all_intervals = self.all_intervals
+        # Activate the writing of the internal variables
+        curCatch.activate_all_internal_variables()
+        # Prepare the Excel writer
+        writer_tot = pd.ExcelWriter(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)
+            flood_intervals = (date(2021, 7, 13, 0, 0, 0, tzinfo=datetime.timezone.utc),
+                                    date(2021, 7, 17, 0, 0, 0, tzinfo=datetime.timezone.utc))
+            phys_prop_intervals = self._intersect_intervals(cur_intervals, flood_intervals)
+            self.save_opti_dates_to_file(cur_intervals)
+            # Rename the result file
+            self.optiParam.change_param("Optimizer", "fname", stationOut)
+            self.optiParam.SavetoFile(None)
+            self.optiParam.Reload(None)
+            self.update_myParams(idLauncher)
+            # Prepare the paramPy dictionnary before calibration
+            self.prepare_calibration_timeDelay(stationOut=stationOut)
+            # Reload the useful modules
+            self.reload_hydro(idCompar=0, fromStation=stationOut, lastLevel=previousLevel, updateAll=True)
+            ## =======
+            ## Init
+            ## =======
+            self.init_optimizer(idOpti)
+            self.associate_ptr(None, idOpti=idOpti)
+            # Get the best parameters to test
+            all_params = self.get_best_params(stationOut=stationOut, quantile=quantile_Nash, std=std_Nash, rmv_near_max=1e-4, apply_clustering=clustering_Nash)
+            ## =======
+            ## Compute
+            ## =======
+            all_frac = []
+            ids = None
+            iv_matrix = None
+            # Check if the excel file already exists and load it to check if some parameters have already been tested
+            if restart_from_file:
+                all_frac, all_params = self._reload_model_analysis(stationOut=stationOut, all_params=all_params)
+            # Get param names
+            names = self.get_param_names(idLauncher=idLauncher, stationOut=stationOut)
+            logging.info("The number of sets of parameters to test are : "+str(len(all_params)))
+            for i in tqdm(range(len(all_params))):
+                cur_p = all_params[i, :-1]
+                cur_obj = all_params[i, -1]
+                cur_obj2 = self.evaluate_model_optimizer(cur_p, idOpti=idOpti)
+                logging.info(_("cur_obj : %s ; cur_obj2 : %s"), cur_obj, 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 : %s ; cur_obj2 : %s"), cur_obj, cur_obj2)
+                # Recover the full matrix from Fortran
+                if ids is None or iv_matrix is None:
+                    iv_data = None
+                else:
+                    iv_data = (ids, iv_matrix)
+                ids, iv_matrix = self.get_all_activated_iv(idOpti=idOpti, idLauncher=idLauncher, iv_variables=iv_data)
+                # Save all the variables/evaluations desired
+                frac_flow_dict = self._get_flow_fractions(idLauncher=idLauncher, stationOut=stationOut, intervals=phys_prop_intervals,
+                                                          from_full_matrix=(ids, iv_matrix))
+                max_flow_dict = self._get_max_flow_fractions(idLauncher=idLauncher, stationOut=stationOut, intervals=phys_prop_intervals,
+                                                             from_full_matrix=(ids, iv_matrix))
+                init_iv =  self._get_punctual_reservoir_fractions(eval_date=cur_intervals[0][0], idLauncher=idLauncher, stationOut=stationOut,
+                                                                  from_full_matrix=(ids, iv_matrix))
+                p_excess = self._get_exceedance(idLauncher=idLauncher, stationOut=stationOut, intervals=cur_intervals)
+                max_sim_obs = self._get_ratio_max_sim_obs(idLauncher=idLauncher, stationOut=stationOut, intervals=cur_intervals)
+                # Extract the time delays
+                all_timeDelays = curCatch.get_timeDelays_inlets(ref=stationOut)
+                all_timeDelays_str = {key : str(datetime.timedelta(seconds=all_timeDelays[key])) for key in all_timeDelays}
+                cur_timeDelays = list(all_timeDelays_str.values())
+                # Concatenate all the informations
+                cur_all_frac = (list(cur_p)
+                                + cur_timeDelays
+                                + list(frac_flow_dict.values())
+                                + list(max_flow_dict.values())
+                                + list(init_iv.values())
+                                + [p_excess, max_sim_obs, cur_obj])
+                all_frac.append(cur_all_frac)
+                # Periodically save the evaluations in case of trouble
+                if (i + 1) % save_every == 0:
+                    # Save the evaluations
+                    var_names = names \
+                                + list(all_timeDelays_str.keys()) \
+                                + list(frac_flow_dict.keys()) \
+                                + list(max_flow_dict.keys()) \
+                                + list(init_iv.keys()) \
+                                + ["P. of exceedance", "Qmax_simul/Q_max_measure", "Nash"]
+                    cur_df = pd.DataFrame(all_frac, columns=var_names)
+                    # write first the tempory results for each station
+                    writer_stat = pd.ExcelWriter(self.workingDir / (stationOut+"_tests.xlsx"), engine = 'xlsxwriter')
+                    cur_df.to_excel(writer_stat, sheet_name=stationOut, columns=var_names)
+                    writer_stat.sheets[stationOut].autofit()
+                    writer_stat.close()
+
+
+            # Save the evaluations
+            if(len(all_params))>0:
+                var_names = names \
+                            + list(all_timeDelays_str.keys()) \
+                            + list(frac_flow_dict.keys()) \
+                            + list(max_flow_dict.keys()) \
+                            + list(init_iv.keys()) \
+                            + ["P. of exceedance", "Qmax_simul/Q_max_measure", "Nash"]
+                cur_df = pd.DataFrame(all_frac, columns=var_names)
+                # write first the tempory results for each station
+                writer_stat = pd.ExcelWriter(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()
 
             ## =======
             ## =======
@@ -3366,6 +3770,159 @@ class Optimisation(wx.Frame):
         writer_tot.close()
         logging.info("The equifinality test is finished!")
 
+
+    # FIXME : this function has been dashed off -> functionnal but not well written!!
+    # TODO : to improve !!!!!!
+    def launch_models_properties_with_Nash(self, event, idLauncher:int=0, idOpti:int=1, quantile_Nash:float=0.01, std_Nash:float=0.03, clustering_Nash:bool=False,
+                                          save_every:int=1000, restart_from_file:bool=False,
+                                          evaluation_interval:tuple[datetime.datetime, datetime.datetime]=[]):
+        """
+        Analyse the properties of the model and compare them with the Nash coefficient.
+
+        Args:
+            idLauncher (int, optional): The id of the launcher. Defaults to 0.
+
+        Returns:
+            None
+
+        Raises:
+            None
+        """
+        curCatch:Catchment = self.myCases[idLauncher].refCatchment
+        try:
+            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
+            self.all_intervals = self._read_opti_intervals(idLauncher=idLauncher)
+            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(self.workingDir / "all_best_tests.xlsx", engine = 'xlsxwriter')
+
+            for iOpti in range(len(sortJct)):
+                stationOut = sortJct[iOpti]
+                logging.info("==================")
+                logging.info("Station : "+stationOut)
+                isOk, cur_intervals = self.prepare_optimize_model_F_one_station(stationOut=stationOut, idLauncher=idLauncher, idOpti=idOpti,
+                                                        all_intervals=all_intervals, already_done_subbasins=doneList,
+                                                        onlyOwnSub=onlyOwnSub, previousLevel=previousLevel,
+                                                        return_intervals=True)
+                # Get the best parameters to test
+                all_params = self.get_best_params(stationOut=stationOut, quantile=None, std=0.1, rmv_near_max=None, apply_clustering=clustering_Nash)
+                ## =======
+                ## Compute loop
+                ## =======
+                # FIXME : if no list, just keep the cur_intervals and also no intervals intersection application
+                if evaluation_interval == []:
+                    evaluation_interval = (date(2021, 7, 13, 0, 0, 0, tzinfo=datetime.timezone.utc),
+                                        date(2021, 7, 17, 0, 0, 0, tzinfo=datetime.timezone.utc))
+                phys_prop_intervals = self._intersect_intervals(cur_intervals, evaluation_interval)
+                all_frac = []
+                ids = None
+                iv_matrix = None
+                # Check if the excel file already exists and load it to check if some parameters have already been tested
+                if restart_from_file:
+                    all_frac, all_params = self._reload_model_analysis(stationOut=stationOut, all_params=all_params)
+                # Get param names
+                names = self.get_param_names(idLauncher=idLauncher, stationOut=stationOut)
+                logging.info("The number of sets of parameters to test are : "+str(len(all_params)))
+                for i in tqdm(range(len(all_params))):
+                    cur_p = all_params[i, :-1]
+                    cur_obj = all_params[i, -1]
+                    cur_obj2 = self.evaluate_model_optimizer(cur_p, idOpti=idOpti)
+                    logging.info(_("cur_obj : %s ; cur_obj2 : %s"), cur_obj, 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 : %s ; cur_obj2 : %s"), cur_obj, cur_obj2)
+                    # Recover the full matrix from Fortran
+                    if ids is None or iv_matrix is None:
+                        iv_data = None
+                    else:
+                        iv_data = (ids, iv_matrix)
+                    ids, iv_matrix = self.get_all_activated_iv(idOpti=idOpti, idLauncher=idLauncher, iv_variables=iv_data)
+                    # Save all the variables/evaluations desired
+                    frac_flow_dict = self._get_flow_fractions(idLauncher=idLauncher, stationOut=stationOut, intervals=phys_prop_intervals,
+                                                            from_full_matrix=(ids, iv_matrix))
+                    max_flow_dict = self._get_max_flow_fractions(idLauncher=idLauncher, stationOut=stationOut, intervals=phys_prop_intervals,
+                                                                from_full_matrix=(ids, iv_matrix))
+                    init_iv =  self._get_punctual_reservoir_fractions(eval_date=cur_intervals[0][0], idLauncher=idLauncher, stationOut=stationOut,
+                                                                    from_full_matrix=(ids, iv_matrix))
+                    p_excess = self._get_exceedance(idLauncher=idLauncher, stationOut=stationOut, intervals=cur_intervals)
+                    max_sim_obs = self._get_ratio_max_sim_obs(idLauncher=idLauncher, stationOut=stationOut, intervals=cur_intervals)
+                    # Extract the time delays
+                    all_timeDelays = curCatch.get_timeDelays_inlets(ref=stationOut)
+                    all_timeDelays_str = {key : str(datetime.timedelta(seconds=all_timeDelays[key])) for key in all_timeDelays}
+                    cur_timeDelays = list(all_timeDelays_str.values())
+                    # Concatenate all the informations
+                    cur_all_frac = (list(cur_p)
+                                    + cur_timeDelays
+                                    + list(frac_flow_dict.values())
+                                    + list(max_flow_dict.values())
+                                    + list(init_iv.values())
+                                    + [p_excess, max_sim_obs, cur_obj])
+                    all_frac.append(cur_all_frac)
+                    # Periodically save the evaluations in case of trouble
+                    if (i + 1) % save_every == 0:
+                        # Save the evaluations
+                        var_names = names \
+                                    + list(all_timeDelays_str.keys()) \
+                                    + list(frac_flow_dict.keys()) \
+                                    + list(max_flow_dict.keys()) \
+                                    + list(init_iv.keys()) \
+                                    + ["P. of exceedance", "Qmax_simul/Q_max_measure", "Nash"]
+                        cur_df = pd.DataFrame(all_frac, columns=var_names)
+                        # write first the tempory results for each station
+                        writer_stat = pd.ExcelWriter(self.workingDir / (stationOut+"_tests.xlsx"), engine = 'xlsxwriter')
+                        cur_df.to_excel(writer_stat, sheet_name=stationOut, columns=var_names)
+                        writer_stat.sheets[stationOut].autofit()
+                        writer_stat.close()
+
+
+                # Save the evaluations
+                if(len(all_params))>0:
+                    var_names = names \
+                                + list(all_timeDelays_str.keys()) \
+                                + list(frac_flow_dict.keys()) \
+                                + list(max_flow_dict.keys()) \
+                                + list(init_iv.keys()) \
+                                + ["P. of exceedance", "Qmax_simul/Q_max_measure", "Nash"]
+                    cur_df = pd.DataFrame(all_frac, columns=var_names)
+                    # write first the tempory results for each station
+                    writer_stat = pd.ExcelWriter(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()
+
+                ## =======
+                ## =======
+                # Reset the configuration of the optimal parameters in all file and in all variables
+                self.reload_optimal_subbasin(idLauncher=idLauncher, idOpti=idOpti, stationOut=stationOut)
+
+                # 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)
+            writer_tot.close()
+        except Exception as e:
+            logging.error("An error occurred during the model properties analysis: " + str(e))
+            # Reset the optimisation file
+            self.save_opti_dates_to_file(self.all_intervals)
+            raise e
+        logging.info("The equifinality test is finished!")
+
     # FIXME : it might be better to pass the myParams to the CaseOpti object instead to allow parallelisation
     def _build_type_to_key_index(self) -> dict[int, int]:
         return {param["type"]: i for i, param in self.myParams.items()}
@@ -3377,6 +3934,160 @@ class Optimisation(wx.Frame):
     def _get_key_from_type_parameter(self, type_param:int) -> int:
         return next((i for i, param in self.myParams.items() if param["type"] == type_param), None)
 
+    def _intersect_intervals(self, intervals:list[tuple[date, date]], flood_intervals:tuple[date, date]):
+        result = []
+        flood_start, flood_end = flood_intervals
+        for int_start, int_end in intervals:
+            # Find overlap
+            start = max(int_start, flood_start)
+            end = min(int_end, flood_end)
+            if start < end:  # There is an overlap
+                result.append((start, end))
+        return result
+
+    def reload_optimal_subbasin(self, idLauncher:int=0, idOpti:int=1, stationOut:str=None):
+        """
+        Reload the optimal subbasin for a given idLauncher and idOpti.
+
+        Args:
+            idLauncher (int): The id of the launcher.
+            idOpti (int): The id of the optimizer.
+            stationOut (str): The name of the station.
+
+        Returns:
+            None
+
+        Raises:
+            None
+        """
+        # Get the current catchment
+        curCatch:Catchment = self.myCases[idLauncher].refCatchment
+        # 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)
+
+
+
+    def init_optimize_model_f(self, idOpti:int=1):
+        """
+        Initialize the optimization model for a given idOpti.
+
+        Args:
+            idOpti (int): The id of the optimizer.
+
+        Returns:
+            None
+
+        Raises:
+            None
+        """
+        # Initialize the optimizer
+        self.init_optimizer(idOpti)
+        # Associate the pointer to the optimizer
+        self.associate_ptr(None, idOpti=idOpti)
+
+
+    def prepare_optimize_model_F_one_station(self, idLauncher:int=0, idOpti:int=1, stationOut:str=None, all_intervals:list[tuple[date, date]]=[],
+                                          onlyOwnSub:bool=True, previousLevel:int=1, already_done_subbasins:list[str]=[],
+                                          return_intervals:bool=False):
+        isOk = 0
+        # Get the current catchment
+        curCatch:Catchment = self.myCases[idLauncher].refCatchment
+        # Define the outlet station and keep the same if not provided
+        if stationOut is None:
+            stationOut = curCatch.junctionOut
+        # Select and save the compare file off the outlet station
+        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=already_done_subbasins, onlyItself=True)
+        # Select correct calibration intervals -> remove the intervals with NaN
+        if all_intervals == []:
+            all_intervals = self._read_opti_intervals(idLauncher=idLauncher)
+        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_optimize_model_f(idOpti=idOpti)
+
+        if return_intervals:
+            return isOk, cur_intervals
+        else:
+            return isOk
+
+
+    def extract_hydro_from_params(self, idLauncher:int=0, idOpti:int=1, stationOut:str=None,
+                                  all_params:np.ndarray=None):
+        """
+        Extract the hydro from the parameters.
+
+        Args:
+            idLauncher (int): The id of the launcher.
+            idOpti (int): The id of the optimizer.
+            stationOut (str): The name of the station.
+            all_params (np.ndarray): The parameters to be tested.
+
+        Returns:
+            None
+
+        Raises:
+            None
+        """
+        if all_params is None:
+            all_params = self.get_best_params(stationOut=stationOut, quantile=0.01, std=0.03, rmv_near_max=1e-4, apply_clustering=True)
+
+        cur_catch = self.myCases[idLauncher].refCatchment
+        self.all_intervals = self._read_opti_intervals(idLauncher=idLauncher)
+        # Prepare the optimization model for one station
+        self.prepare_optimize_model_F_one_station(idLauncher=idLauncher, idOpti=idOpti, stationOut=stationOut)
+        # Init the matrix of hydrographs
+        nb_tests = np.shape(all_params)[0]
+        optimal_hydro = cur_catch.get_outflow()
+        test_hydro = np.zeros((nb_tests, len(optimal_hydro)))
+
+        # Evaluate the model with the parameters
+        for i in tqdm(range(nb_tests)):
+            cur_p = all_params[i, :-1]
+            cur_obj = all_params[i, -1]
+            cur_obj2 = self.evaluate_model_optimizer(cur_p, idOpti=idOpti)
+            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))
+            test_hydro[i, :] = cur_catch.get_outflow()
+
+        # Reset the configuration of the optimal parameters in all file and in all variables
+        self.reload_optimal_subbasin(idLauncher=idLauncher, idOpti=idOpti, stationOut=stationOut)
+        optimal_hydro_2 = cur_catch.get_outflow()
+        if not np.allclose(optimal_hydro, optimal_hydro_2):
+            logging.error("The optimal hydrograph is not the same as the one computed by the model!")
+            logging.error("optimal_hydro : "+str(optimal_hydro)+" ; optimal_hydro_2 : "+str(optimal_hydro_2))
+
+        # Reset the optimisation file
+        self.save_opti_dates_to_file(self.all_intervals)
+        # One of the test_hydro should be the same as the optimal hydrograph
+        # if np.min(test_hydro-optimal_hydro, axis=1)<1e-3:
+        #     return test_hydro, optimal_hydro
+        # if not np.allclose(test_hydro, optimal_hydro):
+
+        return test_hydro, optimal_hydro
 
     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
@@ -3395,7 +4106,7 @@ class Optimisation(wx.Frame):
         else:
             return arr
 
-    def _reload_model_analysis(self, stationOut:str, all_params:np.ndarray):
+    def _reload_model_analysis(self, stationOut:str, all_params:np.ndarray)-> tuple[list, np.ndarray]:
         """
         Reload the model analysis for a given station.
 
@@ -3410,11 +4121,11 @@ class Optimisation(wx.Frame):
             None
         """
         # Check if the excel file already exists and load it to check if some parameters have already been tested
-        filename = os.path.join(self.workingDir, stationOut+"_tests.xlsx")
+        filename = self.workingDir / (stationOut+"_tests.xlsx")
         # just_params = all_params[:, :-1]
         nb_params = np.shape(all_params)[1] - 1
         if os.path.isfile(filename):
-            df = pd.read_excel(os.path.join(self.workingDir, stationOut+"_tests.xlsx"), sheet_name=stationOut)
+            df = pd.read_excel(self.workingDir / (stationOut+"_tests.xlsx"), sheet_name=stationOut)
             # Extract all the values of the dataframe in a list
             all_data_tested = df.iloc[:, 1:].values.tolist()
             # Extract all the values of the dataframe in a numpy array
@@ -3423,4 +4134,4 @@ class Optimisation(wx.Frame):
             new_params = np.array([el for el in all_params if ~np.any(np.all(np.isclose(all_params_tested, el[:-1], atol=1e-6), axis=1))])
             return all_data_tested, new_params
 
-        return [], all_params
+        return [], all_params