wolfhece 2.1.12__py3-none-any.whl → 2.1.14__py3-none-any.whl

wolfhece/hydrology/Comparison.py

@@ -581,7 +581,7 @@ class Comparison:
                             tmpHydro = cur_module.get_direct_insideRB_inlets(unit='m3/s')
 
                             y1.append(tmpHydro[:])
-                        elif(curCatch.myModel==cst.tom_2layers_linIF or curCatch.myModel==cst.tom_2layers_UH):
+                        else:
 
                             # tmp = curCatch.retentionBasinDict["J18"].directFluxInRB
                             # tmpHydro = np.zeros(len(tmp))
@@ -664,7 +664,7 @@ class Comparison:
                                 print("ERROR: the simulation time is not long enough for this subbasin to be taken into account")
                                 sys.exit()
                             y1.append(tmpHydro[:])
-                        elif(curCatch.myModel==cst.tom_2layers_linIF or curCatch.myModel==cst.tom_2layers_UH):
+                        else:
                             tmp = curCatch.retentionBasinDict["J16"].directFluxInRB
                             tmpHydro = np.zeros(len(tmp))
 
@@ -1588,7 +1588,7 @@ class Comparison:
         # The following lines is take the peak difference between simulation and measurements -> Display 0.0 if the measurement is 0.0
         isZero = np.array(meas_peak)==0
         notZero = np.array(meas_peak)!=0
