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

wolfhece/hydrology/Optimisation.py

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

wolfhece/hydrology/SubBasin.py

@@ -34,6 +34,8 @@ from . import plot_hydrology as ph
 from . import data_treatment as datt
 from . import read as rd
 from . import constant as cst
+from . import Models_characteristics as mc
+from . import Internal_variables as iv
 
 from ..wolf_array import *
 from ..PyParams import*
@@ -3291,12 +3293,16 @@ class SubBasin:
         """
         This procedure is activating all internal variables of all the hydrological modules.
         """
-        if self.model == cst.tom_VHM:
-            self.activate_all_iv_VHM()
-        elif self.model == cst.tom_GR4:
-            self.activate_all_iv_GR4()
-        elif self.model == cst.tom_2layers_linIF:
-            self.activate_all_iv_2layers()
+        # if self.model == cst.tom_VHM:
+        #     self.activate_all_iv_VHM()
+        # elif self.model == cst.tom_GR4:
+        #     self.activate_all_iv_GR4()
+        # elif self.model == cst.tom_2layers_linIF:
+        #     self.activate_all_iv_2layers()
+        cur_dir = os.path.join(self.fileNameRead, "Subbasin_"+str(self.iDSorted))
+        
+        mc.MODELS_VAR[self.model].activate_all(directory=cur_dir, prefix_file='simul', type_of_var=iv.FINAL_OUT_VAR)
+        mc.MODELS_VAR[self.model].activate_all(directory=cur_dir, prefix_file='simul', type_of_var=iv.IV_VAR)
 
 
     def collect_x_VHM(self) -> dict[str,np.array]:
@@ -3559,29 +3565,8 @@ class SubBasin:
 
         if all_f == {}:
             all_f = self.collect_fractions()
-        
-        if interval is not None:
-            interv = np.zeros(len(self.time), dtype=bool)
-            for el in interval:
-                date_i = datetime.datetime.timestamp(el[0])
-                date_f = datetime.datetime.timestamp(el[1])
-                interv += (self.time>=date_i) & (self.time<=date_f)
-        else:
-            interv = np.ones(len(self.time), dtype=bool)
 
