wolfhece 2.0.44__py3-none-any.whl → 2.0.46__py3-none-any.whl

wolfhece/hydrology/SubBasin.py

@@ -16,6 +16,7 @@ import datetime                         # module which contains objects treating
 from matplotlib.font_manager import FontProperties
 from dbfread import DBF
 import ctypes as ct
+import pandas as pd
 
 from ..PyTranslate import _
 from . import plot_hydrology as ph
@@ -116,8 +117,9 @@ class SubBasin:
     _version:float                  # version of the wolfHydro python code. Useful for identifying the file versions to read and how to interpret them
 
 
-    def __init__(self, _dateBegin, _dateEnd, _deltaT, _model,_workingDir, _hyeto={}, _x=0.0, _y=0.0,
-                 _iD_interiorPoint=1,_idSorted=1, name=None, readHydro=True, _tz=0, version=cst.VERSION_WOLFHYDRO):
+    def __init__(self, _dateBegin:datetime.datetime=None, _dateEnd:datetime.datetime=None, _deltaT:int=0, _model=cst.measures,_workingDir:str="", 
+                 _hyeto:dict={}, _x:float=0.0, _y:float=0.0, surfaceDrained:float=0.0,
+                 _iD_interiorPoint:int=1,_idSorted:int=1, name:str=None, readHydro=True, _tz:int=0, version:str=cst.VERSION_WOLFHYDRO):
         if(name is None):
             self.name = 'ss '+ str(_iD_interiorPoint)
         else:
@@ -189,8 +191,8 @@ class SubBasin:
         self.landuseHydroDict = {}                  # Dictionnary with all landuses of the hydro subbasin
 
         # Further information
-        self.surfaceDrained = 0.0                   # [km^2]
-        self.surfaceDrainedHydro = 0.0              # [km^2]
+        self.surfaceDrained = surfaceDrained        # [km^2]
+        self.surfaceDrainedHydro = surfaceDrained   # [km^2]
         self.timeDelay = 0.0                        # [s]
 
         self.peakVal = 0.0                          # [m³/s] peak value for total outFlow
@@ -279,8 +281,22 @@ class SubBasin:
             timeArray = np.zeros(len(matrixData))                 # +1 as the time array is not one element more than the outlet in UH
             outFlow = np.zeros(len(matrixData),dtype=ct.c_double, order='F')
 
+            # Init the time properties if not already done
+            if self.dateBegin is None or self.dateEnd is None or self.deltaT == 0:
+                self.dateBegin = datetime.datetime(year=int(matrixData[0][2]), month=int(matrixData[0][1]), day=int(matrixData[0][0]), 
+                                                    hour=int(matrixData[0][3]), minute=int(matrixData[0][4]), second=int(matrixData[0][5]),  
+                                                    microsecond=0, tzinfo=datetime.timezone.utc)
+                self.dateEnd = datetime.datetime(year=int(matrixData[-1][2]), month=int(matrixData[-1][1]), day=int(matrixData[-1][0]), 
+                                                    hour=int(matrixData[-1][3]), minute=int(matrixData[-1][4]), second=int(matrixData[-1][5]),  
+                                                    microsecond=0, tzinfo=datetime.timezone.utc)
+                self.deltaT = (datetime.datetime(year=int(matrixData[1][2]), month=int(matrixData[1][1]), day=int(matrixData[1][0]), 
+                                hour=int(matrixData[1][3]), minute=int(matrixData[1][4]), second=int(matrixData[1][5]),  
+                                microsecond=0, tzinfo=datetime.timezone.utc) - self.dateBegin).total_seconds()
+
             secondsInDay = 24*60*60
-            prevDate = datetime.datetime(year=int(matrixData[0][2]), month=int(matrixData[0][1]), day=int(matrixData[0][0]), hour=int(matrixData[0][3]), minute=int(matrixData[0][4]), second=int(matrixData[0][5]),  microsecond=0, tzinfo=datetime.timezone.utc)
+            prevDate = datetime.datetime(year=int(matrixData[0][2]), month=int(matrixData[0][1]), day=int(matrixData[0][0]), 
+                                         hour=int(matrixData[0][3]), minute=int(matrixData[0][4]), second=int(matrixData[0][5]),  
+                                         microsecond=0, tzinfo=datetime.timezone.utc)
             prevDate -= tzDelta
             if(self.dateBegin!=prevDate):
                 print("ERROR: The first date in hydro data does not coincide with the one expected!")
@@ -298,9 +314,13 @@ class SubBasin:
             nbData = len(matrixData)
 
             for i in range(1,nbData):
-                currDate = datetime.datetime(year=int(matrixData[i][2]), month=int(matrixData[i][1]), day=int(matrixData[i][0]), hour=int(matrixData[i][3]), minute=int(matrixData[i][4]), second=int(matrixData[i][5]),  microsecond=0, tzinfo=datetime.timezone.utc)
+                currDate = datetime.datetime(year=int(matrixData[i][2]), month=int(matrixData[i][1]), day=int(matrixData[i][0]), 
+                                             hour=int(matrixData[i][3]), minute=int(matrixData[i][4]), second=int(matrixData[i][5]),  
+                                             microsecond=0, tzinfo=datetime.timezone.utc)
                 currDate -= tzDelta
