wolfhece 2.0.43__py3-none-any.whl → 2.0.45__py3-none-any.whl

wolfhece/hydrology/RetentionBasin.py

@@ -9,7 +9,7 @@ from scipy.interpolate import interp1d
 import os
 import ctypes as ct
 
-
+from .SubBasin import *
 from .Outlet import *
 from .Dumping import *
 from ..PyTranslate import _
@@ -26,8 +26,11 @@ class RetentionBasin():
     _outFlow:dict
     surfaceDrainedHydro:float # TO BUILD !!!!!!!!!!!!!!
     filledVolume:np.ndarray
+    intletsObj:dict
+    directFluxObj:dict
 
-    def __init__(self, _dateBegin, _dateEnd, _deltaT, _time=None, _id='J1', _name='Default name', _type='', _dictRB={}, _directDictRB={}, _tz=0, _outletNames=[], withRBDict=True, _workingDir=""):
+    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
         self.name = _name
@@ -359,15 +362,28 @@ class RetentionBasin():
         if(self.intletsObj != {}):
             nameOutFlow = list(self.intletsObj.items())[0][0]
             curObj = self.intletsObj[nameOutFlow]
-            timeInlet = curObj.timeDelay
-            deltaTr = timeInlet - self.timeDelay
+            # 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 = curObj.get_outFlow(typeOutFlow="Net", whichOutFlow=nameOutFlow, lag=deltaTr)
             self.inletsRaw = curObj.get_outFlow(typeOutFlow="Raw", whichOutFlow=nameOutFlow, lag=deltaTr)
             for i in range(1,len(list(self.intletsObj.items()))):
                 nameOutFlow = list(self.intletsObj.items())[i][0]
                 curObj = self.intletsObj[nameOutFlow]
                 timeInlet = curObj.timeDelay
-                deltaTr = timeInlet - self.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 += curObj.get_outFlow(typeOutFlow="Net", whichOutFlow=nameOutFlow, lag=deltaTr)
                 self.inletsRaw += curObj.get_outFlow(typeOutFlow="Raw", whichOutFlow=nameOutFlow, lag=deltaTr)
         elif(givenInlet != []):
@@ -394,6 +410,13 @@ class RetentionBasin():
             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 = curObj.get_outFlow(typeOutFlow="Net", whichOutFlow=nameOutFlow, lag=deltaTr)
             self.directFluxInRB_Raw = curObj.get_outFlow(typeOutFlow="Raw", whichOutFlow=nameOutFlow, lag=deltaTr)
@@ -401,7 +424,14 @@ class RetentionBasin():
                 nameOutFlow = list(self.directFluxObj.items())[i][0]
                 curObj = self.directFluxObj[nameOutFlow]
                 timeInlet = curObj.timeDelay
-                deltaTr = timeInlet - self.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
+
                 try:
                     self.directFluxInRB += curObj.get_outFlow(typeOutFlow="Net", whichOutFlow=nameOutFlow, lag=deltaTr)
                 except:
@@ -448,8 +478,8 @@ class RetentionBasin():
         else:
             # self.directFluxInRB = np.zeros(len(self.time)-1)
             # self.directFluxInRB_Raw = np.zeros(len(self.time)-1)
-            self.directFluxInRB = np.zeros(len(self.time))
-            self.directFluxInRB_Raw = np.zeros(len(self.time))
+            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 plot(self, workingDir, plotRaw=True, axis="Hours",rangeData=[], deltaMajorTicks=24.0*3600.0, deltaMinorTicks=3600.0, tzPlot=0, unitReservoir="[m^3]"):
@@ -648,7 +678,7 @@ class RetentionBasin():
 
 
     def plot_outlet(self, Measures=None, rangeData=[], yrangeRain=[], yrangeData=[], ylabel=[],addData=[], dt_addData=[], beginDates_addData=[], endDates_addData=[],\
-                    label_addData=[], color_addData=[],factor=1.5, graph_title='', withEvap=False, writeFile='', withDelay=True, deltaMajorTicks=-1,deltaMinorTicks=-1, tzPlot=0):
+                    label_addData=[], color_addData=[],factor=1.5, graph_title='', withEvap=False, writeFile='', withDelay=True, deltaMajorTicks=-1,deltaMinorTicks=-1, tzPlot=0, figure=None):
 
         print("plot_outlet() function for RB -> TO DO !!!")
 
