wolfhece 1.8.12__py3-none-any.whl → 2.0.0__py3-none-any.whl

wolfhece/hydrology/Optimisation.py

@@ -92,9 +92,10 @@ class Optimisation(wx.Frame):
     # launcherDir:list
     myParams:dict
     myParamsPy:dict
-    curParams_vec:np.ndarray
+    curParams_vec_F:np.ndarray
     nbParams:int
-    optiFactor:ct.c_double
+    optiFactor_F:ct.c_double
+    bestFactor:float
 
     comparHowParam:Wolf_Param
     # launcherParam:Wolf_Param
@@ -140,7 +141,7 @@ class Optimisation(wx.Frame):
         self.myStations = []
         self.compareFilesDict = {}
 
-        self.curParams_vec = None
+        self.curParams_vec_F = None
 
         if self.debugDLL:
             self.load_dll(self.pathDll, DLL_FILE_DEBUG)
@@ -415,14 +416,41 @@ class Optimisation(wx.Frame):
         if self.debugDLL:
             self.enable_MenuBar("Debug")
     
-    def apply_optim(self, event, idLauncher=0):
 
-        # Get the best parameters
-        bestParams = self.collect_optim()
+    def apply_optim(self, event, idLauncher:int=0, replace_only_if_better:bool=False, optim_params:np.ndarray=None):
+        """
+        Apply optimal parameters based on the results file of the optimisation : ".rpt".
 
-        self.apply_optim_2_params(bestParams[:-1], idLauncher=idLauncher)
+        Args:
+            event: The event from the GUI.
+            idLauncher (optional: int(0)): The ID of the launcher.
+            replace_only_if_better (optional: bool(False) by default): A boolean indicating whether to replace the current parameters if the new ones are better.
 
-        self.optiFactor = ct.c_double(bestParams[-1])
+        Returns:
+            If replace_only_if_better is False, returns the best parameters found.
+            If replace_only_if_better is True and the new parameters are better, returns the best parameters found.
+            Otherwise, returns None.
+        """
+        # Get the best parameters
+        if optim_params is None:
+            bestParams:np.array = self.collect_optim()
+        else:
+            # FIXME : gneralise the -1 for the test for any number of objective function
+            assert self.nbParams==len(optim_params)-1, "ERROR : the number of parameters to appy are the ones expected!"
+            bestParams:np.array = optim_params
+
+        test_best = bestParams[-1] # FIXME : gneralise the -1 for the test for any number of objective function
+        if not replace_only_if_better:
+            self.apply_optim_2_params(bestParams[:-1], idLauncher=idLauncher)
+            self.bestFactor = test_best
+            return bestParams
+        elif test_best>self.bestFactor:
+            self.apply_optim_2_params(bestParams[:-1], idLauncher=idLauncher)
+            self.bestFactor = bestParams[-1]
+            return bestParams
+        else:
+            return None
+        
 
 
     # Initialisation of the Optimizer from Fortran
@@ -567,9 +595,14 @@ class Optimisation(wx.Frame):
                     self.myParamsPy[i]["junction_name"] = self.myCases[idLauncher].launcherParam.get_param(curParam, "junction_name")
 
 
-    def collect_optim(self):
+    def collect_optim(self, fileName=""):
+
+        isOk,fileName = check_path(fileName, self.workingDir)
+        if fileName=="":
+            nameTMP = self.optiParam.get_param("Optimizer","fname")
+        else:
+            isOk,nameTMP = check_path(fileName, self.workingDir)
 
-        nameTMP = self.optiParam.get_param("Optimizer","fname")
         optimFileTxt = os.path.join(self.workingDir, nameTMP+".rpt")
         optimFileBin = os.path.join(self.workingDir, nameTMP+".rpt.dat")
         
@@ -1096,9 +1129,9 @@ class Optimisation(wx.Frame):
         dims = np.empty((ndims,), dtype=ct.c_int, order='F')
         # The only dimension is the number of parameters to calibrate
         dims[0] = self.nbParams
-        self.curParams_vec = np.empty((self.nbParams,), dtype=ct.c_double, order='F')
+        self.curParams_vec_F = np.empty((self.nbParams,), dtype=ct.c_double, order='F')
         # creation of the c_ptr to give to fortran to reconstruct the tensors