-                prevDate = datetime.datetime(year=int(matrixData[i-1][2]), month=int(matrixData[i-1][1]), day=int(matrixData[i-1][0]), hour=int(matrixData[i-1][3]), minute=int(matrixData[i-1][4]), second=int(matrixData[i-1][5]),  microsecond=0, tzinfo=datetime.timezone.utc)
+                prevDate = datetime.datetime(year=int(matrixData[i-1][2]), month=int(matrixData[i-1][1]), day=int(matrixData[i-1][0]), 
+                                             hour=int(matrixData[i-1][3]), minute=int(matrixData[i-1][4]), second=int(matrixData[i-1][5]),  
+                                             microsecond=0, tzinfo=datetime.timezone.utc)
                 prevDate -= tzDelta
                 diffDate = currDate - prevDate
                 diffTimeInSeconds = diffDate.days*secondsInDay + diffDate.seconds
@@ -339,6 +359,9 @@ class SubBasin:
                 print("ERROR: the dates read are not consitent with the dates already recored in this subbasin!")
                 sys.exit()
 
+            if self._version<2022.0:
+                outFlow[:] = outFlow[:]/self.surfaceDrained*3.6
+
         elif(self.model==cst.tom_2layers_linIF or self.model==cst.tom_2layers_UH):
             # For this model, there are 3 different layers to read.
 
@@ -394,6 +417,18 @@ class SubBasin:
             # Init of the outflow array
             outFlow = np.zeros((len(matrixData),2),dtype=ct.c_double, order='F')
 
+            # Init the time properties if not already done
+            if self.dateBegin is None or self.dateEnd is None or self.deltaT == 0:
+                self.dateBegin = datetime.datetime(year=int(matrixData[0][2]), month=int(matrixData[0][1]), day=int(matrixData[0][0]), 
+                                                    hour=int(matrixData[0][3]), minute=int(matrixData[0][4]), second=int(matrixData[0][5]),  
+                                                    microsecond=0, tzinfo=datetime.timezone.utc)
+                self.dateEnd = datetime.datetime(year=int(matrixData[-1][2]), month=int(matrixData[-1][1]), day=int(matrixData[-1][0]), 
+                                                    hour=int(matrixData[-1][3]), minute=int(matrixData[-1][4]), second=int(matrixData[-1][5]),  
+                                                    microsecond=0, tzinfo=datetime.timezone.utc)
+                self.deltaT = (datetime.datetime(year=int(matrixData[1][2]), month=int(matrixData[1][1]), day=int(matrixData[1][0]), 
+                                hour=int(matrixData[1][3]), minute=int(matrixData[1][4]), second=int(matrixData[1][5]),  
+                                microsecond=0, tzinfo=datetime.timezone.utc) - self.dateBegin).total_seconds()
+
             secondsInDay = 24*60*60
             prevDate = datetime.datetime(year=int(matrixData[0][2]), month=int(matrixData[0][1]), day=int(matrixData[0][0]), hour=int(matrixData[0][3]), minute=int(matrixData[0][4]), second=int(matrixData[0][5]),  microsecond=0, tzinfo=datetime.timezone.utc)
             prevDate -= tzDelta
@@ -410,9 +445,13 @@ class SubBasin:
                 outFlow[0][0] = matrixData[0][6]
             for i in range(1,len(matrixData)):
 
-                currDate = datetime.datetime(year=int(matrixData[i][2]), month=int(matrixData[i][1]), day=int(matrixData[i][0]), hour=int(matrixData[i][3]), minute=int(matrixData[i][4]), second=int(matrixData[i][5]),  microsecond=0, tzinfo=datetime.timezone.utc)
+                currDate = datetime.datetime(year=int(matrixData[i][2]), month=int(matrixData[i][1]), day=int(matrixData[i][0]), 
+                                             hour=int(matrixData[i][3]), minute=int(matrixData[i][4]), second=int(matrixData[i][5]),  
+                                             microsecond=0, tzinfo=datetime.timezone.utc)
                 currDate -= tzDelta
-                prevDate = datetime.datetime(year=int(matrixData[i-1][2]), month=int(matrixData[i-1][1]), day=int(matrixData[i-1][0]), hour=int(matrixData[i-1][3]), minute=int(matrixData[i-1][4]), second=int(matrixData[i-1][5]),  microsecond=0, tzinfo=datetime.timezone.utc)
+                prevDate = datetime.datetime(year=int(matrixData[i-1][2]), month=int(matrixData[i-1][1]), day=int(matrixData[i-1][0]), 
+                                             hour=int(matrixData[i-1][3]), minute=int(matrixData[i-1][4]), second=int(matrixData[i-1][5]),  
+                                             microsecond=0, tzinfo=datetime.timezone.utc)
                 prevDate -= tzDelta
                 diffDate = currDate - prevDate
                 diffTimeInSeconds = diffDate.days*secondsInDay + diffDate.seconds