-        peak_prop = {stationKey[i]: [ list( (np.array(meas_peak[i])-np.array(el))/(np.array(meas_peak[i])+isZero[i]) *notZero[i] ) 
+        peak_prop = {stationKey[i]: [ list( (np.array(el)-np.array(meas_peak[i]))/(np.array(meas_peak[i])+isZero[i]) *notZero[i] ) 
                         for el in all_peaks[i] ] 
                      for i in range(len(stationKey))
                     }
@@ -1640,13 +1640,52 @@ class Comparison:
         sorted_keys = list(all_data[0].keys())
 
         ## Str of dates
-        all_names = ["-".join([cdate[0].strftime("%d/%m/%Y"), cdate[1].strftime("%d/%m/%Y")]) for cdate in intervals]
+        all_names = ["\n - \n".join([cdate[0].strftime("%d/%m/%Y"), cdate[1].strftime("%d/%m/%Y")]) for cdate in intervals]
 
 
         ## Plot 
         nb_stations = len(stationKey)
         type_of_model = [self.myCatchments[el]["Title"] for el in self.myCatchments]
-        type_of_data = type_of_data = ["Nash", r"$  \frac{Q^{s}_{max}-Q^{m}_{max}}{Q^{m}_{max}} $ "]
-        
+        type_of_data = ["Nash", r"$  \frac{Q^{s}_{max}-Q^{m}_{max}}{Q^{m}_{max}} $ "]
+        type_of_data_names = ["Nash", "Exceedance"]
+
         ph.bar_Nash_n_other(all_data, all_colors, nb_x=len(intervals), nb_data=len(type_of_model), nb_lines=nb_stations, 
-                            y_titles=type_of_data, x_titles=all_names, nameModel=type_of_model, line_names=sorted_keys, toShow=True)
+                            y_titles=type_of_data, x_titles=all_names, nameModel=type_of_model, line_names=sorted_keys, toShow=False)
+        
+        # =========
+        # =========
+        # Plot tables - 2nd version with the table instead of bars
+        all_ns= {
+            cur_catch["Title"]: np.array([list(cur_catch["Object"].get_sub_Nash(measures[i], stationKey[i], intervals)) for i in range(len(stationKey))])
+            for cur_catch in self.myCatchments.values()
+        }
+
+        all_peaks = {cur_catch["Title"]: np.array([cur_catch["Object"].get_sub_peak(stationKey[i], intervals) for i in range(len(stationKey))])
+                     for cur_catch in self.myCatchments.values()
+        }
+        
+        print(all_peaks)
+
+        meas_peak = np.array([ measures[i].get_peak(intervals) 
+                     for i in range(len(stationKey)) ])
+        
+        # The following lines is take the peak difference between simulation and measurements -> Display 0.0 if the measurement is 0.0
+        isZero = (meas_peak==0)
+        notZero = (meas_peak!=0)
+        peak_prop = {
+            cur_model: (value-meas_peak)/(meas_peak+isZero) *notZero
+            for cur_model, value in all_peaks.items()
+        }
+
+        # Concatenate all data
+        all_data = [all_ns, peak_prop]
+        
+        for data, name_of_data in zip(all_data, type_of_data_names):
+            for cur_model, cur_data in data.items():
+                file_name = os.path.join(self.workingDir, name_of_data+"_"+cur_model)+".png"
+                # cur_title = cur_model + ": " + name_of_data
+                ph.table_Nash_n_other(cur_data, name_of_data, 
+                                    row_names=sorted_keys, column_names=all_names, 
+                                    writeFile=file_name, toShow=False)
+
+        plt.show()

wolfhece/hydrology/Optimisation.py

@@ -2499,7 +2499,7 @@ class Optimisation(wx.Frame):
         
     # FIXME : this function has been dashed off -> functionnal but not well written!!
     # TODO : to improve !!!!!!
-    def test_equifinality_with_Nash(self, event, idLauncher:int=0, idOpti:int=1, quantile_Nash:float=0.6, std_Nash:float=0.02, clustering_Nash:bool=True):
+    def test_equifinality_with_Nash(self, event, idLauncher:int=0, idOpti:int=1, quantile_Nash:float=0.01, std_Nash:float=0.3, clustering_Nash:bool=True):
         """
         Test the equifinality of the model.
 
@@ -2578,6 +2578,8 @@ class Optimisation(wx.Frame):
                 # Save all the variables/evaluations desired
                 frac_dict = self._get_cur_fractions(idLauncher=idLauncher, stationOut=stationOut, intervals=cur_intervals)
                 cur_all_frac = list(frac_dict.values())
+                frac_vol_dict = self._get_volume_fractions(idLauncher=idLauncher, stationOut=stationOut, intervals=cur_intervals)
+                qof_max = self._get_max_runoff(idLauncher=idLauncher, stationOut=stationOut, intervals=cur_intervals)
                 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
@@ -2585,13 +2587,18 @@ class Optimisation(wx.Frame):
                 all_timeDelays_str = {key : str(datetime.timedelta(seconds=all_timeDelays[key])) for key in all_timeDelays}
                 cur_timeDelays = list(all_timeDelays_str.values())
                 # Concatenate all the informations
-                cur_all_frac = list(cur_p) + cur_timeDelays + cur_all_frac + [p_excess, max_sim_obs, cur_obj]
+                cur_all_frac = list(cur_p) + cur_timeDelays + cur_all_frac + list(frac_vol_dict.values()) + [qof_max, p_excess, max_sim_obs, cur_obj]
                 all_frac.append(cur_all_frac)
 
             # Get param names
             names = self.get_param_names(idLauncher=idLauncher, stationOut=stationOut)
             # Save the evaluations
-            var_names = names + list(all_timeDelays_str.keys()) + list(frac_dict.keys()) + ["P. of exceedance", "Qmax_simul/Q_max_measure", "Nash"]
+            var_names = names \
+                        + list(all_timeDelays_str.keys()) \
+                        + list(frac_dict.keys()) \
+                        + list(frac_vol_dict.keys()) \
+                        + ["% max runoff", "P. of exceedance", "Qmax_simul/Q_max_measure", "Nash"]
+            
             cur_df = pd.DataFrame(all_frac, columns=var_names)
             # write first the tempory results for each station
             writer_stat = pd.ExcelWriter(os.path.join(self.workingDir, stationOut+"_tests.xlsx"), engine = 'xlsxwriter')
@@ -2741,11 +2748,39 @@ class Optimisation(wx.Frame):
         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_summary_fractions(summary="mean", interval=intervals)
 
         return cur_fracts
     
 
+    # TODO : to finish this function
+    def _get_volume_fractions(self, idLauncher:int=0, stationOut:str="", 
+                         intervals:list[tuple[datetime.datetime, datetime.datetime]]=[]) -> dict[list[str], list[float]]:
+        
+        curCatch:Catchment = self.myCases[idLauncher].refCatchment
+        cur_key = curCatch.get_key_catchmentDict(stationOut)
+        curBasin: SubBasin = curCatch.catchmentDict[cur_key]
+        if type(curBasin) != SubBasin:
+            logging.warning("The current module is not a SubBasin object!")
+            return None
+        cur_fracts = curBasin.get_volume_fractions(interval=intervals)
+        return cur_fracts
+
+    # FIXME :  to improve and generalise
+    def _get_max_runoff(self, idLauncher:int=0, stationOut:str="", 
+                         intervals:list[tuple[datetime.datetime, datetime.datetime]]=[]) -> dict[list[str], list[float]]:
+
+        curCatch:Catchment = self.myCases[idLauncher].refCatchment
+        cur_key = curCatch.get_key_catchmentDict(stationOut)
+        curBasin: SubBasin = curCatch.catchmentDict[cur_key]
+        cur_fracts = curBasin.get_summary_fractions(summary="max", interval=intervals)
+
+        return cur_fracts["% qof"]
+    
+
     def _get_ratio_max_sim_obs(self, idLauncher:int=0, stationOut:str="", 
                          intervals:list[tuple[datetime.datetime, datetime.datetime]]=[]) -> float:
         
@@ -2795,6 +2830,8 @@ class Optimisation(wx.Frame):
     def plot_equifinality(self, event, idLauncher:int=0):
 
         physical_properties = ["%qof", "%qif", "%qbf", "%loss"]
+        physical_properties_vol = ['% qof volume', '% qif volume', '% qbf volume', '% loss volume']
+        # physical_properties_vol = [el+" volume" for el in physical_properties]
         colors_properties = ["b", "g", "k", "orange"]
         y_label = "Nash"
 
@@ -2820,6 +2857,19 @@ class Optimisation(wx.Frame):
                 ax.set_title("Proportion of rain : "+stationOut)
                 ax.legend()
                 fig.savefig(os.path.join(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):
+                    cur_columns = [col for col in df.columns if cur_prop.replace(" ", "") in col.replace(" ", "")]
+                    if cur_columns != []:
+                        corr_prop = cur_columns[0]
+                        ax.scatter(df.loc[:,corr_prop], df.loc[:,y_label], s=0.5, c=cur_color, 
+                                   marker='o', label=cur_prop, alpha=0.4)
+                ax.set_xlabel("% of the rain volume [-]")
+                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"))
                 # Plot the Probability of exceedance
                 cur_color = colors_properties[0]
                 x_label = "P. of exceedance"
@@ -2841,7 +2891,16 @@ class Optimisation(wx.Frame):
                 ax.set_title("Peak analysis : "+stationOut)
                 ax.legend()
                 fig.savefig(os.path.join(self.workingDir, "Equifinality_peaks_ratio_"+stationOut+".png"))
-                
+                # Plot % of the max runoff
+                x_label = "% max runoff"
+                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("Max runoff [%] : "+stationOut)
+                ax.legend()
+                fig.savefig(os.path.join(self.workingDir, "Equifinality_max_runoff_"+stationOut+".png"))
             else:
                 logging.error("The file "+filename+" does not exist!")