@@ -819,10 +849,9 @@ class RetentionBasin():
             logging.warning("Therefore, lag will be imposed to zero!")
             lag = 0.0
 
-        if(self.type == "HelleRB"):
-            if "delta time" in self._outFlow[whichOutFlow]:
-                timeDelta = self._outFlow[whichOutFlow]["delta time"]
-                lag = timeDelta
+        if "delta time" in self._outFlow[nameOutFlow]:
+            timeDelta = self._outFlow[nameOutFlow]["delta time"]
+            lag += timeDelta
 
 
         index = math.floor(lag/(self.time[1]-self.time[0]))
@@ -921,13 +950,14 @@ class RetentionBasin():
         return self.get_outFlow(whichOutFlow=whichOutFlow, typeOutFlow="Raw", unit=unit)
 
 
-    def get_inlets_noDelay(self, unit='m3/s'):
+    def get_inlets_noDelay(self, unit='m3/s')->np.ndarray:
         """
         This function returns the total inlets of the basin and considers t0=0 at the outlet of the
         subbasin without considering timeDelay (the time of the real outlet of the whole potential catchment)
         """
 
         logging.warning("This function 'get_inlets_noDelay()' is operational but obsolate since version" + str(cst.VERSION_WOLFHYDRO_2023_1))
+        logging.warning("Please use the function 'get_inlets()' instead")
 
         # nameOut = list(self.outFlow.items())[0][0]
         # myInlets = self.inlets
@@ -984,6 +1014,36 @@ class RetentionBasin():
         return myInlet
 
 
+    def get_direct_insideRB_inlets(self, unit:str='m3/s', lag:float=0.0)->np.ndarray:
+
+        if lag < 0.0:
+            logging.error("TimeDelay difference cannot be negative for a SubBasin!!")
+            logging.warning("Therefore, lag will be imposed to zero! This might create some mistakes!")
+            lag = 0.0
+
+        direct_inlets = np.zeros(len(self.directFluxInRB),dtype=ct.c_double, order='F')
+        index = math.floor(lag/(self.time[1]-self.time[0]))
+
+        if(index==0):
+            direct_inlets = self.directFluxInRB.copy()
+        elif(index<len(direct_inlets)):
+            direct_inlets[index:] = self.directFluxInRB[:-index].copy()
+        else:
+            logging.error("Warning: the simulation time is not long enough for this subbasin to be taken into account")
+            logging.error("Error informations : ")
+            logging.error("Function name : get_inlets()")
+            logging.error("index = " + str(index))
+            logging.error("len(myOutFlow) = " + str(len(direct_inlets)))
+            logging.error("Lag = " + str(lag))
+            return direct_inlets
+
+        if unit=='mm/h':
+            logging.warning("Arguable way to convert in mm/h, there is ambiguity!")
+            direct_inlets *= 3.6/self.surfaceDrainedHydro
+
+        return direct_inlets
+
+
     def write_height_reservoir(self, workingDir):
 
         myH = np.zeros(len(self.filledVolume))
@@ -1015,11 +1075,12 @@ class RetentionBasin():
 
             # Artificial exit
             nameArtificialExit = list(self._outFlow.items())[1][0]