@@ -511,7 +550,6 @@ class SubBasin:
                     for i in range(1,len(matrixData)):
                         outFlow[i][1] = matrixData[i][6]
 
-
         elif(self.model==cst.tom_VHM):
             # For this model, there are 3 different layers to read.
 
@@ -539,6 +577,19 @@ class SubBasin:
                     i += 1
             matrixData = np.array(list_data).astype("float")
             timeArray = np.zeros(len(matrixData))
+
+            # Init the time properties if not already done
+            if self.dateBegin is None or self.dateEnd is None or self.deltaT == 0:
+                self.dateBegin = datetime.datetime(year=int(matrixData[0][2]), month=int(matrixData[0][1]), day=int(matrixData[0][0]), 
+                                                    hour=int(matrixData[0][3]), minute=int(matrixData[0][4]), second=int(matrixData[0][5]),  
+                                                    microsecond=0, tzinfo=datetime.timezone.utc)
+                self.dateEnd = datetime.datetime(year=int(matrixData[-1][2]), month=int(matrixData[-1][1]), day=int(matrixData[-1][0]), 
+                                                    hour=int(matrixData[-1][3]), minute=int(matrixData[-1][4]), second=int(matrixData[-1][5]),  
+                                                    microsecond=0, tzinfo=datetime.timezone.utc)
+                self.deltaT = (datetime.datetime(year=int(matrixData[1][2]), month=int(matrixData[1][1]), day=int(matrixData[1][0]), 
+                                hour=int(matrixData[1][3]), minute=int(matrixData[1][4]), second=int(matrixData[1][5]),  
+                                microsecond=0, tzinfo=datetime.timezone.utc) - self.dateBegin).total_seconds()
+                
             # Init of the outflow array
             outFlow = np.zeros((len(matrixData),3),dtype=ct.c_double, order='F')
 
@@ -635,7 +686,6 @@ class SubBasin:
                 # outFlow[i][2] = matrixData[i][6]*self.surfaceDrained/3.6
                 outFlow[i][2] = matrixData[i][6]
 
-
         elif(self.model==cst.tom_GR4):
             # For this model, there is only 1 output to consider.
 
@@ -669,6 +719,18 @@ class SubBasin:
             # Init of the outflow array
             outFlow = np.zeros((len(matrixData),1),dtype=ct.c_double, order='F')
 
+            # Init the time properties if not already done
+            if self.dateBegin is None or self.dateEnd is None or self.deltaT == 0:
+                self.dateBegin = datetime.datetime(year=int(matrixData[0][2]), month=int(matrixData[0][1]), day=int(matrixData[0][0]), 
+                                                    hour=int(matrixData[0][3]), minute=int(matrixData[0][4]), second=int(matrixData[0][5]),  
+                                                    microsecond=0, tzinfo=datetime.timezone.utc)
+                self.dateEnd = datetime.datetime(year=int(matrixData[-1][2]), month=int(matrixData[-1][1]), day=int(matrixData[-1][0]), 
+                                                    hour=int(matrixData[-1][3]), minute=int(matrixData[-1][4]), second=int(matrixData[-1][5]),  
+                                                    microsecond=0, tzinfo=datetime.timezone.utc)
+                self.deltaT = (datetime.datetime(year=int(matrixData[1][2]), month=int(matrixData[1][1]), day=int(matrixData[1][0]), 
+                                hour=int(matrixData[1][3]), minute=int(matrixData[1][4]), second=int(matrixData[1][5]),  
+                                microsecond=0, tzinfo=datetime.timezone.utc) - self.dateBegin).total_seconds()
+
             secondsInDay = 24*60*60
             prevDate = datetime.datetime(year=int(matrixData[0][2]), month=int(matrixData[0][1]), day=int(matrixData[0][0]), hour=int(matrixData[0][3]), minute=int(matrixData[0][4]), second=int(matrixData[0][5]),  microsecond=0, tzinfo=datetime.timezone.utc)
             prevDate -= tzDelta
@@ -681,9 +743,13 @@ class SubBasin:
             # outFlow[0][0] = matrixData[0][6]*self.surfaceDrained/3.6
             outFlow[0][0] = matrixData[0][6]
             for i in range(1,len(matrixData)):
-                currDate = datetime.datetime(year=int(matrixData[i][2]), month=int(matrixData[i][1]), day=int(matrixData[i][0]), hour=int(matrixData[i][3]), minute=int(matrixData[i][4]), second=int(matrixData[i][5]),  microsecond=0, tzinfo=datetime.timezone.utc)
+                currDate = datetime.datetime(year=int(matrixData[i][2]), month=int(matrixData[i][1]), day=int(matrixData[i][0]), 
+                                             hour=int(matrixData[i][3]), minute=int(matrixData[i][4]), second=int(matrixData[i][5]),  
+                                             microsecond=0, tzinfo=datetime.timezone.utc)
                 currDate -= tzDelta