-        if summary == "mean":
-            return {key: np.nanmean(all_f[key], where=interv) for key in all_f}
-        elif summary == "median":
-            return {key: np.nanmedian(all_f[key][interv]) for key in all_f}
-        elif summary == "std":
-            return {key: np.nanstd(all_f[key][interv]) for key in all_f}
-        elif summary == "min":
-            return {key: np.nanmin(all_f[key], where=interv) for key in all_f}
-        elif summary == "max":
-            return {key: np.nanmax(all_f[key], where=interv, initial=0.0) for key in all_f}
-        else:
-            logging.error("The summary type is not recognised!")
-            return []
+        return self._operation_on_ts(all_f, operation=summary, interval=interval)
 
 
     def get_volume_fractions(self, all_f:dict={}, 
@@ -3717,7 +3702,80 @@ class SubBasin:
         unit='mm/h'
 
         return self.get_outFlow(unit=unit)
+    
+
+    def get_flow_fractions(self, all_f:dict={}, summary:str=None,
+                              interval:list[tuple[datetime.datetime, datetime.datetime]]=None) -> dict[str, np.ndarray|float]:
+        """
+        This procedure is returning a summary of the fractions of the current module.
+
+        Parameters:
+        - summary (str): The type of summary to return.
+        - interval (list[datetime.datetime], optional): The interval of time to consider. Default is None.
+
+        Returns:
+        - dict: A dictionary containing the summary of the fractions of the current module.
+        """
+
+        if all_f == {}:
+            cur_dir = os.path.join(self.fileNameRead, "Subbasin_"+str(self.iDSorted))
+            all_qin = mc.MODELS_VAR[self.model].get_all_iv_timeseries(directory=cur_dir,
+                                            prefix_file='simul', type_of_var=iv.FINAL_OUT_VAR)
+            all_f = mc.MODELS_VAR[self.model].get_all_iv_timeseries(directory=cur_dir,
+                                            prefix_file='simul', type_of_var=iv.DEFAULT_VAR)
+            all_f.update(all_qin)
+        
+        q_simul = self.get_outFlow(unit='mm/h')
+        all_r = {"%"+key: val/q_simul * 100.0 for key, val in all_f.items()}
+
+        return self._operation_on_ts(all_r, summary=summary, interval=interval)
+    
+
+    def get_iv(self, all_iv:dict={}, max_params:dict={}, summary:str=None,
+                interval:list[tuple[datetime.datetime, datetime.datetime]]=None) -> dict[str, np.array]:
+        """
+        This procedure is returning a summary of the fractions of the current module.
+
+        Parameters:
+        - summary (str): The type of summary to return.
+        - interval (list[datetime.datetime], optional): The interval of time to consider. Default is None.
+
+        Returns:
+        - dict: A dictionary containing the summary of the fractions of the current module.
+        """
+
+        if all_iv == {}:
+            cur_dir = os.path.join(self.fileNameRead, "Subbasin_"+str(self.iDSorted))
+            all_iv = mc.MODELS_VAR[self.model].get_all_iv_timeseries(directory=cur_dir,
+                                            prefix_file='simul', type_of_var=iv.IV_VAR)
+        if max_params != {}:
+            out_dict = {key: all_iv[key]/cur_max for key, cur_max in max_params.items()}
+        else:
+            out_dict = all_iv
         
+        return self._operation_on_ts(out_dict, summary=summary, interval=interval)
+
+
+    def get_iv_fractions_one_date(self, all_iv:dict={}, max_params:dict={}, eval_date:datetime.datetime=None) -> dict[str, np.array]:
+        """
+        This procedure is returning a summary of the fractions of the current module.
+
+        Parameters:
+        - summary (str): The type of summary to return.
+        - interval (list[datetime.datetime], optional): The interval of time to consider. Default is None.
+
+        Returns:
+        - dict: A dictionary containing the summary of the fractions of the current module.
+        """
+
+        all_iv = self.get_iv(all_iv=all_iv, max_params=max_params, summary=None)
+        t_eval = datetime.datetime.timestamp(eval_date)
+        eval_i = np.searchsorted(self.time, t_eval)
+        if self.time[eval_i] != t_eval:
+            logging.warning("The date is not in the time series!")
+            return {}
+
+        return {"% "+key: val[eval_i] for key, val in all_iv.items()}
     
 
     def import_from_pandas_Series(self, data:pd.Series, which="outFlow"):
@@ -3760,7 +3818,33 @@ class SubBasin:
         tserie = pd.Series(data, index=idx, copy=True, name=" ".join([self.name,which]))
 
         return tserie
+    
+
+    def _operation_on_ts(self, ts:dict[str, np.ndarray], summary:str=None, interval:list[tuple[datetime.datetime, datetime.datetime]]=None):
+        if interval is not None:
+            interv = np.zeros(len(self.time), dtype=bool)
+            for el in interval:
+                date_i = datetime.datetime.timestamp(el[0])
+                date_f = datetime.datetime.timestamp(el[1])
+                interv += (self.time>=date_i) & (self.time<=date_f)
+        else:
+            interv = np.ones(len(self.time), dtype=bool)
 
+        if summary is None:
+            return {key: ts[key][interv] for key in ts}
+        elif summary == "mean":
+            return {key: np.nanmean(ts[key], where=interv) for key in ts}
+        elif summary == "median":
+            return {key: np.nanmedian(ts[key][interv]) for key in ts}
+        elif summary == "std":
+            return {key: np.nanstd(ts[key][interv]) for key in ts}
+        elif summary == "min":
+            return {key: np.nanmin(ts[key], where=interv) for key in ts}
+        elif summary == "max":
+            return {key: np.nanmax(ts[key], where=interv, initial=0.0) for key in ts}
+        else:
+            logging.error("The summary type is not recognised!")
+            return {}
 
     # def plot_Nash_vs_Qexcess(self, figure:plt.axis=None, toShow:bool=False, writeFile:str=""):
 

wolfhece/hydrology/cst_exchanges.py

@@ -555,6 +555,7 @@ NAM["Parameters"][exchange_parameters_NAM_CK12]["File"] = ["simul_OF.param", "si
 NAM["Parameters"][exchange_parameters_NAM_CK12]["Group"] = ["Time Parameters", "NAM parameters"]
 NAM["Parameters"][exchange_parameters_NAM_CK12]["Key"] = ["Lagtime", "Lagtime"]
 NAM["Parameters"][exchange_parameters_NAM_CK12]["Unit"] = "[h]"
+NAM["Parameters"][exchange_parameters_NAM_CK12]["Convertion Factor"] = [1/3600.0, 1.0]    # [sec] -> [h]
 NAM["Parameters"][exchange_parameters_NAM_CK12]["Range"] = (10.0, 50.0)
 NAM["Parameters"][exchange_parameters_NAM_CAREA] = {}
 NAM["Parameters"][exchange_parameters_NAM_CAREA]["Name"] = "C_area"

wolfhece/pydike.py

@@ -63,7 +63,7 @@ class Dike(Triangulation,Zones):
         nb = int(self.trace.length3D/ds)
         nb2 = int(max(distup,distdown)/ds)
 
-        mytri = myzone.createmultibin(nb,nb2)
+        mytri = myzone.create_multibin(nb,nb2)
         self.tri = mytri.tri
         self.pts = mytri.pts
         self.nb_pts = mytri.nb_pts