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

wolfhece/PyDraw.py

@@ -191,7 +191,7 @@ class DragdropFileTarget(wx.FileDropTarget):
                     id = id + '_1'
 
                 try:
-                    newobj = Zones(filename=name)
+                    newobj = Zones(filename=name, parent=self.window)
                     self.window.add_object('vector', newobj = newobj, id  = id)
                 except:
                     logging.error(_('Error while loading vector : ') + name)
@@ -203,7 +203,7 @@ class DragdropFileTarget(wx.FileDropTarget):
                     id = id + '_1'
 
                 try:
-                    newobj = cloud_vertices(fname=name)
+                    newobj = cloud_vertices(fname=name, mapviewer=self.window)
                     self.window.add_object('cloud', newobj = newobj, id  = id)
                 except:
                     logging.error(_('Error while loading cloud : ') + name)
@@ -380,6 +380,12 @@ class WolfMapViewer(wx.Frame):
 
         self.filemenu.AppendSeparator()
 
+        # SIMULATION Hydrologique
+
+        hydrol = self.filemenu.Append(wx.ID_ANY, _('Open hydrological model'), _('Hydrological simulation'))
+
+        self.filemenu.AppendSeparator()
+
         # MULTIVIEWER
 
         compareitem = self.filemenu.Append(wx.ID_ANY, _('Set comparison'), _('Set comparison'))
@@ -665,6 +671,13 @@ class WolfMapViewer(wx.Frame):
         self._wxlogging = value
 
 
+    def open_hydrological_model(self):
+        """ Open a hydrological model """
+
+        from .PyGui import HydrologyModel
+
+        newview = HydrologyModel(splash = False)
+
     def create_2D_MB_model(self):
         """ Create a 2D model """
 
@@ -4731,6 +4744,10 @@ class WolfMapViewer(wx.Frame):
 
             self.create_2D_MB_model()
 
+        elif itemlabel == _('Open hydrological model'):
+
+            self.open_hydrological_model()
+
         elif itemlabel == _('Check headers'):
 
             self.check_2D_MB_headers()

wolfhece/PyGui.py

@@ -276,19 +276,32 @@ class HydrologyModel(GenMapManager):
                 ('_encode.sub','Coded index SubB [-]')]}
 
 