-                prevDate = datetime.datetime(year=int(matrixData[i-1][2]), month=int(matrixData[i-1][1]), day=int(matrixData[i-1][0]), hour=int(matrixData[i-1][3]), minute=int(matrixData[i-1][4]), second=int(matrixData[i-1][5]),  microsecond=0, tzinfo=datetime.timezone.utc)
+                prevDate = datetime.datetime(year=int(matrixData[i-1][2]), month=int(matrixData[i-1][1]), day=int(matrixData[i-1][0]), 
+                                             hour=int(matrixData[i-1][3]), minute=int(matrixData[i-1][4]), second=int(matrixData[i-1][5]),  
+                                             microsecond=0, tzinfo=datetime.timezone.utc)
                 prevDate -= tzDelta
                 diffDate = currDate - prevDate
                 diffTimeInSeconds = diffDate.days*secondsInDay + diffDate.seconds
@@ -716,7 +782,6 @@ class SubBasin:
                 print("ERROR: the dates read are not consitent with the dates already recored in this subbasin!")
                 sys.exit()
 
-
         elif(self.model==cst.measures):
             print("Reading the measurements outlet file...")
             if(type(fileNames)!=str):
@@ -736,7 +801,25 @@ class SubBasin:
                     i += 1
 
             matrixData = np.array(list_data).astype("float")
-            # Init of the outflow array
+            # Init the time properties if not already done
+            if self.dateBegin is None or self.dateEnd is None or self.deltaT == 0:
+                if nbCl==5:
+                    self.dateBegin = datetime.datetime(year=int(matrixData[0][2]), month=int(matrixData[0][1]), day=int(matrixData[0][0]), hour=int(matrixData[0][3]), tzinfo=datetime.timezone.utc)
+                    self.dateEnd = datetime.datetime(year=int(matrixData[-1][2]), month=int(matrixData[-1][1]), day=int(matrixData[-1][0]), hour=int(matrixData[-1][3]), tzinfo=datetime.timezone.utc)
+                    self.deltaT = (datetime.datetime(year=int(matrixData[1][2]), month=int(matrixData[1][1]), day=int(matrixData[1][0]), hour=int(matrixData[1][3]), tzinfo=datetime.timezone.utc) 
+                                    - self.dateBegin).total_seconds()
+                if nbCl==7:
+                    self.dateBegin = datetime.datetime(year=int(matrixData[0][2]), month=int(matrixData[0][1]), day=int(matrixData[0][0]), 
+                                                       hour=int(matrixData[0][3]), minute=int(matrixData[0][4]), second=int(matrixData[0][5]),  
+                                                       microsecond=0, tzinfo=datetime.timezone.utc)
+                    self.dateEnd = datetime.datetime(year=int(matrixData[-1][2]), month=int(matrixData[-1][1]), day=int(matrixData[-1][0]), 
+                                                       hour=int(matrixData[-1][3]), minute=int(matrixData[-1][4]), second=int(matrixData[-1][5]),  
+                                                       microsecond=0, tzinfo=datetime.timezone.utc)
+                    self.deltaT = (datetime.datetime(year=int(matrixData[1][2]), month=int(matrixData[1][1]), day=int(matrixData[1][0]), 
+                                    hour=int(matrixData[1][3]), minute=int(matrixData[1][4]), second=int(matrixData[1][5]),  
+                                    microsecond=0, tzinfo=datetime.timezone.utc) - self.dateBegin).total_seconds()
+                    
+            # Init of the outflow array                    
             timeInterval = self.dateEnd-self.dateBegin+datetime.timedelta(seconds=self.deltaT)
             outFlow = np.zeros(int(timeInterval.total_seconds()/self.deltaT),dtype=ct.c_double, order='F')
             timeArray = np.zeros(int(timeInterval.total_seconds()/self.deltaT))
@@ -816,7 +899,6 @@ class SubBasin:
                 print("ERROR: the dates read are not consitent with the dates already recored in this subbasin!")
                 sys.exit()
 
-
         elif(self.model==cst.compare_opti):
             print("Reading the measurements outlet file...")
             if(type(fileNames)!=str):
@@ -837,6 +919,13 @@ class SubBasin:
                     i += 1
 
             matrixData = np.array(list_data).astype("float")
+            
+            # Init the time properties if not already done
+            if self.dateBegin is None or self.dateEnd is None or self.deltaT == 0:
+                self.dateBegin = datetime.datetime.fromtimestamp(matrixData[0][0], tz=datetime.timezone.utc)
+                self.dateEnd = datetime.datetime.fromtimestamp(matrixData[-1][0], tz=datetime.timezone.utc)
+                self.deltaT = matrixData[1][0]-matrixData[0][0]
+
             # Init of the outflow array
             timeInterval = self.dateEnd-self.dateBegin+datetime.timedelta(seconds=self.deltaT)
             # outFlow = np.zeros(int(timeInterval.total_seconds()/self.deltaT),dtype=ct.c_double, order='F')
@@ -1039,7 +1128,8 @@ class SubBasin:
         nameOutFlow = list(self._outFlow.items())[0][0]
         # Sum all the inlets hydrographs
         self.sum_inlets()