-            timeDelayNextRB = self.downstreamObj[nameArtificialExit].timeDelay
-            timeDelta = self._outFlow[nameArtificialExit]["delta time"]
-            newStep = self.convert_index_global_to_other_global(step,timeDelayOut=timeDelayNextRB,timeDelta=timeDelta)
-            if(newStep>0 and newStep<len(self._outFlow[nameArtificialExit]["Net"])):
-                self._outFlow[nameArtificialExit]["Net"][newStep] = Qstream
+            self._outFlow[nameArtificialExit]["Net"][step] = Qstream
+            # timeDelayNextRB = self.downstreamObj[nameArtificialExit].timeDelay
+            # timeDelta = self._outFlow[nameArtificialExit]["delta time"]
+            # newStep = self.convert_index_global_to_other_global(step,timeDelayOut=timeDelayNextRB,timeDelta=timeDelta)
+            # if(newStep>0 and newStep<len(self._outFlow[nameArtificialExit]["Net"])):
+            #     self._outFlow[nameArtificialExit]["Net"][newStep] = Qstream
 
         else:
             self._outFlow[mainNameOut]["Net"][step] = Qstream + Qres
@@ -1095,13 +1156,13 @@ class RetentionBasin():
         relVol = self.relative_filledVolume
         for iOutFlow in range(1,len(list(self._outFlow.items()))):
             nameOut = list(self._outFlow.items())[iOutFlow][0]
-            self._outFlow[nameOut]["Raw"] = np.zeros(len(self.inletsRaw))
+            self._outFlow[nameOut]["Raw"] = np.zeros(len(self.inletsRaw), dtype=ct.c_double, order='F')
 
         sizeOfHydro = len(self.time)
         for elOutFlow in self._outFlow:
-            self._outFlow[elOutFlow]["Net"] =  np.zeros(sizeOfHydro)
+            self._outFlow[elOutFlow]["Net"] =  np.zeros(sizeOfHydro, dtype=ct.c_double, order='F')
 
-        outFlowReservoir = np.zeros(sizeOfHydro)
+        outFlowReservoir = np.zeros(sizeOfHydro, dtype=ct.c_double, order='F')
         for i in range(1,sizeOfHydro):
 
             h = self.volume_to_h(self.filledVolume[i-1])
@@ -1278,13 +1339,33 @@ class RetentionBasin():
 
 
     def construct_surfaceDrainedHydro(self):
+        """
+        Calculates the total surface drained hydrology by summing up the surface drained hydrology values
+        from the directFluxObj and intletsObj modules.
+        Cautions: when there are several outflows in a module, the surfaceDrainedHydro is added only once,
+        towards the natural outlet of the module (by convention the first outflow).
+
+        Returns:
+            None
+        """
 
         self.surfaceDrainedHydro = 0.0
-        for element in self.directFluxObj:
-            self.surfaceDrainedHydro += self.directFluxObj[element].surfaceDrainedHydro
 
-        for element in self.intletsObj:
-            self.surfaceDrainedHydro += self.intletsObj[element].surfaceDrainedHydro
+        for key, cur_module in self.directFluxObj.items():
+            names = cur_module.get_outFlow_names()
+            if len(names)==1:
+                self.surfaceDrainedHydro += cur_module.surfaceDrainedHydro
+            else:
+                if names[0] == key:
+                    self.surfaceDrainedHydro += cur_module.surfaceDrainedHydro
+
+        for key, cur_module in self.intletsObj.items():
+            names = cur_module.get_outFlow_names()
+            if len(names)==1:
+                self.surfaceDrainedHydro += cur_module.surfaceDrainedHydro
+            else:
+                if names[0] == key:
+                    self.surfaceDrainedHydro += cur_module.surfaceDrainedHydro
 
 
     def unuse(self, mask=[]):
@@ -1377,10 +1458,10 @@ class RetentionBasin():
         allInlets = []
 
         for element in self.intletsObj:
-            allInlets.append(self.intletsObj[element].name)
+            allInlets.append(str(self.intletsObj[element].name))
 
         for element in self.directFluxObj:
-            allInlets.append(self.directFluxObj[element].name)
+            allInlets.append(str(self.directFluxObj[element].name))
 
         return allInlets
 
@@ -1397,6 +1478,14 @@ class RetentionBasin():
 
         return timeDelays
 
+    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):
@@ -1422,29 +1511,25 @@ class RetentionBasin():
         return self.timeDelayObj.get_iDSorted()
 
 
-    def get_outFlow_names(self)->list:
-
-        names = []
-        for key in self._outFlow:
-            names.append(key)
+    def get_outFlow_names(self)->list:        
 
