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

wolfhece/hydrology/RetentionBasin.py

@@ -14,6 +14,7 @@ from .Outlet import *
 from .Dumping import *
 from ..PyTranslate import _
 from . import constant as cst
+from ..PyVertexvectors import getIfromRGB, getRGBfromI
 
 class RetentionBasin():
     ## @var outFlow
@@ -29,7 +30,7 @@ class RetentionBasin():
     intletsObj:dict
     directFluxObj:dict
 
-    def __init__(self, _dateBegin=None, _dateEnd=None, _deltaT:int=None, _time=None, _id='J1', _name='Default name', _type='', 
+    def __init__(self, _dateBegin=None, _dateEnd=None, _deltaT:int=None, _time=None, _id='J1', _name='Default name', _type='',
                  _dictRB={}, _directDictRB={}, _tz=0, _outletNames=[], withRBDict=True, _workingDir=""):
         print('Creation of a RetentionBasin!')
         self.iD = _id
@@ -47,11 +48,15 @@ class RetentionBasin():
         self.fileNameRead = _workingDir # //
         self.fileNameWrite = self.fileNameRead
         if(_time is None):
-            tzDelta = datetime.timedelta(hours=self.tz)
-            ti = datetime.datetime.timestamp(self.dateBegin-tzDelta)
-            tf = datetime.datetime.timestamp(self.dateEnd-tzDelta)
-            self.time = np.arange(ti,tf+self.deltaT,self.deltaT)
-
+            if(_dateBegin is None or _dateEnd is None or _deltaT is None):
+                self.time = None
+                self.filledVolume = None
+            else:
+                tzDelta = datetime.timedelta(hours=self.tz)
+                ti = datetime.datetime.timestamp(self.dateBegin-tzDelta)
+                tf = datetime.datetime.timestamp(self.dateEnd-tzDelta)
+                self.time = np.arange(ti,tf+self.deltaT,self.deltaT)
+                self.filledVolume = np.zeros(len(self.time), dtype=np.float64)
 
         self.x = 0.0
         self.y = 0.0
@@ -85,7 +90,6 @@ class RetentionBasin():
 
         self.rain = []
 
-        self.filledVolume = np.zeros(len(self.time), dtype=np.float64)
         self.qLim = None        # object to compute "l'ecretage"
 
         self.outletObj = None   # object to compute the outlet
@@ -107,13 +111,13 @@ class RetentionBasin():
             for element in _dictRB:
                 if(_dictRB[element]['from'][key_Param.VALUE] == self.iD):
                     if(tmpCounter>0):
-                        print("ERROR: the same RB associated to two different caracteristics. Please check the RetentionBasin.postPro file.")
-                        sys.exit()
+                        logging.error("ERROR: the same RB associated to two different caracteristics. Please check the RetentionBasin.postPro file.")
+                        raise ValueError("The same RB associated to two different caracteristics. Please check the RetentionBasin.postPro file.")
                     self.dictRB = _dictRB[element]
                     tmpCounter +=1
             if(tmpCounter == 0):
-                print("Error: no RB associated! Please check the RetentionBasin.postPro file.")
-                sys.exit()
+                logging.error("Error: no RB associated! Please check the RetentionBasin.postPro file.")
+                raise ValueError("No RB associated! Please check the RetentionBasin.postPro file.")
         elif(_directDictRB!={}):
             self.dictRB = _directDictRB
         elif(withRBDict):
@@ -127,7 +131,7 @@ class RetentionBasin():
                     self.dictRB['type'] = {}
                     self.dictRB['type'][key_Param.VALUE] = ""
                 elif(myAnswer=="N" or myAnswer=="n"):
-                    sys.exit()
+                    raise ValueError("No answer given!")
         else:
             self.dictRB['type'] = {}
             self.dictRB['type'][key_Param.VALUE] = ""
@@ -243,9 +247,9 @@ class RetentionBasin():
             if(name in self.downstreamObj):
                 self.downstreamObj[name] = toPoint
             else:
-                print("ERROR: this outlet name is not recognised!")
-                print("Name = ", name)
-                sys.exit()
+                logging.error("ERROR: this outlet name is not recognised!")
+                logging.error("Name = ", name)
+                raise ValueError("This outlet name is not recognised!")
 
         self._outFlow[name] = {}
         self._outFlow[name]["Net"] = []
@@ -353,6 +357,81 @@ class RetentionBasin():
         return self._outFlow
 
 
+    def compute_one_step_hydro(self, i, givenDirectFluxIn:float=None, givenInlet:float=None):
+        """ This function computes the raw and real hydrographs for one time step.
+
+            The volume filled and then the water height in the RB at time $t$ will be evaluated will depend of the flows
+            at time $t-1$ exept if the
+
+            Internal variables modified : self.inlets, self.inletsRaw,
+                                        self.directFluxInRB, self.directFluxInRB_Raw,
+                                        self._outFlowRaw, self._outFlow, self.filledVolume
+            CAUTION: - Discussion about the ceil or the floor for the timeDelay indice!!!
+                     - UPDATE 2023.1 now the outFlow are not delayed anymore !!!! -> IMPORTANT UPDATE
+        """
+        self.sum_one_step_directFluxInRB(i, givenDirectFluxIn)
+        self.sum_one_step_inlets(i, givenInlet)
+
+        mainNameOut = list(self._outFlow.items())[0][0]
+        # In the Raw hydrograph the first outlet is considered to be the main one. Therefore the exit where the flux would go if the structure were to present
+        self._outFlow[mainNameOut]["Raw"][i] = self.inletsRaw[i] + self.directFluxInRB_Raw[i]
+        for iOutFlow in range(1,len(list(self._outFlow.items()))):
+            nameOut = list(self._outFlow.items())[iOutFlow][0]
+            self._outFlow[nameOut]["Raw"][i] = 0.0
+
+        # Compute
+        h = self.volume_to_h(self.filledVolume[i])
+        # Qout = self.outletObj.compute(h,self.time[self.convert_index_global_to_local(i)])
+        Qout = self.outletObj.compute(h,self.time[i+1], index=i+1)
+        qLim = self.qLim.compute(h,self.time[i+1])
+        Qin = self.directFluxInRB[i-1]+max(self.inlets[i]-qLim,0.)
+        rhs = Qin - Qout
+        outFlowReservoir = Qout
+        # If the volume increase => the outflow is kept (Maybe to improve!! The height can go to the upper threshold)
+        if rhs>0:
+            self.filledVolume[i+1] = self.filledVolume[i] + rhs*(self.time[i+1]-self.time[i])
+        # If the volume is decreasing but is not enough to empty it at this time step
+        elif self.filledVolume[i]>abs(rhs*(self.time[i+1]-self.time[i])):
+            self.filledVolume[i+1] = self.filledVolume[i] + rhs*(self.time[i+1]-self.time[i])
+            # if(self.surface == 0.0):
+            #     h = 0.0
+            # else:
+            #     h = self.filledVolume[i]/self.surface
+            h = self.volume_to_h(self.filledVolume[i+1])
+            # All the values:
+                # -outlet,
+                # -ecretage,
+                # -volume,
+            # will be reevaluated. Because we can go to the lower threshold.
+            # Qout = self.outletObj.compute(h,self.time[self.convert_index_global_to_local(i)])
+            Qout = self.outletObj.compute(h,self.time[i+1], index=i+1)
+            qLim = self.qLim.compute(h,self.time[i+1])
+            rhs = self.directFluxInRB[i]+max(self.inlets[i]-qLim,0.)-Qout
+            outFlowReservoir = Qout
+            self.filledVolume[i+1] = self.filledVolume[i] + rhs*(self.time[i+1]-self.time[i])
+
+        else:
+            self.filledVolume[i+1] =0
+            outFlowReservoir = self.filledVolume[i]/((self.time[i+1]-self.time[i]))+self.directFluxInRB[i]+max(self.inlets[i]-qLim,0.)
+
+        if self.filledVolume[i+1]>self.volume:
+            outFlowReservoir += (self.filledVolume[i+1]-self.volume)/((self.time[i+1]-self.time[i]))
+            self.filledVolume[i+1] = self.volume
+
+        self._outFlow = self.compute_final(outFlowReservoir,min(self.inlets[i],qLim),i)
+
+
+    def init_all_inlets(self):
+        """ This function initializes the inlets and directFluxInRB of the RB
+            Internal variables modified: self.inlets, self.inletsRaw, self.directFluxInRB, self.directFluxInRB_Raw
+        """
+        self.inlets = np.zeros(len(self.time),dtype=ct.c_double, order='F')
+        self.inletsRaw = np.zeros(len(self.time),dtype=ct.c_double, order='F')
+
+        self.directFluxInRB = np.zeros(len(self.time),dtype=ct.c_double, order='F')
+        self.directFluxInRB_Raw = np.zeros(len(self.time),dtype=ct.c_double, order='F')
+
+
     def sum_inlets(self, givenInlet=[]):
         """ This procedure sum all the inlets of the RB
             Caution: inlets variable is different from directFluxIn !!
@@ -383,15 +462,15 @@ class RetentionBasin():
                     # Assumption the transfer time between the 2 RB is ambiguous
                     # Therefore, the transfer time is set to 0.0
                     deltaTr = 0.0
-                    
+
                 self.inlets += curObj.get_outFlow(typeOutFlow="Net", whichOutFlow=nameOutFlow, lag=deltaTr)
                 self.inletsRaw += curObj.get_outFlow(typeOutFlow="Raw", whichOutFlow=nameOutFlow, lag=deltaTr)
         elif(givenInlet != []):
             if(len(givenInlet)!=len(self.time)):
-                print("ERROR: the dimension of the time array and the given inlet are not the same!")
-                print("Length optained = ", len(givenInlet))
-                print("Length expected = ", len(self.time))
-                sys.exit()
+                logging.error("The dimension of the time array and the given inlet are not the same!")
+                logging.error(f"Length obtained = {len(givenInlet)}")
+                logging.error(f"Length expected = {len(self.time)}")
+                raise ValueError("The dimension of the time array and the given inlet are not the same!")
             self.inlets = givenInlet
             self.inletsRaw = givenInlet
         else:
@@ -469,10 +548,10 @@ class RetentionBasin():
         elif(givenDirectFluxIn != []):
             # FIXME The following line to potentially change !!!
             if(len(givenDirectFluxIn)!=len(self.time)):
-                print("ERROR: the dimension of the time array and the given inlet are not the same!")
-                print("Length optained = ", len(givenDirectFluxIn))
-                print("Length expected = ", len(self.time))
-                sys.exit()
+                logging.error("The dimension of the time array and the given inlet are not the same!")
+                logging.error("Length optained = ", len(givenDirectFluxIn))
+                logging.error("Length expected = ", len(self.time))
+                raise ValueError("The dimension of the time array and the given inlet are not the same!")
             self.directFluxInRB = givenDirectFluxIn
             self.directFluxInRB_Raw = givenDirectFluxIn
         else:
@@ -482,6 +561,78 @@ class RetentionBasin():
             self.directFluxInRB_Raw = np.zeros(len(self.time), dtype=ct.c_double, order='F')
 
 
+    def sum_one_step_inlets(self, i, givenInlet:float=None):
+        if self.intletsObj != {}:
+            nameOutFlow = list(self.intletsObj.items())[0][0]
+            curObj = self.intletsObj[nameOutFlow]
+            # Compute the transfer time between modules
+            if type(curObj) is SubBasin:
+                timeInlet = curObj.timeDelay
+                deltaTr = timeInlet - self.timeDelay
+            else:
+                # Assumption the transfer time between the 2 RB is ambiguous
+                # Therefore, the transfer time is set to 0.0
+                deltaTr = 0.0
+            self.inlets[i] = curObj.get_outFlow(typeOutFlow="Net", whichOutFlow=nameOutFlow, lag=deltaTr)[i]
+            self.inletsRaw[i] = curObj.get_outFlow(typeOutFlow="Raw", whichOutFlow=nameOutFlow, lag=deltaTr)[i]
+            for i in range(1,len(list(self.intletsObj.items()))):
+                nameOutFlow = list(self.intletsObj.items())[i][0]
+                curObj = self.intletsObj[nameOutFlow]
+                timeInlet = curObj.timeDelay
+                if type(curObj) is SubBasin:
+                    timeInlet = curObj.timeDelay
+                    deltaTr = timeInlet - self.timeDelay
+                else:
+                    # Assumption the transfer time between the 2 RB is ambiguous
+                    # Therefore, the transfer time is set to 0.0
+                    deltaTr = 0.0
+
+                self.inlets[i] += curObj.get_outFlow(typeOutFlow="Net", whichOutFlow=nameOutFlow, lag=deltaTr)[i]
+                self.inletsRaw[i] += curObj.get_outFlow(typeOutFlow="Raw", whichOutFlow=nameOutFlow, lag=deltaTr)[i]
+        elif(givenInlet is not None):
+            self.inlets[i] = givenInlet
+            self.inletsRaw[i] = givenInlet
+        else:
+            self.inlets[i] = 0.0
+            self.inletsRaw[i] = 0.0
+
+
+    def sum_one_step_directFluxInRB(self, i, givenDirectFluxIn:float=None):
+        """This procedure computes the flux going directly inside the RB
+
+            Internal variables modified: self.directFluxInRB, self.directFluxInRB_Raw
+        """
+        if(self.directFluxObj != {}):
+            nameOutFlow = list(self.directFluxObj.items())[0][0]
+            curObj = self.directFluxObj[nameOutFlow]
+            timeInlet = curObj.timeDelay
+            if type(curObj) is SubBasin:
+                timeInlet = curObj.timeDelay
+                deltaTr = timeInlet - self.timeDelay
+            else:
+                # Assumption the transfer time between the 2 RB is ambiguous
+                # Therefore, the transfer time is set to 0.0
+                deltaTr = 0.0
+            deltaTr = timeInlet - self.timeDelay
+            self.directFluxInRB[i] = curObj.get_outFlow(typeOutFlow="Net", whichOutFlow=nameOutFlow, lag=deltaTr)[i]
+            self.directFluxInRB_Raw[i] = curObj.get_outFlow(typeOutFlow="Raw", whichOutFlow=nameOutFlow, lag=deltaTr)[i]
+            for i in range(1,len(list(self.directFluxObj.items()))):
+                nameOutFlow = list(self.directFluxObj.items())[i][0]
+                curObj = self.directFluxObj[nameOutFlow]
+                timeInlet = curObj.timeDelay
+                if type(curObj) is SubBasin:
+                    timeInlet = curObj.timeDelay
+                    deltaTr = timeInlet - self.timeDelay
+                else:
+                    # Assumption the transfer time between the 2 RB is ambiguous
+                    # Therefore, the transfer time is set to 0.0
+                    deltaTr = 0.0
+
+                self.directFluxInRB[i] += curObj.get_outFlow(typeOutFlow="Net", whichOutFlow=nameOutFlow, lag=deltaTr)[i]
+                self.directFluxInRB_Raw[i] += curObj.get_outFlow(typeOutFlow="Raw", whichOutFlow=nameOutFlow, lag=deltaTr)[i]
+
+
+
     def plot(self, workingDir, plotRaw=True, axis="Hours",rangeData=[], deltaMajorTicks=24.0*3600.0, deltaMinorTicks=3600.0, tzPlot=0, unitReservoir="[m^3]"):
         """ This procedure plots:
         - the inlets: in color chosen randomly by matplotlib
@@ -782,8 +933,8 @@ class RetentionBasin():
         elif(myIndex<len(dataLoc)):
             dataLoc[:-myIndex] = dataGlob[myIndex:]
         else:
-            print("ERROR: the simulation time is not long enough for this subbasin to be taken into account")
-            sys.exit()
+            logging.error("ERROR: the simulation time is not long enough for this subbasin to be taken into account")
+            raise ValueError("The simulation time is not long enough for this subbasin to be taken into account")
 
         return dataLoc
 
@@ -817,8 +968,7 @@ class RetentionBasin():
             else:
                 result[myIndex:] = vector[:-myIndex]
         else:
-            print("ERROR: the simulation time is not long enough for this subbasin to be taken into account")
-            sys.exit()
+            raise ValueError("The simulation time is not long enough for this subbasin to be taken into account")
 
         return result
 
@@ -874,7 +1024,7 @@ class RetentionBasin():
         if unit=='mm/h':
             if self.surfaceDrainedHydro==0.0:
                 logging.error("ERROR: the surface drained = 0! Not possible to express the outFlow in mm/s!")
-                sys.exit()
+                raise ValueError("ERROR: the surface drained = 0! Not possible to express the outFlow in mm/s!")
             myOutFlow *= 3.6/self.surfaceDrainedHydro
 
 
@@ -1221,7 +1371,7 @@ class RetentionBasin():
         # Verification
         if(datetime.datetime.timestamp(prevDate)>datetime.datetime.timestamp(self.dateBegin)):
             logging.error("ERROR: the first hydro data element is posterior to dateBegin!")
-            sys.exit()
+            raise ValueError("ERROR: the first hydro data element is posterior to dateBegin!")
 
         if(nbCl==5):
             # Caution : the index of the loop start at 24 because the timestamp function
@@ -1270,15 +1420,15 @@ class RetentionBasin():
         # Add the last element in the time matrix as its size is 1 element bigger than outlet
         timeArray[-1] = timeArray[-2] + diffTimeInSeconds
         if(self.deltaT!=diffDate.seconds):
-            print("ERROR: The last timestep in hydro data does not coincide with the one expected!")
-            sys.exit()
+            logging.error("ERROR: The last timestep in hydro data does not coincide with the one expected!")
+            raise ValueError("ERROR: The last timestep in hydro data does not coincide with the one expected!")
         # Save time array if it does not exist yet
         # Otherwise, check the consistency of the array with the time array of the object
         if(self.time is None):
             self.time=timeArray
         elif(self.time.all()!=timeArray.all()):
-            print("ERROR: the dates read are not consitent with the dates already recored in this subbasin!")
-            sys.exit()
+            logging.error("ERROR: the dates read are not consitent with the dates already recored in this subbasin!")
+            raise ValueError("ERROR: the dates read are not consitent with the dates already recored in this subbasin!")
 
         volume = np.array([self.h_to_volume(i) for i in height])
 
@@ -1465,6 +1615,40 @@ class RetentionBasin():
 
         return allInlets
 
+    
+    def get_inletCoords(self):
+
+        allCoords = []
+
+        for element in self.intletsObj:
+            allCoords.append([self.intletsObj[element].x, self.intletsObj[element].y])
+
+        for element in self.directFluxObj:
+            allCoords.append([self.directFluxObj[element].x, self.directFluxObj[element].y])
+
+        return allCoords
+    
+    def get_zone(self) -> zone:
+        """ Return a zone instance to insert in viewer """
+
+        myzone = zone(name = self.name)
+
+        x,y = self.x, self.y
+
+        xy_inlets = self.get_inletCoords()  
+        names     = self.get_inletsName()
+        for xy, curname in zip(xy_inlets, names):
+            locx, locy = xy
+            newvec = vector(name = curname)
+            newvec.add_vertex(wolfvertex(locx,locy))
+            newvec.add_vertex(wolfvertex(x,y))
+
+            newvec.myprop.color = getIfromRGB([255,100,0])
+            newvec.myprop.width = 3
+
+            myzone.add_vector(newvec, forceparent=True)
+
+        return myzone
 
 
     def get_timeDelays(self, timeDelays={}):
@@ -1480,12 +1664,12 @@ class RetentionBasin():
 
     def get_timeDelays_inlets(self):
 
-    
+
         all_timeDelays = {el.timeDelay-self.timeDelay for el in self.intletsObj.values()}
         all_timeDelays.update({el.timeDelay-self.timeDelay for el in self.directFluxObj.values()})
 
         return all_timeDelays
-    
+
 
     ##  This procedure save in a "transfer.param" file the timeDelay of the SubBasin and all its upstream elements
     def save_timeDelays(self):
@@ -1511,7 +1695,7 @@ class RetentionBasin():
         return self.timeDelayObj.get_iDSorted()
 
 
-    def get_outFlow_names(self)->list:        
+    def get_outFlow_names(self)->list:
 
         return list(self._outFlow.keys())
 
@@ -1537,7 +1721,7 @@ class RetentionBasin():
     # @var update_upstream boolean that specify whether the upstream elements should also be updated
     # @var level_min integer that specify the potential level at which the update should be stopped.
     def update_hydro(self, update_upstream:bool=True, level_min:int=1):
-        
+
         # !!! (ALERT) : So far, we consider that a RB object will always need to update its upstream elements
         # TODO : a potiential future need will require only an optimisation of the RB and fixed upstream elements!
         # if update_upstream:
@@ -1618,11 +1802,11 @@ class RetentionBasin():
             self.filledVolume = volume[imin:imax+1]
 
         return
-    
+
 
     def evaluate_objective_function(self, unit="mm/h")->np.ndarray:
         # unit = "m3/s"
-            
+
         return self.get_direct_insideRB_inlets(unit=unit)
 
 
@@ -1684,4 +1868,25 @@ class RetentionBasin():
         else:
             print("WARNING: This type RB was not recognised! Please check the RetentionBasin.postPro file.")
 
-            
+
+    def init_time_simulation(self, dateBegin:datetime.datetime, dateEnd:datetime.datetime, deltaT:float, tz:int=0):
+
+            tzDelta = datetime.timedelta(hours=self.tz)
+            self.dateBegin = dateBegin
+            self.dateEnd = dateEnd
+            self.deltaT = deltaT
+            ti = datetime.datetime.timestamp(self.dateBegin-tzDelta)
+            tf = datetime.datetime.timestamp(self.dateEnd-tzDelta)
+            self.time = np.arange(ti,tf+self.deltaT,self.deltaT)
+
+            return self.time
+
+
+    def init_internal_variable(self):
+
+        for iOutFlow in range(len(list(self._outFlow.items()))):
+            nameOut = list(self._outFlow.items())[iOutFlow][0]
+            self._outFlow[nameOut]["Net"] = np.zeros(len(self.time), dtype=np.float64)
+            self._outFlow[nameOut]["Raw"] = np.zeros(len(self.time), dtype=np.float64)
+
+        self.filledVolume = np.zeros(len(self.time), dtype=np.float64)

wolfhece/hydrology/SubBasin.py

@@ -17,6 +17,7 @@ from matplotlib.font_manager import FontProperties
 from dbfread import DBF
 import ctypes as ct
 import pandas as pd
+from pathlib import Path
 
 from ..PyTranslate import _
 from . import plot_hydrology as ph
@@ -248,7 +249,7 @@ class SubBasin:
                 file_exists = os.path.exists(fileName)
                 if(not(file_exists)):
                     typeOfFileName = 'simul_net_trans_rain.txt'
-                    fileName = join(workingDir, subBasinName + typeOfFileName)
+                    fileName = os.path.join(workingDir,subBasinName, typeOfFileName)
                     file_exists = os.path.exists(fileName)
                     if(file_exists):
                         print("ERROR : the file simul_net_trans_rain.txt is not used yet in this version! Please check version of the code before 05/11/2021 !")
@@ -1422,17 +1423,17 @@ class SubBasin:
         """Add hyetographs to the subbasin
             TO DO: Adapt the code to find automatically the .dbf files. E.G. when data are read in NetCDF files.
         """
-        fileName = workingDir + 'Subbasin_'+str(self.iDSorted)+'/simul_rain_geom_126.vec.dbf'
-        fileName2 = workingDir + 'Subbasin_'+str(self.iDSorted)+'/simul_geom.vec.dbf'
+        fileName  = Path(workingDir) / ('Subbasin_'  +str(self.iDSorted)) / 'simul_rain_geom.vec.dbf'
+        fileName2 = Path(workingDir) / ('Subbasin_'  +str(self.iDSorted)) /'/simul_geom.vec.dbf'
 
-        if(os.path.exists(fileName)):
-            dbDict = self.read_dbfFile(fileName)
+        if(fileName.exists()):
+            dbDict = self.read_dbfFile(str(fileName))
             for i in range(len(dbDict.records)):
                 idHyeto = int(dbDict.records[i]['data'])
                 # idMyHyeto = hyetoDict['Ordered To Nb'][idHyeto]
                 self.myHyetoDict[idHyeto] = hyetoDict['Hyetos'][idHyeto]
-        elif(os.path.exists(fileName2)):
-            dbDict = self.read_dbfFile(fileName2)
+        elif(fileName2.exists()):
+            dbDict = self.read_dbfFile(str(fileName2))
             for i in range(len(dbDict.records)):
                 idHyeto = int(dbDict.records[i]['data'])
                 # idMyHyeto = hyetoDict['Ordered To Nb'][idHyeto]
@@ -3451,12 +3452,43 @@ class SubBasin:
         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) for key in all_f}