-        if(self.model==cst.tom_UH or self.model==cst.measures or self.model==cst.tom_GR4):
+        if(self.model==cst.tom_UH or self.model==cst.measures or 
+           self.model==cst.tom_GR4 or self.model==cst.compare_opti):
             tmpHydro = np.zeros(len(self.myHydro),dtype=ct.c_double, order='F')
             if(self.model==cst.tom_GR4):
                 tmpHydro = self.myHydro[:,0]*self.surfaceDrained/3.6
@@ -2557,7 +2647,7 @@ class SubBasin:
         allInlets = []
 
         for element in self.intletsObj:
-            allInlets.append(self.intletsObj[element].name)
+            allInlets.append(str(self.intletsObj[element].name))
 
         return allInlets
 
@@ -2569,6 +2659,11 @@ class SubBasin:
             timeDelays = self.intletsObj[element].get_timeDelays(timeDelays)
 
         return timeDelays
+    
+
+    def get_timeDelays_inlets(self):
+
+        return {el.name: el.timeDelay-self.timeDelay for el in self.intletsObj.values()}
 
 
     def get_surface_proportions(self, show=True):
@@ -2667,16 +2762,16 @@ class SubBasin:
             self.intletsObj[element].save_timeDelays()
 
 
-    def get_myHydro(self, unit:str="mm/h"):
+    def get_myHydro(self, unit:str="mm/h") -> np.ndarray:
 
-        if unit=="m3/s" or "m^3/s":
+        if unit=="m3/s" or unit=="m^3/s":
             if self.model == cst.measures:
                 # FIXME we consider so far that myHydro of a measures are in m^3/h
                 myHydro = self.myHydro
             elif self.surfaceDrained<=0.0:
                 logging.error("The surface drained is negative or equal to zero! myHydro will be given in mm/h!")
                 if len(np.shape(self.myHydro)) == 1:
-                    myHydro = self.myHydro
+                    myHydro = self.myHydro.copy()
                 else:
                     myHydro = np.sum(self.myHydro,1)
             else:
@@ -2686,7 +2781,7 @@ class SubBasin:
                     myHydro = np.sum(self.myHydro,1)*self.surfaceDrained/3.6
         else:
             if len(np.shape(self.myHydro)) == 1:
-                myHydro = self.myHydro
+                myHydro = self.myHydro.copy()
             else:
                 myHydro = np.sum(self.myHydro,1)
 
@@ -2840,11 +2935,7 @@ class SubBasin:
 
     def get_outFlow_names(self)->list:
 
-        names = []
-        for key in self._outFlow:
-            names.append(key)
-
-        return names
+        return list(self._outFlow.keys())
 
 
     def change_version(self, newVersion=None):
@@ -2866,7 +2957,7 @@ class SubBasin:
 
     ## This procedure is updating all the hydrographs of all upstream elements imposing limits
     # @var level_min integer that specify the potential level at which the update should be stopped.
-    def update_upstream_hydro(self, level_min:int=1):
+    def update_upstream_hydro(self, level_min:int=1, update_upstream:bool=True):
 
         for key in self.intletsObj:
             curObj = self.intletsObj[key]
@@ -3013,14 +3104,506 @@ class SubBasin:
         return peak_s
 
 