-        pointerParam = self.curParams_vec.ctypes.data_as(ct.POINTER(ct.c_double))
+        pointerParam = self.curParams_vec_F.ctypes.data_as(ct.POINTER(ct.c_double))
         pointerDims = dims.ctypes.data_as(ct.POINTER(ct.c_int))
         # call of the Fortran function
         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),
@@ -1115,12 +1148,12 @@ class Optimisation(wx.Frame):
         dims = np.empty((ndims,), dtype=ct.c_int, order='F')
         # The only dimension is the number of parameters to calibrate
         dims[0] = 1
-        self.optiFactor = ct.c_double(0.0)
+        self.optiFactor_F = ct.c_double(0.0)
         # creation of the c_ptr to give to fortran to reconstruct the tensors
         pointerDims = dims.ctypes.data_as(ct.POINTER(ct.c_int))
         # call of the Fortran function
         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))
+                                        pointerDims, ct.byref(self.optiFactor_F))
 
         print("End of factor pointer association.")
 
@@ -1151,8 +1184,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)
-        print("Best Factor = ", self.optiFactor)
+        print("Best parameters : ", self.curParams_vec_F)
+        print("Best Factor = ", self.optiFactor_F)
 
         # Apply the best parameters
         self.apply_optim(None)
@@ -1175,7 +1208,17 @@ class Optimisation(wx.Frame):
 
 
     def launch_semiDistributed_optimisation(self, event, idOpti=1, idLauncher=0):
+        """
+        Procedure launching the semi-distributed optimisation process.
 
+        Args:
+            event: The event triggering the optimisation.
+            idOpti (int): The ID of the optimizer in Fortran.
+            idLauncher (int): The ID of the launcher.
+
+        Returns:
+            None
+        """
         curCatch:Catchment = self.myCases[idLauncher].refCatchment
 
         if (self.optiParam.get_group("Semi-Distributed"))is not None:
@@ -1193,6 +1236,18 @@ class Optimisation(wx.Frame):
                 compareFileName = self.optiParam.myparams["Semi-Distributed"]["File reference "+str(iRef)]["value"]
                 readDict[stationOut] = compareFileName
             self.compareFilesDict = readDict
+            # Get the initial number of intervals 
+            # -> these can evolve according to the measurement available at each station
+            # FIXME : finish to generalise this part
+            nb_comparisons = self.comparHowParam.get_param("Comparison global characteristics","nb")
+            nb_intervals_init = [self.comparHowParam.get_param(" ".join(["Comparison",str(i)]),"nb intervals") for i in range(1,nb_comparisons+1)]
+            # Get the number of attempts with random initial conditions and from the best parameters for each station
+            # The total number of iterations per station is the product of these two numbers :
+            # nb_iter total = nb_iter_from_random * nb_iter_from_best
+            nb_iter_from_random = self.optiParam.get_param("Optimizer","nb iter from random initial conditions",default_value=1)
+            nb_iter_from_best = self.optiParam.get_param("Optimizer","nb iter from best",default_value=1)
+            # Check the initial parameters and if they are forced 
+            init_params = self.get_initial_parameters()
             # Sort all the junctions by level
             sortJct = curCatch.sort_level_given_junctions(list(readDict.keys()), changeNames=False)
             self.myStations = sortJct
@@ -1206,6 +1261,8 @@ 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
+                # self.select_opti_intervals(stationOut)
                 # Rename the result file
                 self.optiParam.change_param("Optimizer", "fname", stationOut)
                 self.optiParam.SavetoFile(None)
@@ -1213,13 +1270,46 @@ class Optimisation(wx.Frame):
                 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)