-        return names
+        return list(self._outFlow.keys())
 
 
     ## 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]
             if curObj.myLevel>=level_min:
-                curObj.update_hydro(update_upstream=True, level_min=level_min)
+                curObj.update_hydro(update_upstream=update_upstream, level_min=level_min)
 
 
         for key in self.directFluxObj:
             curObj = self.directFluxObj[key]
             if curObj.myLevel>=level_min:
-                curObj.update_hydro(update_upstream=True, level_min=level_min)
+                curObj.update_hydro(update_upstream=update_upstream, level_min=level_min)
 
 
 
@@ -1452,9 +1537,12 @@ 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):
-
-        if update_upstream:
-            self.update_upstream_hydro(level_min=level_min)
+        
+        # !!! (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:
+        #     self.update_upstream_hydro(level_min=level_min)
+        self.update_upstream_hydro(update_upstream=update_upstream,level_min=level_min)
 
         self.compute_hydro()
 
@@ -1529,4 +1617,71 @@ class RetentionBasin():
             imax = min(np.argmin(mask[imin:]), nbT)
             self.filledVolume = volume[imin:imax+1]
 
-        return
+        return
+    
+
+    def evaluate_objective_function(self, unit="mm/h")->np.ndarray:
+        # unit = "m3/s"
+            
+        return self.get_direct_insideRB_inlets(unit=unit)
+
+
+    def update_from_RBdict(self, dict_RB={}):
+
+        self.type = self.dictRB['type'][key_Param.VALUE]
+        if('stagnant height' in self.dictRB):
+            self.hStagn =  float(self.dictRB['stagnant height'][key_Param.VALUE])
+        if(self.type == 'HighwayRB'):
+            self.surface = float(self.dictRB['surface'][key_Param.VALUE])
+            self.hBank = float(self.dictRB['height 2'][key_Param.VALUE])
+            self.volume = self.surface * self.hBank
+        elif(self.type == 'RobiernuRB'):
+            self.volume = float(self.dictRB['volume'][key_Param.VALUE])
+        elif(self.type == 'OrbaisRB'):
+            self.volume = float(self.dictRB['volume'][key_Param.VALUE])
+            try:
+                zvFile = self.dictRB['Z-V file'][key_Param.VALUE]
+            except:
+                zvFile = ""
+            if(zvFile!=""):
+                zvFile = zvFile.replace("\\", "/")
+                self.read_zv(zvFile)
+
+        elif(self.type == 'ForcedDam'):
+            self.volume = float(self.dictRB['volume'][key_Param.VALUE])
+            self.hi = float(self.dictRB['initial height'][key_Param.VALUE])
+            self.vi = self.h_to_volume(self.hi)
+
+            try:
+                zvFile = self.dictRB['Z-V file'][key_Param.VALUE]
+            except:
+                zvFile = ""
+            if(zvFile!=""):
+                zvFile = zvFile.replace("\\", "/")
+
+                #FIXME : Blinder la gestion des noms relatifs via une fonction
+                if os.path.isabs(zvFile):
+                    self.read_zv(zvFile)
+                else:
+                    self.read_zv(os.path.join(self.fileNameRead,zvFile))
+
+            if("time delay" in self.dictRB):
+                self.timeDelay = float(self.dictRB["time delay"][key_Param.VALUE])
+        elif(self.type == "HelleRB"):
+            self.volume = float(self.dictRB['volume'][key_Param.VALUE])
+            try:
+                zvFile = self.dictRB['Z-V file'][key_Param.VALUE]
+                isOk, zvFile = check_path(zvFile, self.fileNameRead, applyCWD=True)
+                if isOk<0:
+                    print("ERROR : Problem in the Z-V file!")
+                    zvFile = ""
+            except:
+                zvFile = ""
+            if(zvFile!=""):
+                zvFile = zvFile.replace("\\", "/")
+                self.read_zv(zvFile)
+
+        else:
+            print("WARNING: This type RB was not recognised! Please check the RetentionBasin.postPro file.")
+
+