+            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 []
 
-    
+
+    def get_volume_fractions(self, all_f:dict={}, 
+                              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_f == {}:
+            all_f = self.collect_fractions()
+        
+        all_v = {key: val/100.0*self.myRain for key, val in all_f.items()}
+        
+        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)
+        
+        tot_rain = np.nansum(self.myRain[interv])*self.deltaT/3600
+
+        return {key+" volume": (np.nansum(all_v[key][interv])*self.deltaT/3600)/tot_rain*100 for key in all_v}
+        
 
     def check_presence_of_iv(self):
         """
@@ -3514,6 +3546,7 @@ class SubBasin:
 
         return q_test
     
+
     def plot_all_fractions(self, all_fractions:dict[str:np.array]={},figure=None, to_show:bool=False, writeDir:str="", range_data:list[datetime.datetime]=[]) -> None:
 
         if writeDir == "":

wolfhece/hydrology/plot_hydrology.py

@@ -824,4 +824,62 @@ def bar_Nash_n_other(all_data:list[dict], all_colors:list[dict], nb_x, nb_data,
     
 
     if toShow : 
+        plt.show()
+
+
+def table_Nash_n_other(data:np.ndarray, 
+                       type_of_data:str="Nash", color_map:str=None,
+                       row_names:list[str]=[], column_names:list[str]=[], title:str="",
+                       writeFile:str="", toShow:bool=False, nan_color:str="white", nan_value:float=0.0):
+    
+    if nan_value is not None:
+        data[data == nan_value] = np.nan
+
+    # Heat map definition
+    fig_tmp, ax_tmp = plt.subplots()
+    if type_of_data == "Nash":
+        heatmap = ax_tmp.imshow(data[:, 0:1], cmap='RdYlGn', aspect='auto', vmin=0, vmax=1)
+    if type_of_data == "Exceedance":
+        heatmap = ax_tmp.imshow(data[:, 1:2], cmap='bwr_r', aspect='auto', vmin=-1, vmax=1, origin='lower')
+    
+    heat_rgb = heatmap.to_rgba(data)
+    plt.close(fig_tmp)
+
+    vfunc = np.vectorize(lambda x: '' if np.isnan(x) else f'{x:.2f}')
+    ndata = vfunc(data)
+
+    # plot the table
+    fig, ax = plt.subplots()
+    table = ax.table(cellText=ndata, loc='center', 
+                    cellColours= heat_rgb,
+                    colLabels=column_names,
+                    rowLabels=row_names,
+                    cellLoc='center',
+                    rowLoc='center',
+                    colLoc='center')
+    
+    # Make the column fit with around their name
+    for i in range(len(row_names)):
+        table.auto_set_column_width(i)
+    # Change the text color based on the brightness of the cell color
+    for i, cell in table.get_celld().items():
+        cell.set_edgecolor('black')
+        if cell.get_facecolor()[0] < 0.5:  # if the cell color is dark
+            cell.get_text().set_color('white')
+        else:
+            cell.get_text().set_color('black')
+
+    table.scale(1.0, 3.0)
+    # table.auto
+
+    # Hide axes
+    ax.axis('off') 
+    # Set the title
+    if title != "":
+        ax.set_title(title)
+
+    if writeFile != "":
+        plt.savefig(writeFile, transparent=True, bbox_inches='tight')
+
+    if toShow:
         plt.show()