-                # Compute
-                self.init_optimizer(idOpti)
-                self.associate_ptr(None, idOpti=idOpti)
-                self.compute_optimizer(idOpti)
-                self.apply_optim(None)
+                ## loop on the number of different optimisation attempt we would like for each station
+                best_params_overall = None
+                cur_i = 0
+                i_best_overal = 0
+                for i_rand in range(nb_iter_from_random):
+                    best_params = init_params
+                    for i_best in range(nb_iter_from_best):
+                        # Prepare I.C. starting from best configuration
+                        self.prepare_init_params_from_best(best_params=best_params, idLauncher=idLauncher)
+                        # Reload the useful modules
+                        self.reload_hydro(idCompar=0, fromStation=stationOut, lastLevel=previousLevel, updateAll=True)
+                        # Compute
+                        self.init_optimizer(idOpti)
+                        self.associate_ptr(None, idOpti=idOpti)
+                        self.compute_optimizer(idOpti)
+                        # Collect the best parameters and their objective function(s)
+                        test_params = self.apply_optim(None, replace_only_if_better=(i_best!=0)) # Always apply the best parameters for the first iteration
+                        # If test_params are not the best or 1st test => We don't save them
+                        if test_params is not None:
+                            best_params = test_params
+                            if best_params_overall is None:
+                                best_params_overall = best_params
+                            elif best_params[-1] > best_params_overall[-1]:
+                                best_params_overall = best_params 
+                                i_best_overal = cur_i                  
+                        # 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"))
+                        cur_i += 1
+                # Apply the best parameters overall attemps
+                self.apply_optim(None,optim_params=best_params_overall)
+                # 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"))
+                
+                
                 # Simulation with the best parameters
                 self.compute_distributed_hydro_model()
                 # Update myHydro of all effective subbasins to get the best configuration upstream
@@ -1245,7 +1335,7 @@ class Optimisation(wx.Frame):
         # Will update all the normal parameters
         for element in self.myParams:
             junctionName = self.myParams[element]["junction_name"]
-            paramValue = self.curParams_vec[element-1]
+            paramValue = self.curParams_vec_F[element-1]
             if paramValue != self.myParams[element]["value"]:
                 self.myParams[element]["value"] = paramValue
                 isOk = self.myParams[element]["update"](junctionName, value=paramValue)
@@ -1263,7 +1353,7 @@ 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)
+        print("curParam = ", self.curParams_vec_F)
         print("All timeDelays = ", self.myCases[0].refCatchment.get_all_timeDelay())
         tf = time_mod.process_time()
         print("Time in update_hydro() : ", tf-t0)
@@ -1290,7 +1380,7 @@ class Optimisation(wx.Frame):
     def update_timeDelay(self, index):
 
         isOk = 0.0
-        newTimeDelay = self.curParams_vec[index-1]
+        newTimeDelay = self.curParams_vec_F[index-1]
         if(self.myParamsPy[index]["value"]!=newTimeDelay):
             junctionName = self.myParamsPy[index]["junction_name"]
             self.myParamsPy[index]["value"] = newTimeDelay
@@ -1535,7 +1625,7 @@ class Optimisation(wx.Frame):
 
         wx.Exit()
         
-
+    
     def get_all_outlets(self, event, idLauncher:int=0):
         # this function will save all the hydrographs with the optimal parameters
         
@@ -1720,9 +1810,9 @@ class Optimisation(wx.Frame):
 
         myModelDict = cste.modelParamsDict[myModel]["Parameters"]
 
-        if self.curParams_vec is None \
-           or len(self.curParams_vec) != self.nbParams:
-            self.curParams_vec = np.empty((self.nbParams,), dtype=ct.c_double, order='F')
+        if self.curParams_vec_F is None \
+           or len(self.curParams_vec_F) != self.nbParams:
+            self.curParams_vec_F = np.empty((self.nbParams,), dtype=ct.c_double, order='F')
 
         for i in range(self.nbParams):
             myType = self.myParams[i+1]["type"]
@@ -1742,7 +1832,7 @@ class Optimisation(wx.Frame):
                 tmpWolf = None
             else:
                 
-                self.curParams_vec[i] = params[i]
+                self.curParams_vec_F[i] = params[i]
                 self.update_timeDelay(i+1)
                 refCatch.save_timeDelays([self.myParams[i+1]["junction_name"]])
                 print("TO DO : Complete the python parameter dict!!!!!!!")
@@ -1768,31 +1858,96 @@ class Optimisation(wx.Frame):
             refCatch.update_hydro(idCompar=0)
 
 
-    def remove_py_params(self, idLauncher:int=0):
-        cur_opti = self.myCases[idLauncher]
-        paramDict = cur_opti.launcherParam
-        nb_params = int(paramDict.get_param("Paramètres à varier", "Nombre de paramètres à varier"))
 