+    def collect_x_from_production(self) -> dict[str,np.array]:
+        """
+        This procedure is collecting all the time series fractions of each outflow of the hydrological production models written in Fortran
+        
+        Returns:
+            dict[str, np.array]: A dictionary containing the fractions of each outflow.
+        """
+        all_x = {}
+
+        if self.model == cst.tom_VHM:
+            all_x = self.collect_x_VHM()
+        elif self.model == cst.tom_GR4:
+            all_x = self.collect_x_GR4()
+        elif self.model == cst.tom_2layers_linIF:
+            all_x = self.collect_x_2layers()
+        
+        return all_x
+    
+    def collect_fractions(self) -> dict[str,np.array]:
+        """
+        This procedure is collecting all the fractions of each outflow of the hydrological production models.
+        
+        Returns:
+            dict[str, np.array]: A dictionary containing the fractions of each outflow.
+        """
+        all_x = self.collect_x_from_production()
+
+        if self.model == cst.tom_VHM:
+            all_f = self._collect_fractions_VHM(all_x)
+        elif self.model == cst.tom_GR4:
+            all_f = self._collect_fractions_GR4(all_x)
+        elif self.model == cst.tom_2layers_linIF:
+            all_f = self._collect_fractions_2layers(all_x)
+        
+        return all_f
+    
+    
+    def collect_all_internal_variables(self) -> dict[str,np.array]:
+        """
+        This procedure is collecting all internal variables of the hydrological production models.
+        
+        Returns:
+            dict[str, np.array]: A dictionary containing the fractions of each outflow.
+        """
+        all_iv = {}
+
+        if self.model == cst.tom_VHM:
+            all_iv = self.collect_iv_VHM()
+        elif self.model == cst.tom_GR4:
+            all_iv = self.collect_iv_GR4()
+        elif self.model == cst.tom_2layers_linIF:
+            all_iv = self.collect_iv_2layers()
+        
+        return all_iv
+    
+    
+    def activate_all_internal_variables(self):
+        """
+        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()
+
+
+    def collect_x_VHM(self) -> dict[str,np.array]:
+        """
+        This procedure is collecting all the fractions of each outflow of the VHM model.
+        
+        Returns:
+        - all_x: A dictionary containing the fractions of each outflow of the VHM model.
+        """
+        list_keys = ["x", "U"]
+        files_per_keys = [["xbf", "xif", "xof", "xu"],[]]
+        group = "Internal variables to save"
+        param = "simul_soil"
+        
+        all_x = self.collect_internal_variables(list_keys, files_per_keys, 
+                            group_name=group, param_name=param)
+
+        return all_x
+    
+
+    def _collect_fractions_VHM(self, all_x:dict[str,np.array]) -> dict[str,np.array]:
+        """
+        This procedure is collecting all the fractions of each outflow of the VHM model.
+        
+        Returns:
+        - all_f: A dictionary containing the fractions of each outflow of the VHM model.
+        """
+        all_f = {}
+
+        if all_x=={}:
+            return all_f
+        
+        condition = self.myRain > 0.0
+
+        all_f["% qof"] = np.where(condition, all_x["xof"] * 100.0, np.nan)
+        all_f["% qif"] = np.where(condition, all_x["xif"] * 100.0, np.nan)
+        all_f["% qbf"] = np.where(condition, all_x["xbf"] * 100.0, np.nan)
+        all_f["% loss"] = np.where(condition, all_x["xu"]  * 100.0, np.nan)
+        
+        return all_f
+    
+    
+    def collect_iv_VHM(self) -> dict[str,np.array]:
+        """
+        This procedure is collecting all internal variables of the VHM model in each module.
+        
+        Returns:
+        - all_iv: A dictionary containing all internal variables of the VHM model.
+        """
+        list_keys = ["x", "U"]
+        files_per_keys = [[],["U"]]
+        group = "Internal variables to save"
+        param = "simul_soil"
+        
+        all_iv = self.collect_internal_variables(list_keys, files_per_keys, 
+                            group_name=group, param_name=param)
+
+        return all_iv
+    
+
+    def activate_all_iv_VHM(self):
+        """
+        This procedure is activating all internal variables of the VHM model in each module.
+        """
+        list_keys = ["x", "U"]
+        group = "Internal variables to save"
+        param = "simul_soil"
+        
+        self.activate_internal_variables(list_keys, group_name=group, param_name=param)
+    
+
+    def collect_x_GR4(self) -> dict[str,np.array]:
+        """
+        This procedure is collecting the fractions of each outflow of the GR4 model.
+        
+        Returns:
+            dict[str, np.array]: A dictionary containing all fractions of each outflow of the GR4 model.
+        """
+        all_x = {}
+        
+        return all_x
+    
+    
+    def _collect_fractions_GR4(self, all_x:dict[str,np.array]) -> dict[str,np.array]:
+        """
+        This procedure is collecting all the fractions of each outflow of the GR4 model.
+        
+        Returns:
+        - all_f: A dictionary containing the fractions of each outflow of the GR4 model.
+        """
+        all_f = {}
+        
+        return all_f
+    
 
-    # FIXME Finish the function below -> returning all possible or desired internal variables
-    # def get_InterVar(self, typeVar:int):
+    def collect_iv_GR4(self) -> dict[str,np.array]:
+        """
+        This procedure is collecting all internal variables of the GR4 model in each module.
+        
+        Returns:
+        - all_iv: A dictionary containing all internal variables of the GR4 model.
+        """
+        all_iv = {}
+        
+        return all_iv
+    
+
+    def activate_all_iv_GR4(self):
+        """
+        This procedure is activating all internal variables of the GR4 model in each module.
+        """
+        return
+    
 
-    #     if typeVar==
+    def collect_x_2layers(self) -> dict[str,np.array]:
+        """
+        This procedure is collecting the fractions of each outflow of the 2 layers model.
+        
+        Returns:
+            A dictionary containing the collected fractions of each outflow variables.
+        """
+        list_keys = ["x", "U", "Reservoir"]
+        files_per_keys = [["xif"], [], ["xp"]]
+        group = "Internal variables to save"
+        param = "simul_soil"
+        
+        all_x = self.collect_internal_variables(list_keys, files_per_keys, 
+                                                group_name=group, param_name=param)
+
+        return all_x
+    
+
+    def _collect_fractions_2layers(self, all_x:dict[str,np.array]) -> dict[str,np.array]:
+        """
+        This procedure is collecting all the fractions of each outflow of the 2 layers model.
+        
+        Returns:
+        - all_f: A dictionary containing the fractions of each outflow of the 2 layers model.
+        """
+        all_f = {}
+
+        if all_x=={}:
+            return all_f
+        
+        condition = self.myRain > 0.0
+        
+        f_if = np.where(condition, all_x["xp"] * all_x["xif"], np.nan)
+        
+        all_f["% qof"] = (all_x["xp"] - f_if) * 100.0
+        all_f["% qif"] = f_if * 100.0
+        all_f["% loss"] = np.where(condition, (1.0 - all_x["xp"]) * 100.0, np.nan)
+        
+        return all_f
+    
+
+    def collect_iv_2layers(self) -> dict[str,np.array]:
+        """
+        This procedure is collecting all internal variables of the 2 layers model in each module.
+        
+        Returns:
+        - all_iv: A dictionary containing the fractions all internal variables of the 2 layers model.
+        """
+        list_keys = ["x", "U", "Reservoir"]
+        files_per_keys = [[], ["U"], ["S"]]
+        group = "Internal variables to save"
+        param = "simul_soil"
+        
+        all_iv = self.collect_internal_variables(list_keys, files_per_keys, 
+                                                group_name=group, param_name=param)
+        
+        return all_iv
+    
+
+    def activate_all_iv_2layers(self):
+        """
+        This procedure is activating all internal variables of the 2 layers model in each module.
+        """
+        list_keys = ["x", "U", "Reservoir"]
+        group = "Internal variables to save"
+        param = "simul_soil"
+        
+        self.activate_internal_variables(list_keys, group_name=group, param_name=param)
+
+    
+    def collect_internal_variables(self, list_keys:list[str], files_per_keys:list[list[str]], 
+                  group_name:str="Internal variables to save", param_name:str="simul_soil"
+                )-> dict[str,np.array]:
+        """
+        Collects all the internal variables of the 2 layers model.
+
+        Parameters:
+        - list_keys (list[str]): List of keys representing the internal variables to collect.
+        - files_per_keys (list[list[str]]): List of lists containing the file names associated with each key.
+        - group_name (str, optional): Name of the group containing the internal variables to save. Default is "Internal variables to save".
+        - production_name (str, optional): Name of the production file. Default is "simul_soil".
+
+        Returns:
+        - dict[str,np.array]: A dictionary containing the collected internal variables, where the keys are the variable names and the values are numpy arrays.
+
+        """
+        all_iv = {}
+
+        production_file = ".".join([param_name,"param"])
+        cur_dir = os.path.join(self.fileNameRead, "Subbasin_"+str(self.iDSorted))
+        param_fileName = os.path.join(cur_dir, production_file)
+
+        wolf_soil = Wolf_Param(to_read=True, filename=param_fileName,toShow=False, init_GUI=False)
+
+        for index, curKey in enumerate(list_keys):
+            ok_IV = wolf_soil.get_param(group_name, curKey, default_value=0)
+            if ok_IV == 1:
+                for curVar in files_per_keys[index]:
+                    ts_file = "".join([param_name, "_", curVar, ".dat"])
+                    isOk, tmp = rd.check_path(os.path.join(cur_dir, ts_file))
+                    if isOk<0:
+                        logging.warning("The file : " + ts_file + " does not exist!")
+                        continue
+                    time, cur_iv = rd.read_hydro_file(cur_dir, ts_file)
+                    all_iv[curVar] = cur_iv
+            else:
+                logging.warning("Please activate the interval variable : " + curKey + "to have access the following fraction of outlets : ")
+        
+        return all_iv
+    
+
+    def activate_internal_variables(self, list_keys:list[str], group_name:str="Internal variables to save", param_name:str="simul_soil"):
+        """
+        Activates all the internal variables of the 2 layers model.
+
+        Parameters:
+        - list_keys (list[str]): List of keys representing the internal variables to collect.
+
+        """
+        production_file = ".".join([param_name,"param"])
+        cur_dir = os.path.join(self.fileNameRead, "Subbasin_"+str(self.iDSorted))
+        param_fileName = os.path.join(cur_dir, production_file)
+
+        wolf_soil = Wolf_Param(to_read=True, filename=param_fileName,toShow=False, init_GUI=False)
+
+        for curKey in list_keys:
+            wolf_soil.change_param(group_name, curKey, 1)
+        
+        wolf_soil.SavetoFile(None)
+        wolf_soil.Reload(None)
+
+        return
+    
+    def get_summary_fractions(self, summary:str="mean", 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()
+        
+        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) for key in all_f}
+        else:
+            logging.error("The summary type is not recognised!")
+            return []
+
+    
+
+    def check_presence_of_iv(self):
+        """
+        This procedure is checking the presence of internal variables in the current module.
+        """
+        # TODO
+
+        return
+    
+
+    def get_all_Qtest(self, nb_atttempts=-1, typeOutFlow:str="Net", unit:str='m3/s', whichOutFlow="", lag:float=0.0) -> np.array:
+        """
+        This function returns the Qtest hydrograph of the current module.
+
+        Parameters:
+        - which (str, optional): The type of hydrograph to return. Default is "Net".
+
+        Returns:
+        - np.array: The Qtest hydrograph of the current module.
+        """
+        
+        # FIXME Take into account all the possible types of hydrographs and units
+        file_debug_info = "simul_GR4_out_debuginfo.txt"
+        prefix = "simul_GR4_out"
+        
+        working_dir =  os.path.join(self.fileNameRead, 'Subbasin_' + str(self.iDSorted) + '/')
+
+        q_test = []
+
+        file_debug_info = "_".join([prefix,"_debuginfo.txt"])
+        if nb_atttempts < 0:
+            with open(os.path.join(working_dir,file_debug_info), 'r') as file:
+                lines = file.readline()
+            items = lines.split('\t')
+            nb_init = int(items[0])
+            nb_max = int(items[0])
+            nb_atttempts = nb_max
+
+        all_files = [os.path.join(working_dir,"".join([prefix,str(i+1)+".dat"])) for i in range(nb_atttempts)]
+        areOk = [(rd.check_path(file)[0])>=0 
+                 for file in all_files]
+        max_index = next((i for i, x in enumerate(areOk) if x == False), len(areOk))
+        q_test = [rd.read_hydro_file(working_dir, file_name)[1]*self.surfaceDrained/3.6 
+                  for file_name in all_files[:max_index]]
+
+        
+        # for i in range(nb_atttempts):
+        #     file_name = "".join([prefix,str(i+1)+".dat"])
+        #     isOk, full_name = rd.check_path(os.path.join(working_dir, file_name))
+        #     if isOk<0:
+        #         break
+        #     t, cur_q = rd.read_hydro_file(working_dir, file_name)
+        #     cur_q = cur_q*self.surfaceDrained/3.6
+        #     q_test.append(cur_q)            
+
+        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 == "":
+            writeFile = os.path.join(self.fileNameWrite, "PostProcess", "_".join(["Q_fractions", self.name]))
+        else:
+            writeFile = os.path.join(writeDir, "_".join(["Q_fractions", self.name]))
+        
+        if all_fractions == {}:
+            all_fractions = self.collect_fractions()
+            if all_fractions == {}:
+                logging.warning("No fractions found!")
+                return
+        elif self.name in all_fractions:
+            all_fractions = all_fractions[self.name]
+        else:
+            all_fractions =  {}
+            logging.warning("The name of the current module is not in the dictionary of fractions!")
+
+        nb_elements = len(all_fractions)
+        if nb_elements == 0:
+            logging.warning("No fractions found!")
+            return
+        y = [el for el in all_fractions.values()]
+        x = [el for el in all_fractions.keys()]
+        y_label = "Fractions of the outflows [%]"
+        graph_title = "Fractions of the outflows of " + self.name
+
+        ph.plot_hydro(nb_elements, y,time=self.time, y_titles=y_label, y_labels=x, writeFile=writeFile, figure=figure, graph_title=graph_title, rangeData=range_data)
+
+        if to_show:
+            plt.show()
+
+
+    def evaluate_objective_function(self, unit="mm/h")->np.ndarray:
+        """
+        This procedure is evaluating the objective function of the current module.
+
+        Returns:
+        - np.ndarray: The objective function of the current module.
+        """
+        # FIXME
+        unit='mm/h'
+
+        return self.get_outFlow(unit=unit)
+        
+    
+
+    def import_from_pandas_Series(self, data:pd.Series, which="outFlow"):
+        time = data.index.values.astype(np.int64) // 10 ** 9
+
+        if which == "outFlow":
+            self._outFlow["Net"] = data.values.astype(dtype=ct.c_double, order='F')
+        elif which == "outFlowRaw":
+            self._outFlow["Raw"] = data.values.astype(dtype=ct.c_double, order='F')
+        elif which == "myHydro":
+            self.myHydro = data.values.astype(dtype=ct.c_double, order='F')
+        elif which == "myRain":
+            data = data.values.astype(dtype=np.double, order='F')
+        elif which == "cumul_rain":
+            data = data.values.astype(dtype=np.double, order='F')
+        else:
+            logging.error("Not a recognised 'which' argument!")
+            logging.error("Try the following : 'ouflow', 'outFlowRaw', 'myHydro', 'myRain', 'cumul_rain'")
+
+        return
+    
+    def export_to_pandas_Series(self, which="outFlow"):
+        idx = pd.to_datetime(self.time, unit='s', utc=True)
+
+        if which == "outFlow":
+            data = self.outFlow
+        elif which == "outFlowRaw":
+            data = self.outFlowRaw
+        elif which == "myHydro":
+            data = self.myHydro
+        elif which == "myRain":
+            data = self.myRain
+        elif which == "cumul_rain":
+            data = self.cumul_rain
+        else:
+            logging.error("Not a recognised 'which' argument!")
+            logging.error("Try the following : 'ouflow', 'outFlowRaw', 'myHydro', 'myRain', 'cumul_rain'")
+            return None
+        
+        tserie = pd.Series(data, index=idx, copy=True, name=" ".join([self.name,which]))
 
+        return tserie
 
 
+    # def plot_Nash_vs_Qexcess(self, figure:plt.axis=None, toShow:bool=False, writeFile:str=""):