-            self.files_hydrology_vectors={'Characteristic_maps':[('.delimit.vec','Watershed')],
+            self.files_hydrology_vectors={'Characteristic_vectors':[('.delimit.vec','Watershed')],
                                         'Whole_basin':[('Rain_basin_geom.vec','Rain geom'),
                                                         ('Evap_basin_geom.vec','Evapotranspiration geom')]}
 
             for curfile in self.files_hydrology_array['Characteristic_maps']:
                 curext=curfile[0]
-                curidx=curfile[1]
+                curidx=curfile[1]                
                 self.mapviewer.add_object(which='array',filename=self.mydircharact+curext,id=curidx,ToCheck=False)
 
-            for curfile in self.files_hydrology_vectors['Characteristic_maps']:
+
+            for curfile in self.files_hydrology_vectors['Characteristic_vectors']:
                 curext=curfile[0]
                 curidx=curfile[1]
-                self.mapviewer.add_object(which='vector',filename=self.mydircharact+curext,id=curidx,ToCheck=False)
+
+                delimit = Zones(filename=self.mydircharact+curext, mapviewer=self.mapviewer, parent = self.mapviewer)
+
+                for idx, cur_zone in enumerate(delimit.myzones):
+                    cur_sub = self.mycatchment.get_subBasin(idx+1)
+                    cur_zone.myname = cur_sub.name
+                    cur_vect = cur_zone.myvectors[0]
+                    cur_vect.set_legend_to_centroid(cur_sub.name + ' - ' + str(cur_sub.iDSorted), visible=True)
+                    cur_vect.myprop.legendfontsize = 12
+                
+                delimit.reset_listogl()
+
+                self.mapviewer.add_object(which='vector',newobj = delimit, id=curidx, ToCheck=True)
 
             for curfile in self.files_hydrology_vectors['Whole_basin']:
                 curext=curfile[0]
@@ -297,7 +310,17 @@ class HydrologyModel(GenMapManager):
                     self.mapviewer.add_object(which='vector',filename=self.mydirwhole+curext,id=curidx,ToCheck=False)
 
             self.mapviewer.add_object(which='vector',newobj=self.myexchanges.mysegs,id='Forced exchanges',ToCheck=False)
+
+            zones_RT = self.mycatchment.get_retentionbasin_zones()
+            zones_RT.parent = self
+            self.mapviewer.add_object(which='vector',newobj=zones_RT,id='Anthropic links',ToCheck=False)
+
             self.mapviewer.add_object(which='cloud',newobj=self.mycatchment.subBasinCloud,id='Local outlets',ToCheck=False)
+            self.mapviewer.add_object(which='cloud',newobj=self.mycatchment.retentionBasinCloud,id='Anthropic inlets/outlets',ToCheck=False)
+
+            self.mycatchment.subBasinCloud.set_mapviewer(self.mapviewer)
+            self.mycatchment.retentionBasinCloud.set_mapviewer(self.mapviewer)
+
             self.mapviewer.add_object(which='cloud',newobj=self.myexchanges.mycloudup,id='Up nodes',ToCheck=False)
             self.mapviewer.add_object(which='cloud',newobj=self.myexchanges.myclouddown,id='Down nodes',ToCheck=False)
 

wolfhece/PyParams.py

@@ -1064,7 +1064,7 @@ class Wolf_Param(wx.Frame):
                         logging.debug("String type will be conserved! -- {}".format(value_param))
 
                 if type(value_param) != int:
-                    logging.warning("Parameters -- EnumProperty -- Value {} is not an integer".format(value_param))
+                    logging.warning("Parameters -- EnumProperty -- Value {} is not an integer in file : {}".format(value_param, self.filename))
                     logging.debug("EnumProperty value must be an integer")
 
                 page.Append(pg.EnumProperty(label= param_name, name= locname, labels= list_keys, values= list_values, value= int(value_param)))

wolfhece/PyVertexvectors.py

@@ -2523,7 +2523,12 @@ class zone:
 
         :param prep: True = préparation des listes OpenGL ; False = affichage direct
         """
+
         if prep:
+            if len(self.myvectors) == 0:
+                logging.warning(_('No vector in zone -- {}').format(self.myname))
+                return
+            
             try:
                 if self.idgllist==-99999:
                     self.idgllist = glGenLists(1)
@@ -2540,6 +2545,10 @@ class zone:
             except:
                 logging.error(_('OpenGL error in zone.plot'))
         else:
+            if len(self.myvectors) == 0:
+                logging.warning(_('No vector in zone -- {}').format(self.myname))
+                return
+
             if self.idgllist!=-99999:
                 glCallList(self.idgllist)
             else:
@@ -4811,6 +4820,10 @@ class Zones(wx.Frame, Element_To_Draw):
             return expended_items
 
         def restore_tree_state(tree:TreeListCtrl, expended_items):
+            
+            if len(expanded)==0:
+                # Nothing to do
+                return
 
             root = tree.GetRootItem()
 
@@ -5837,6 +5850,7 @@ class Zones(wx.Frame, Element_To_Draw):
 
         Pousse la même information dans l'objet parent s'il existe
         """
+        
         if self.wx_exists:
             self.active_zone = object
 

wolfhece/apps/version.py

@@ -5,7 +5,7 @@ class WolfVersion():
 
         self.major = 2
         self.minor = 1
-        self.patch = 13
+        self.patch = 14
 
     def __str__(self):
 

wolfhece/hydrology/Catchment.py

@@ -53,10 +53,9 @@ class Catchment:
     _version:float                                                          # version of the wolfHydro python code. Useful for identifying the file versions to read and how to interpret them
     charact_watrshd:Watershed                                               # Watershed object containing the most useful properties of the arrays in Characteristics maps
     subBasinCloud:cloud_vertices                                            # cloud of points containing the true coordinates (used in simulation) of all subbasin outlets
+    retentionBasinCloud:cloud_vertices                                      # cloud of points containing the true coordinates (used in simulation) of all retention basins
     iP_Cloud:cloud_vertices                                                 # cloud of points containing the given coordinates (given in param files) of all subbasin outlets
 
-    subBasinDict:dict[int:SubBasin]
-
     catchmentDict:dict[Union[str, int], Union[SubBasin, RetentionBasin]]    # dictionnary containing all the elements of the catchment
     subBasinDict:dict[int, SubBasin]                                        # dictionnary containing all the subbasins
 
@@ -85,6 +84,10 @@ class Catchment:
         self.subBasinCloud.myprop.color=getIfromRGB((255,131,250))
         self.subBasinCloud.myprop.filled=True
 
+        self.retentionBasinCloud=cloud_vertices()
+        self.retentionBasinCloud.myprop.color=getIfromRGB((0,131,255))
+        self.retentionBasinCloud.myprop.filled=True
+
         self.iP_Cloud=cloud_vertices()
         self.iP_Cloud.myprop.color=getIfromRGB((255,131,250))
         self.iP_Cloud.myprop.filled=True
@@ -221,6 +224,8 @@ class Catchment:
         # Iterate through the Input params dictionnary
         self.create_ObjectsInCatchment()
 
+        self.charact_watrshd.set_names_subbasins([(cur.iDSorted, cur.name) for cur in self.subBasinDict.values()])
+
         # self.add_hyetoToDict()
 
 
@@ -323,8 +328,27 @@ class Catchment:
         if(self.plotAllSub):
             self.plot_allSub()
 
+        # self.charact_watrshd.impose_sorted_index_subbasins([cur.iDSorted for cur in self.subBasinDict.values()])
 
+        self._fill_cloud_retentionbasin()
+
+    def get_subBasin(self, id_sorted_or_name:int | str) -> SubBasin:
+        """ 
+        This method returns the subbasin object associated with the sorted id or name given in argument.
+
+        The sorted id is the one given by the Fortran code.
+        """
 
+        if isinstance(id_sorted_or_name, str):
+            for cursub in self.subBasinDict.values():
+                if(cursub.name.lower() == id_sorted_or_name.lower()):
+                    return cursub
+
+        elif isinstance(id_sorted_or_name, int):
+            for cursub in self.subBasinDict.values():
+                if(cursub.iDSorted == id_sorted_or_name):
+                    return cursub
+        return None
 
 
     def get_time(self):
@@ -565,6 +589,7 @@ class Catchment:
                     self.junctionNamesDict[self.paramsTopology.myparams[element]["outlet "+str(iOutlet+1)][key_Param.VALUE]] = element
 
                 self.retentionBasinDict[element] = RetentionBasin(self.dateBegin, self.dateEnd, self.deltaT, self.time, idBasin, nameBasin, typeOfRB, self.paramsRB.myparams, _tz=self.tz, _outletNames=myOutletsNames, _workingDir=self.workingDir)
+
                 # Save the RB in the RB dictionnary into the global Catchment dictionnary
                 self.catchmentDict[element] = self.retentionBasinDict[element]
 
@@ -573,6 +598,25 @@ class Catchment:
                 print("ERROR: This type of junction is unknown. Please check the topo postprocess file")
                 sys.exit()
 
+    def _fill_cloud_retentionbasin(self):
+        """ This procedure fills the cloud of the retention basin with the vertices of the retention basin and its inlets. """
+
+        for curRT in self.retentionBasinDict.values():
+            curRT:RetentionBasin
+            self.retentionBasinCloud.add_vertex(wolfvertex(curRT.x,curRT.y))
+            inlet_coords = curRT.get_inletCoords()
+            for cur_inlet in inlet_coords:
+                self.retentionBasinCloud.add_vertex(wolfvertex(cur_inlet[0],cur_inlet[1]))
+
+    def get_retentionbasin_zones(self)-> Zones:
+        """ This method returns a Zones instance of the retention basins. """
+        
+        zones = Zones()
+        for curRB in self.retentionBasinDict.values():
+            curRB:RetentionBasin
+            zones.add_zone(curRB.get_zone(), forceparent=True)
+
+        return zones
 
 
     def link_objects(self):
@@ -1367,7 +1411,7 @@ class Catchment:
                 excelData[0].append(self.topologyDict[level][curBasin].x)
                 excelData[1].append(self.topologyDict[level][curBasin].y)
                 for curChar in self.topologyDict[level][curBasin].mainCharactDict:
-                    excelData[iChar].append(self.topologyDict[level][curBasin].mainCharactDict[curChar][key_Param.VALUE])
+                    excelData[iChar].append(self.topologyDict[level][curBasin].mainCharactDict[curChar]["value"])
                     iChar += 1
                 iBasin += 1
 
@@ -1803,6 +1847,46 @@ class Catchment:
                 # paramsInput.ApplytoMemory(None)
                 paramsInput.SavetoFile(None)
 
+    
+    def _correct_Umax_from_old_model(self, adapt_with_rain:bool=True):
+        fileName = "simul_soil.param"
+        which="Umax"
+
+        for iBasin in range(1,len(self.subBasinDict)+1):
+            myBasin = self.subBasinDict[iBasin]
+            dirID = myBasin.iDSorted
+
+            fileToModif = os.path.join(self.workingDir, "Subbasin_" + str(dirID), fileName)
+
+            paramsInput = Wolf_Param(to_read=False,toShow=False)
+            paramsInput.ReadFile(fileToModif)
+            
+            if adapt_with_rain:
+                myInterval = paramsInput.get_param("Distributed production model parameters", "Time span soil", default_value=0.0)
+                if myInterval==0.0:
+                    nbIntervals = len(myBasin.myRain)-1
+                else:
+                    nbIntervals = math.floor(myInterval/myBasin.deltaT)
+                kernel = np.ones(nbIntervals)
+                volRain = np.convolve(myBasin.myRain, kernel)*myBasin.deltaT/3600.0
+                maxRain = np.max(volRain)
+            else:
+                maxRain = paramsInput.get_param("Distributed production model parameters", "Umax")
+                if maxRain==0.0:
+                    logging.warning("The Umax is not adapted with the rain and its value is 0.0. It might be better to put 'adapt_with_rain' to True.")
+
+            k = paramsInput.get_param("Horton parameters", "k", default_value=0.0)
+            if k==0.0:
+                continue
+            
+            U_max = maxRain/k
+
+            paramsInput.change_param("Distributed production model parameters", which, U_max)
+            paramsInput.change_param("Horton parameters", "k", 0.0)
+
+            # paramsInput.ApplytoMemory(None)
+            paramsInput.SavetoFile(None)
+
 
 
     def plot_all_diff_cumulRain_with_lagtime(self, interval, lagTime, selection_by_iD=[], graph_title="", show=True, writeDir="", lawNetRain=0, netRainParams={}):

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!")