-        myModel = self.myCases[idLauncher].refCatchment.myModel
-        nbParamsModel = cste.modelParamsDict[myModel]["Nb"]
-        
-        for i in range(1,nb_params+1):
-            curParam = "param_" + str(i)
-            curType = int(paramDict.get_param(curParam, "type_of_data"))
-            if curType < 0:
-                del paramDict.myparams[curParam]
-                nb_params -= 1
-
-        # Test
-        if nb_params >  nbParamsModel:
-            logging.error("The number of to optimise are greater than the number of max parameter of the model!! ")
-            return
+    def remove_py_params(self, idLauncher:int=0):
+            """
+            Removes the Python parameters from the optimization configuration.
+
+            Args:
+                idLauncher (int, optional): The ID of the launcher. Defaults to 0.
+            """
+            cur_opti = self.myCases[idLauncher]
+            paramDict = cur_opti.launcherParam
+            nb_params = int(paramDict.get_param("Paramètres à varier", "Nombre de paramètres à varier"))
+
+            myModel = self.myCases[idLauncher].refCatchment.myModel
+            nbParamsModel = cste.modelParamsDict[myModel]["Nb"]
+            
+            for i in range(1,nb_params+1):
+                curParam = "param_" + str(i)
+                curType = int(paramDict.get_param(curParam, "type_of_data"))
+                if curType < 0:
+                    del paramDict.myparams[curParam]
+                    nb_params -= 1
+
+            # Test
+            if nb_params >  nbParamsModel:
+                logging.error("The number of to optimise are greater than the number of max parameter of the model!! ")
+                return
 
-        self.myCases[idLauncher].launcherParam.change_param("Paramètres à varier", "Nombre de paramètres à varier", nb_params)
+            self.myCases[idLauncher].launcherParam.change_param("Paramètres à varier", "Nombre de paramètres à varier", nb_params)
 
-        return
+            return
+    
     
+    def select_opti_intervals(self, idLauncher:int=0, stationOut=""):
+        cur_opti = self.myCases[idLauncher]
+        cur_ref = cur_opti.refCatchment
+        if stationOut == "":
+            stationOut = cur_ref.junctionOut
+        file_compare = os.path.join(self.workingDir,"compare.txt")
+        isOk, file_compare = check_path(file_compare)
+        if isOk<0:
+            logging.error("The file compare.txt is not found!")
+            return 
+        meas_hydro = SubBasin()
+
+        nb_comparison = self.comparHowParam.get_param("Comparison global characteristics", "nb")
+        str_di = "date begin"
+        str_df = "date end"
+        for icomp in range(1, nb_comparison):
+            cur_key = " ".join("Comparison", str(icomp))
+            nb_intervals = self.comparHowParam.get_param(cur_key, "nb_intervals")
+            for i_inter in range(1,nb_intervals):
+                str_read = self.comparHowParam.get_param(" ".join(str_di,str(i_inter)))
+                di = datetime.datetime.timestamp(
+                    datetime.datetime.strptime(str_read, cst.DATE_FORMAT_HYDRO).replace(tzinfo=datetime.timezone.utc))
+                str_read = self.comparHowParam.get_param(" ".join(str_df,str(i_inter)))
+                df = datetime.datetime.timestamp(
+                    datetime.datetime.strptime(str_read, cst.DATE_FORMAT_HYDRO).replace(tzinfo=datetime.timezone.utc))
+                # Check that di is a timestamp lower than other date 
+
+
+    def prepare_init_params_from_best(self, best_params:np.array, idLauncher:int=0):
+        # If there are no best params the initial values will be random
+        if best_params is None:
+            # Force the initial parameters to be defined randomly
+            self.saParam.change_param("Initial parameters", "Read initial parameters?", 0)
+            return
+        
+        # In the following code, we apply the best parameters to the initial parameters
+        self.saParam.change_param("Initial parameters", "Read initial parameters?", 1)
+        for i in range(self.nbParams):
+            self.saParam.change_param("Initial parameters", " ".join(["Parameter",str(i+1)]), best_params[i])
+        
+        self.saParam.SavetoFile(None)
+        self.saParam.Reload(None)
 
+    
+    def get_initial_parameters(self)-> np.array:
+        read_IP = self.saParam.get_param("Initial parameters", "Read initial parameters?")
+        if read_IP == 1:
+            # FIXME : Generalise for more than 1 objctive function
+            init_params = np.zeros(self.nbParams+1)
+            for i in range(self.nbParams):
+                init_params[i] = self.saParam.get_param("Initial parameters", " ".join(["Parameter",str(i+1)]))
+            init_params[-1] = -sys.float_info.max              
+        else:
+            init_params = None
+        
+        return init_params
+        
+                
     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
 
@@ -1809,5 +1964,3 @@ class Optimisation(wx.Frame):
             return arr.copy()
         else:
             return arr
-
-            

wolfhece/hydrology/PostProcessHydrology.py

@@ -56,51 +56,51 @@ class PostProcessHydrology(wx.Frame):
             # Reading of the input file 'Input.compar'
             paramsCompar = Wolf_Param(to_read=False,toShow=False)
             paramsCompar.ReadFile(self.filename)
-            nbCatchment = int(paramsCompar.myparams['Main information']['nb catchment']['value'])
+            nbCatchment = int(paramsCompar.myparams['Main information']['nb catchment'][key_Param.VALUE])
 
             beginElement = 'Catchment '
             for i in range(1,nbCatchment+1):
                 element = beginElement + str(i)
                 self.myCatchments[element]={}
-                self.myCatchments[element]['Title'] = paramsCompar.myparams[element]['name']['value']
-                # Just check and correct the name of the filePath the way 
-                paramsCompar.myparams[element]['filePath']['value'] = paramsCompar.myparams[element]['filePath']['value'].replace("\\", "/")
-                if not(paramsCompar.myparams[element]['filePath']['value'].endswith('/')):
-                    paramsCompar.myparams[element]['filePath']['value'] = paramsCompar.myparams[element]['filePath']['value'] + '/'
-                dirName = paramsCompar.myparams[element]['filePath']['value']
+                self.myCatchments[element]['Title'] = paramsCompar.myparams[element]['name'][key_Param.VALUE]
+                # Just check and correct the name of the filePath the way
+                paramsCompar.myparams[element]['filePath'][key_Param.VALUE] = paramsCompar.myparams[element]['filePath'][key_Param.VALUE].replace("\\", "/")
+                if not(paramsCompar.myparams[element]['filePath'][key_Param.VALUE].endswith('/')):
+                    paramsCompar.myparams[element]['filePath'][key_Param.VALUE] = paramsCompar.myparams[element]['filePath'][key_Param.VALUE] + '/'
+                dirName = paramsCompar.myparams[element]['filePath'][key_Param.VALUE]
                 # Read the name of the input file
                 try:
-                    self.fileName = paramsCompar.myparams[element]['fileName']['value']
+                    self.fileName = paramsCompar.myparams[element]['fileName'][key_Param.VALUE]
                 except:
                     self.fileName = "Input.postPro"
 
                 paramsCatchment = Wolf_Param(to_read=False, toShow=False)
                 paramsCatchment.ReadFile(dirName+self.fileName)
-                nameCatchment = paramsCatchment.myparams['Main information']['Name']['value']
+                nameCatchment = paramsCatchment.myparams['Main information']['Name'][key_Param.VALUE]
 
-                paramsCatchment.myparams['Main information']['directoryPath']['value'] = paramsCatchment.myparams['Main information']['directoryPath']['value'].replace("\\", "/")
-                if not(paramsCatchment.myparams['Main information']['directoryPath']['value'].endswith('/')):
-                    paramsCatchment.myparams['Main information']['directoryPath']['value'] = paramsCatchment.myparams['Main information']['directoryPath']['value'] + '/'
-                dirCatchment = paramsCatchment.myparams['Main information']['directoryPath']['value']
+                paramsCatchment.myparams['Main information']['directoryPath'][key_Param.VALUE] = paramsCatchment.myparams['Main information']['directoryPath'][key_Param.VALUE].replace("\\", "/")
+                if not(paramsCatchment.myparams['Main information']['directoryPath'][key_Param.VALUE].endswith('/')):
+                    paramsCatchment.myparams['Main information']['directoryPath'][key_Param.VALUE] = paramsCatchment.myparams['Main information']['directoryPath'][key_Param.VALUE] + '/'
+                dirCatchment = paramsCatchment.myparams['Main information']['directoryPath'][key_Param.VALUE]
 
                 isOk, dirCatchment = check_path(dirCatchment, prefix=self.directoryPath,applyCWD=True)
                 if isOk<0:
                     print("ERROR : Problem in directory path!")
 
                 try:
-                    catchmentFileName = paramsCatchment.myparams['Main information']['Catchment file name']['value']
+                    catchmentFileName = paramsCatchment.myparams['Main information']['Catchment file name'][key_Param.VALUE]
                 except:
                     catchmentFileName = ""
                 try:
-                    rbFileName = paramsCatchment.myparams['Main information']['RB file name']['value']
+                    rbFileName = paramsCatchment.myparams['Main information']['RB file name'][key_Param.VALUE]
                 except:
                     rbFileName = ""
                 try:
-                    tz = int(paramsCatchment.myparams['Main information']['time zone']['value'])
+                    tz = int(paramsCatchment.myparams['Main information']['time zone'][key_Param.VALUE])
                 except:
                     tz = 0
 
-                if(int(paramsCatchment.myparams['Plot information']['plot all subbasin']['value']) == 1):
+                if(int(paramsCatchment.myparams['Plot information']['plot all subbasin'][key_Param.VALUE]) == 1):
                     plotAllHydro = True
                 else:
                     plotAllHydro = False
@@ -109,7 +109,7 @@ class PostProcessHydrology(wx.Frame):
                 else:
                     isCompared = True
                 self.myCatchments[element]['Object'] = Catchment(nameCatchment, dirCatchment, plotAllHydro, isCompared, _catchmentFileName=catchmentFileName, _rbFileName=rbFileName, _tz=tz)
-            if(nbCatchment>0):        
+            if(nbCatchment>0):
                 dictToCompare = paramsCompar.myparams['Plots']
                 self.myComparison = Comparison(self.directoryPath, self.myCatchments, dictToCompare)
                 self.myComparison.compare_now()
@@ -119,17 +119,17 @@ class PostProcessHydrology(wx.Frame):
             self.myCatchments['Catchment 1']['Title']=''
             paramsCatchment = Wolf_Param(to_read=False, toShow=False)
             paramsCatchment.ReadFile(self.filename)
-            nameCatchment = paramsCatchment.myparams['Main information']['Name']['value']
-            if(int(paramsCatchment.myparams['Plot information']['plot all subbasin']['value']) == 1):
+            nameCatchment = paramsCatchment.myparams['Main information']['Name'][key_Param.VALUE]
+            if(int(paramsCatchment.myparams['Plot information']['plot all subbasin'][key_Param.VALUE]) == 1):
                 plotAllHydro = True
             else:
                 plotAllHydro = False
             isCompared = False
             try:
-                tz = int(paramsCatchment.myparams['Main information']['time zone']['value'])
+                tz = int(paramsCatchment.myparams['Main information']['time zone'][key_Param.VALUE])
             except:
                 tz = 0
-            
+
             self.myCatchments['Catchment 1']['Object'] = Catchment(nameCatchment, self.directoryPath, plotAllHydro, _plotNothing=False, _tz=tz)
 
         else:

wolfhece/hydrology/SubBasin.py

@@ -2125,8 +2125,8 @@ class SubBasin:
         paramFile = Wolf_Param(to_read=False,toShow=False)
         paramFile.ReadFile(path +'simul_flood.out.param')
 
-        nbFloods = int(paramFile.myparams['Floods characteristics']['nb']['value'])
-        dt = float(paramFile.myparams['Floods characteristics']['dt']['value'])
+        nbFloods = int(paramFile.myparams['Floods characteristics']['nb'][key_Param.VALUE])
+        dt = float(paramFile.myparams['Floods characteristics']['dt'][key_Param.VALUE])
 
         filePre = "simul_flood"
         floodData = []
@@ -2964,38 +2964,38 @@ class SubBasin:
             logging.error("=================")
 
         return gOutFlow
-    
+
 
     @property
     def cumul_rain(self) -> np.array:
         return np.cumsum(self.myRain)
-    
+
 
 
     def evaluate_Nash(self, measure,
                       intervals:list[tuple[datetime.datetime]]=[]) -> list[float]:
         ns = []
-        
+
         if intervals == []:
-            ns.append( datt.evaluate_Nash(self.outFlow, self.time, 
-                                         measures=measure.get_myHydro(), tMeasures=measure.time, 
+            ns.append( datt.evaluate_Nash(self.outFlow, self.time,
+                                         measures=measure.get_myHydro(), tMeasures=measure.time,
                                          dateBegin=self.dateBegin, dateEnd=self.dateEnd) )
             return tuple(ns)
-        
+
         # for el in intervals:
-        #     ns.append( datt.evaluate_Nash(self.outFlow, self.time, 
-        #                                  measures=measure.get_myHydro(), tMeasures=measure.time, 
+        #     ns.append( datt.evaluate_Nash(self.outFlow, self.time,
+        #                                  measures=measure.get_myHydro(), tMeasures=measure.time,
         #                                  dateBegin=el[0], dateEnd=el[1]) )
-        ns = [ datt.evaluate_Nash(self.outFlow, self.time, 
-                                  measures=measure.get_myHydro(), tMeasures=measure.time, 
+        ns = [ datt.evaluate_Nash(self.outFlow, self.time,
+                                  measures=measure.get_myHydro(), tMeasures=measure.time,
                                   dateBegin=el[0], dateEnd=el[1])
               for el in intervals ]
 
         return tuple(ns)
-    
+
 
     def get_peak(self, intervals:list[tuple[datetime.datetime]]=[]) -> list[float]:
-        
+
         peak_s = []
         for element in intervals:
             # We conisder the indice to form complete intervals
@@ -3004,11 +3004,11 @@ class SubBasin:
             # meas_i = math.floor((element[0]-measure.dateBegin).total_seconds/measure.deltaT)
             # meas_f = math.floor((element[1]-measure.dateBegin).total_seconds/measure.deltaT)
             if simul_i<0 or simul_f>len(self.time):
-                continue        
+                continue
             peak_s.append(self.outFlow[simul_i:simul_f+1].max())
-        
+
         return peak_s
-        
+
 
 
     # FIXME Finish the function below -> returning all possible or desired internal variables

wolfhece/hydrology/constant.py

@@ -34,6 +34,10 @@ DEFAULT_LANDUSE[5] = _("rivière")
 DEFAULT_LANDUSE[6] = _("plan d'eau")
 
 
+##
+DATE_FORMAT_HYDRO = '%Y-%m-%dT%H:%M:%S' 
+
+
 ## Version of the code
 VERSION_WOLFHYDRO_2023_0 = "2023.1"     # First version to include the versioning
 VERSION_WOLFHYDRO_2023_1 = "2023.1"     # First version to include the versioning

wolfhece/hydrology/cst_exchanges.py

@@ -36,7 +36,8 @@ exchange_parameters_Dist_Soil_TSPAN    = 113 #Paramètre modèle distribué Soil
 exchange_parameters_Dist_Horton_F0     = 114 #Paramètre modèle distribué Horton
 exchange_parameters_Dist_Horton_FC     = 115 #Paramètre modèle distribué Horton
 exchange_parameters_Dist_Horton_K      = 116 #Paramètre modèle distribué Horton
-exchange_parameters_Dist_kif           = 117 #Paramètre modèle distribué Horton
+exchange_parameters_Dist_kif           = 117 #Paramètre modèle distribué pour réservoir linéaire couche épidermique (if)
+exchange_parameters_Dist_qlif          = 118 #Paramètre modèle distribué pour réservoir linéaire couche épidermique (if)
 
 
 # Constants representing the exchanges - Python

wolfhece/mesh2d/wolf2dprev.py

@@ -1885,8 +1885,8 @@ class prev_parameters_simul:
 
     def getvaluesx(self, event):
         for curmodel in self.mysimuls.values():
-            if curmodel['checked']:
-                locmodel = curmodel['values']
+            if curmodel.checked:
+                locmodel = curmodel
 
                 curcol = 3
                 if locmodel is self.parent:
@@ -1917,8 +1917,8 @@ class prev_parameters_simul:
 
     def getvaluesy(self, event):
         for curmodel in self.mysimuls.values():
-            if curmodel['checked']:
-                locmodel = curmodel['values']
+            if curmodel.checked:
+                locmodel = curmodel
 
                 curcol = 3
                 if locmodel is self.parent: