wolfhece 2.1.126__py3-none-any.whl → 2.1.128__py3-none-any.whl

wolfhece/coupling/hydrology_2d.py

@@ -16,6 +16,7 @@ from ..PyTranslate import _
 
 from scipy.spatial import KDTree
 import pandas as pd
+from datetime import datetime
 from pathlib import Path
 import numpy as np
 from typing import Literal, Union
@@ -27,22 +28,32 @@ from matplotlib.axes import Axes
 
 
 class InjectionType(Enum):
-    GLOBAL = 'Global'
-    PARTIAL = 'Partial'
-    ANTHROPOGENIC = 'Anthropogenic'
-    CONSTANT = 'Constant'
-    VIRTUAL = 'Virtual'
+    GLOBAL = 'Global'                   # Global hydrograph - sum of upstream watershed and local hydrograph (hydrological model)
+    PARTIAL = 'Partial'                 # Partial hydrograph - local hydrograph only (hydrological model)
+    ANTHROPOGENIC = 'Anthropogenic'     # Output of an anthropogenic module (hydrological model)
+    CONSTANT = 'Constant'               # Constant value (user input)
+    VIRTUAL = 'Virtual'                 # Virtual hydrograph - Combination/Part of hydrographs (computed by the coupling)
+    FORCED_UNSTEADY = 'Forced unsteady' # Imposed unsteady flow (user input)
 
+BUILDING_TOLERANCE = 0.05 # Epsilon for the buildings (DEM-DTM) [m]
 
 class Searching_Context():
+    """ Part of the hydrological model adapted for seraching tasks """
 
-    def __init__(self, 
-                 river_axis:vector, 
-                 kdtree:KDTree, 
-                 nodes:Node_Watershed, 
-                 downstream_reaches:list[int], 
+    def __init__(self,
+                 river_axis:vector,
+                 kdtree:KDTree,
+                 nodes:Node_Watershed,
+                 downstream_reaches:list[int],
                  up_node:Node_Watershed) -> None:
-        
+        """
+        :param river_axis: river axis -- vector
+        :param kdtree: KDTree of the downstream reaches
+        :param nodes: nodes of the downstream reaches - from Hydrology model
+        :param downstream_reaches: downstream reaches - from Hydrology model
+        :param up_node: up node - from Hydrology model
+        """
+
         self.river_axis:vector              = river_axis        # river axis -- vector
         self.kdtree:KDTree                  = kdtree            # KDTree of the downstream reaches
         self.nodes:Node_Watershed           = nodes             # nodes of the downstream reaches - from Hydrology model
@@ -50,7 +61,8 @@ class Searching_Context():
         self.up_node:Node_Watershed         = up_node           # up node - from Hydrology model
 
     def __str__(self) -> str:
-        
+        """ Return a string representation of the searching context """
+
         ret = ''
 
         ret += f"  Number of reaches: {len(self.downstream_reaches)}\n"
@@ -64,7 +76,15 @@ class Searching_Context():
 class Scaled_Infiltration():
 
     def __init__(self, idx:int, type:InjectionType, colref:str, factor:float, lagtime:float) -> None:
-        
+        """ Constructor of the scaled infiltration
+
+        :param idx: index of the infiltration
+        :param type: type of the infiltration
+        :param colref: reference column
+        :param factor: multiplicator factor [-]
+        :param lagtime: lag time [s]
+        """
+
         self.index = idx        # index of the infiltration
         self.type = type        # type of the infiltration
         self.colref = colref    # reference column
@@ -74,7 +94,7 @@ class Scaled_Infiltration():
 class Coupling_Hydrology_2D():
 
     def __init__(self) -> None:
-        
+
 
         self._rivers_zones:list[Zones] = []
         self.rivers:dict[str, vector] = {}
@@ -92,7 +112,10 @@ class Coupling_Hydrology_2D():
         self.hydrographs_local:pd.DataFrame = None
         self._hydrographs_virtual = []
 
-        self._dem:WolfArray = None
+        self._dem:WolfArray = None  # Digital Elevation Model
+        self._dtm:WolfArray = None  # Digital Terrain Model -- Optional -- if exists, no infiltration authorized on buildings (defined as dem > dtm)
+        self._buildings:WolfArray = None  # Buildings -- exists if dtm exists
+
         self._infil_idx:WolfArray = None
         self.counter_zone_infil = 0
 
@@ -100,7 +123,7 @@ class Coupling_Hydrology_2D():
         # Chaque zone est définie par :
         #  - un type d'infiltration
         #  - un nom d'hydrogramme (ou une valeur constante)
-        #  - un facteur podérateur 
+        #  - un facteur podérateur
         #  - un temps de déphasage
 
         self.infiltrations:list[Scaled_Infiltration] = []
@@ -120,11 +143,25 @@ class Coupling_Hydrology_2D():
         self_along = None
         self._locales = None
 
+    @property
+    def dateBegin(self) -> datetime:
+        if self._hydrology_model is None:
+            logging.error(_("No hydrology model loaded"))
+            return None
+        return self._hydrology_model.dateBegin
+
+    @property
+    def dateEnd(self) -> datetime:
+        if self._hydrology_model is None:
+            logging.error(_("No hydrology model loaded"))
+            return None
+        return self._hydrology_model.dateEnd
+
     def __str__(self) -> str:
         """ Return a string representation of the coupling """
-        
+
         ret =''
-        
+
         ret += _("Rivers: {}\n").format(len(self.rivers))
         for curriver in self.rivers:
             ret += f"{curriver}\n"
@@ -145,22 +182,22 @@ class Coupling_Hydrology_2D():
             ret += f"{cursearch} : \n{self._searching[cursearch]}\n"
 
         ret += f"Coupling array: \n{self._infil_idx}\n"
-        
+
         return ret
 
     @property
     def number_of_injections(self) -> int:
-        
+
         if self._infil_idx is None:
             logging.error(_("No infiltration array -- Spread the injections first"))
             return 0
 
         return self._infil_idx.array.max()
-    
+
     @property
     def number_of_nodes_per_zone(self) -> dict[int, int]:
         """ Return the number of nodes per zone """
-        
+
         if self._infil_idx is None:
             logging.error(_("No infiltration array -- Spread the injections first"))
             return {}
@@ -168,7 +205,7 @@ class Coupling_Hydrology_2D():
         non_zeros = self._infil_idx.array[np.where(self._infil_idx.array > 0)]
 
         return {i:np.count_nonzero(non_zeros == i) for i in range(1, self.number_of_injections+1)}
-    
+
     def plot_number_of_nodes_per_zone(self) -> tuple[Figure, Axes]:
         """ Plot the number of nodes per zone """
 
@@ -183,20 +220,20 @@ class Coupling_Hydrology_2D():
         ax.set_ylabel(_("Number of nodes"))
 
         return fig, ax
-            
+
     @property
     def along(self) -> list[str, str]:
         return self._along
-    
+
     @along.setter
     def along(self, value:list[tuple[str, str]]) -> None:
 
         for curval in value:
-            
+
             curcol, currivers = curval
-            
+
             assert curcol in self.hydrographs_local.columns, f"Column {curcol} not found in hydrographs"
-            
+
             def check_rivers(currivers):
                 if isinstance(currivers, list):
                     for curriver in currivers:
@@ -209,36 +246,46 @@ class Coupling_Hydrology_2D():
     @property
     def locales(self) -> list[str]:
         return self._locales
-    
+
     @locales.setter
-    def locales(self, value:list[str]) -> None:
+    def locales(self, value:list[tuple[str, str | pd.Series | float, InjectionType]]) -> None:
+        """ Set the locales injections """
 
         for curvect, curcol, curtype in value:
+            # Check if the data is correct
 
-            if curtype != InjectionType.CONSTANT:
+            if curtype not in [InjectionType.CONSTANT, InjectionType.FORCED_UNSTEADY]:
                 assert curvect in self.locale_injections, f"Vector {curvect} not found"
                 assert curcol in list(self.hydrographs_total.columns)+ self._hydrographs_virtual, f"Column {curcol} not found in hydrographs"
+            elif curtype == InjectionType.FORCED_UNSTEADY:
+                assert isinstance(curcol, pd.Series), "Forced unsteady flow should be a Series"
+                # check if the DateFrame has value inside interval of the hydrographs
+                assert curcol.index[0] <= self.dateBegin, "Forced unsteady flow should start before the hydrographs"
+                assert curcol.index[-1] >= self.dateEnd, "Forced unsteady flow should end after the hydrographs"
+            else:
+                assert isinstance(curcol, float), "Constant value should be a float"
 
         self._locales = value
 
     @property
     def watershed(self) -> Watershed:
         return self._hydrology_model.charact_watrshd
-    
+
     @property
     def river_system(self) -> RiverSystem:
         return self.watershed.riversystem
-    
+
     @property
     def subs_array(self) -> WolfArray:
         return self.watershed.subs_array
-    
-    def set_array_to_coupling(self, array:WolfArray | Path) -> None:
-        """ Set the array to coupling 
-        
+
+    def set_array_to_coupling(self, array:WolfArray | Path, dtm:WolfArray | Path = None) -> None:
+        """ Set the array to coupling
+
         :param array: The array to coupling
+        :param dtm: The DTM of the array
         """
-        
+
         if isinstance(array, Path):
             if array.exists():
                 self._dem = WolfArray(array)
@@ -246,7 +293,18 @@ class Coupling_Hydrology_2D():
                 logging.error(_("File {} not found").format(array))
                 return
 
+        if isinstance(dtm, Path):
+            if dtm.exists():
+                self._dtm = WolfArray(dtm)
+            else:
+                logging.error(_("File {} not found").format(dtm))
+                return
+
         self._dem = array
+        self._dtm = dtm
+
+        assert self._dem.get_header().is_like(self._dtm.get_header()), "DEM and DTM should have the same header"
+
         self._create_infiltration_array()
 
     def _create_infiltration_array(self):
@@ -256,34 +314,51 @@ class Coupling_Hydrology_2D():
             logging.error(_("No array to coupling"))
             return
 
+        if self._dtm is None:
+            logging.info(_("No DTM found -- Infiltration authorized everywhere"))
+        else:
+            logging.info(_("DTM found -- Infiltration authorized only on the ground"))
+            self._buildings = self._dem - self._dtm
+
+            # Buildings are defined as the difference between the DEM and the DTM
+            # If the difference is greater than BUILDING_TOLERANCE, the cell is considered as a building
+            # Otherwise, the cell is considered as a ground
+
+            # If cell is masked in the DTM, cells is considred as ground
+            self._buildings.array[np.logical_and(~self._dem.array.mask,self._dtm.array.mask)] = 0.
+
+            self._buildings.array[self._buildings.array < BUILDING_TOLERANCE] = 0.
+            self._buildings.array[self._buildings.array >= BUILDING_TOLERANCE] = 1.
+            self._buildings.mask_data(0.)
+
         self._infil_idx = WolfArray(srcheader=self._dem.get_header(), whichtype=WOLF_ARRAY_FULL_INTEGER)
         self._infil_idx.add_ops_sel()
         self._infil_idx.array[:,:] = 0
 
-        self.counter_zone_infil = 0  
- 
+        self.counter_zone_infil = 0
+
     def add_hydrology_model(self, name:str, filename:str | Path) -> None:
-        """ Add a hydrology model to the coupling 
-        
+        """ Add a hydrology model to the coupling
+
         :param filename: The filename of the hydrology model
         """
-        
+
         self._hydrology_model = Catchment(name, str(filename), False, True)
-    
+
     def get_anthropogenic_names(self) -> list[str]:
         """ Print the names of the anthropogenic hydrographs """
-        
+
         if self._hydrology_model is None:
             logging.error(_("No hydrology model loaded"))
             return []
 
-        return [" : ".join([cur_anth.name, name]) 
-                    for cur_anth in self._hydrology_model.retentionBasinDict.values() 
+        return [" : ".join([cur_anth.name, name])
+                    for cur_anth in self._hydrology_model.retentionBasinDict.values()
                     for name in cur_anth.get_outFlow_names()]
-    
+
     def get_names_areas(self) -> list[str]:
         """ Print the names of the areas """
-        
+
         if self._hydrology_model is None:
             logging.error(_("No hydrology model loaded"))
             return []
@@ -295,12 +370,12 @@ class Coupling_Hydrology_2D():
         return names, area_subs, area_glob
 
     def create_hydrographs_local_global(self, unit_discharge:float, total_duration:float, anth_discharge:dict = None) -> None:
-        """ 
+        """
         Create the hydrographs from the hydrology model .
-        
+
         Global and local hydrographs are created based on a unit discharge and a total duration.
 
-        You can also add anthropogenic hydrographs from a dictionary. 
+        You can also add anthropogenic hydrographs from a dictionary.
         The key is the name of the anthropogenic hydrograph and the value is the discharge.
         The keys can be obtained with the method get_anthropogenic_names.
 
@@ -311,14 +386,14 @@ class Coupling_Hydrology_2D():
         # Extract the column names according to their sorted subbasin indices
         col_time = "Time [s]"
         col_subs, area_subs, area_glob = self.get_names_areas()
-        col_anth = [" : ".join([cur_anth.name, name]) 
-                    for cur_anth in self._hydrology_model.retentionBasinDict.values() 
+        col_anth = [" : ".join([cur_anth.name, name])
+                    for cur_anth in self._hydrology_model.retentionBasinDict.values()
                     for name in cur_anth.get_outFlow_names()]
-        
+
         #Create a dictionnary
 
         dict_glob = {col_time : [0., total_duration]}
-        
+
         for cur_sub, cur_area in zip(col_subs, area_glob):
             discharge = cur_area * unit_discharge
             dict_glob[cur_sub] = [discharge, discharge]
@@ -350,23 +425,23 @@ class Coupling_Hydrology_2D():
             if self._hydrology_model is None:
                 logging.error(_("No hydrology model loaded"))
                 return
-            
+
             directory = Path(self._hydrology_model.workingDir) / 'PostProcess'
 
         if total is not None:
             self.hydrographs_total.to_csv(directory / total, sep='\t', decimal='.', encoding='latin1')
         else:
             self.hydrographs_total.to_csv(directory / 'Hydros_2_simul2D.txt', sep='\t', decimal='.', encoding='latin1')
-        
+
         if partial is not None:
             self.hydrographs_local.to_csv(directory / partial, sep='\t', decimal='.', encoding='latin1')
         else:
             self.hydrographs_local.to_csv(directory / 'HydrosSub_2_simul2D.txt', sep='\t', decimal='.', encoding='latin1')
 
-    
+
     def load_hydrographs(self, directory:str | Path = None, total:str = None, partial:str = None) -> None:
-        """ Load the hydrographs from the hydrology model 
-        
+        """ Load the hydrographs from the hydrology model
+
         :param directory: The directory of the hydrology model -- If None, the working directory of the loaded hydrology model is used
         :param total: The filename of the total hydrographs - If None, the default filename is used
         :param partial: The filename of the partial hydrographs - If None, the default filename is used
@@ -378,7 +453,7 @@ class Coupling_Hydrology_2D():
             if self._hydrology_model is None:
                 logging.error(_("No hydrology model loaded"))
                 return
-            
+
             directory = Path(self._hydrology_model.workingDir) / 'PostProcess'
 
             if total is not None:
@@ -401,7 +476,7 @@ class Coupling_Hydrology_2D():
                     self.hydrographs_local = pd.read_csv(partial, sep='\t', decimal='.', header=0, index_col=0, encoding='latin1')
                 else:
                     logging.error(_("File {} not found").format(partial))
-            
+
             else:
                 partial = directory / 'HydrosSub_2_simul2D.txt'
                 if partial.exists():
@@ -409,18 +484,18 @@ class Coupling_Hydrology_2D():
                 else:
                     logging.error(_("File {} not found").format(partial))
 
-    
+
     def print_hydrographs(self, total:bool = True, partial:bool = True) -> None:
         """ Print the hydrographs from the hydrology model """
 
         if total:
             print(_("Total hydrographs:"))
             print(self.hydrographs_total.columns)
-        
+
         if partial:
             print(_("Partial hydrographs:"))
             print(self.hydrographs_local.columns)
-    
+
     def plot_hydrographs(self, total:bool = True, partial:bool = True) -> tuple[tuple[Figure, Axes],tuple[Figure, Axes]]:
         """ Plot the hydrographs from the hydrology model """
 
@@ -430,9 +505,9 @@ class Coupling_Hydrology_2D():
             ax1.legend(loc='upper center', ncol=8)
             ax1.set_ylim(0, 1000)
             fig1.set_size_inches(15, 5)
-            fig1.tight_layout()       
+            fig1.tight_layout()
         else:
-            fig1, ax1 = None, None 
+            fig1, ax1 = None, None
 
         if partial:
             ax2 = self.hydrographs_local.plot()
@@ -440,11 +515,11 @@ class Coupling_Hydrology_2D():
             ax2.legend(loc='upper center', ncol=8)
             ax2.set_ylim(0, 1000)
             fig2.set_size_inches(15, 5)
-            fig2.tight_layout()   
+            fig2.tight_layout()
         else:
-            fig2, ax2 = None, None 
+            fig2, ax2 = None, None
 
-        return (fig1, ax1), (fig2, ax2)    
+        return (fig1, ax1), (fig2, ax2)
 
 
     def add_virtual_hydrograph(self, name:str, src_hydrograph_name:str, factor:float, lag:float=0.):
@@ -453,16 +528,16 @@ class Coupling_Hydrology_2D():
         self._hydrographs_virtual.append((name, src_hydrograph_name, factor, lag))
 
     def add_river(self, filename:str | Path) -> None:
-        """ Add a river to the hydrology model 
-        
+        """ Add a river to the hydrology model
+
         :param filename: The filename of the river
         """
-        
+
         self._rivers_zones.append(Zones(filename))
 
     def reset(self) -> None:
         """ Reset the hydrology model """
-        
+
         self._rivers_zones = []
         self.rivers = {}
         self._locale_injection_zones = None
@@ -475,11 +550,11 @@ class Coupling_Hydrology_2D():
         self.reset_injections()
 
     def add_locale_injections(self, filename:str | Path) -> None:
-        """ Add a local injection to the hydrology model 
-        
+        """ Add a local injection to the hydrology model
+
         :param filename: The filename of the local injection
         """
-        
+
         self._locale_injection_zones = Zones(filename)
 
     def find_river_axis(self):
@@ -498,19 +573,19 @@ class Coupling_Hydrology_2D():
                         logging.warning(_("Vector {} in zone {} is not used -- Ignoring it as a river axis").format(curvector.myname, curzone.myname))
 
     def _add_injection(self, name:str, vect:vector):
-        """ Add an injection to the hydrology model 
-        
+        """ Add an injection to the hydrology model
+
         :param name: The name of the injection
         :param vect: The vector of the injection
         """
-        
+
         self.locale_injections[name] = vect
 
     def find_injections(self):
         """ Find the injection points from Zones """
 
         for curzone in self._locale_injection_zones.myzones:
-            
+
             names = [curvect.myname for curvect in curzone.myvectors]
 
             if 'injection' in names:
@@ -530,8 +605,8 @@ class Coupling_Hydrology_2D():
             self.upstreams[curriver] = (up.x, up.y)
 
     def _find_upstream(self, curvect:vector) -> wolfvertex:
-        """ Find the upstream of a vector 
-        
+        """ Find the upstream of a vector
+
         :param curvect: The river's axis
         """
 
@@ -552,17 +627,17 @@ class Coupling_Hydrology_2D():
             return vert1
 
     def prepare_search(self, rivers:list[str] = None):
-        """ 
+        """
         Prepare the search for the hydrology model.
 
-        The order is important because the reaches will be 
+        The order is important because the reaches will be
         progressively excluded from the search for the next ones.
 
         So, you have to start with the **main river** and then the **tributaries**.
-        
+
         :param rivers: The list of rivers to prepare
         """
-        
+
         excluded = []
 
         if rivers is None:
@@ -580,12 +655,12 @@ class Coupling_Hydrology_2D():
 
             # Récupération de la maille rivière la plus proche
             dist, node_up = self.river_system.get_nearest_nodes(self.upstreams[curriver])
-            
+
             # Récupération de la liste des biefs en aval
             downstream = self.river_system.get_downstream_reaches_excluded(node_up, excluded)
 
             excluded += downstream
-                        
+
             # Mis en place d'une structure de recherche rapide
             nodes, kdtree = self.river_system.get_kdtree_from_reaches(downstream)
 
@@ -593,37 +668,37 @@ class Coupling_Hydrology_2D():
 
     def _is_global(self, col_name:str):
         """ Vérifie si la colonne est un hydrogramme global """
-        
+
         return col_name in self.hydrographs_total.columns
 
     def _is_partial(self, col_name:str):
         """ Vérifie si la colonne est un hydrogramme partiel """
-        
+
         return col_name in self.hydrographs_local.columns
 
     def _is_anthropic(self, col_name:str):
-        """ 
-        Vérifie si la colonne est un hydrogramme anthropique 
+        """
+        Vérifie si la colonne est un hydrogramme anthropique
         (c'est-à-dire une colonne de l'hydrogramme total qui n'est pas un hydrogramme partiel)
-        
+
         """
-        
+
         return self._is_global(col_name) and not self._is_partial(col_name)
 
     def _is_virtual(self, col_name:str):
         """ Vérifie si la colonne est un hydrogramme virtuel """
-        
+
         return col_name in [virtualname for virtualname, src_name, frac, lag in self._hydrographs_virtual]
 
-    def _add_infil(self, 
-                  type_name:InjectionType, 
-                  col_name_q:str | float, 
-                  factor:float, 
-                  lag:float, 
+    def _add_infil(self,
+                  type_name:InjectionType,
+                  col_name_q:str | float,
+                  factor:float,
+                  lag:float,
                   index_zone:int = None):
-        """ 
-        Ajoute une infiltration à la liste des infiltrations 
-        
+        """
+        Ajoute une infiltration à la liste des infiltrations
+
         :param type_name: nom du type d'infiltration
         :param col_name: nom de la colonne de l'hydrogramme
         :param factor: facteur multiplicatif
@@ -646,20 +721,20 @@ class Coupling_Hydrology_2D():
         if index_zone is None:
             self.counter_zone_infil += 1
             index_zone = self.counter_zone_infil
-        
+
         self.infiltrations.append(Scaled_Infiltration(index_zone, type_name, col_name_q, factor, lag))
 
         return index_zone
 
-    def _add_local_injecton(self, 
-                           local_vect:vector, 
-                           type_name:InjectionType, 
-                           col_name:str, 
-                           factor:float, 
+    def _add_local_injecton(self,
+                           local_vect:vector,
+                           type_name:InjectionType,
+                           col_name:str,
+                           factor:float,
                            lag:float):
-        
-        """ 
-        Ajoute une injection locale à la liste des infiltrations 
+
+        """
+        Ajoute une injection locale à la liste des infiltrations
         et remplissage de la matrice d'infiltration
 
         :param local_vect: vecteur de la zone d'injection
@@ -667,7 +742,7 @@ class Coupling_Hydrology_2D():
         :param col_name: nom de la colonne de l'hydrogramme
         :param factor: facteur multiplicatif
         :param lag: déphasage
-        
+
         """
 
         assert type_name in InjectionType, f"Unknown type {type_name}"
@@ -677,7 +752,7 @@ class Coupling_Hydrology_2D():
 
             self.local_infiltrations[local_vect] = self._add_infil(type_name, col_name, factor, lag)
 
-            # Mise à zéro de la sélection dans la matrice d'infiltration 
+            # Mise à zéro de la sélection dans la matrice d'infiltration
             self._infil_idx.SelectionData.reset()
             # Sélection des mailles à l'intérieur du polygone de la zone d'injection
             self._infil_idx.SelectionData.select_insidepoly(local_vect)
@@ -687,12 +762,23 @@ class Coupling_Hydrology_2D():
             # Conversion des coordonnées en indices de mailles
             ij = self._infil_idx.get_ij_from_xy_array(xy)
 
-            # Affectation de l'indice de la zone d'infiltration
-            for i,j in ij:
-                self._infil_idx.array[i,j] = self.local_infiltrations[local_vect]
+            if self._buildings is not None:
+                # Vérification de la présence de bâtiments dans la zone d'infiltration
+                for i,j in ij:
+                    if self._buildings.array[i,j] == 1:
+                        logging.warning(f"Building found in infiltration zone {local_vect.myname} -- Maille {i,j} ignored")
+                        continue
+                    self._infil_idx.array[i,j] = self.local_infiltrations[local_vect]
+
+                assert np.count_nonzero(self._infil_idx.array == self.local_infiltrations[local_vect]) > 0, f"No infiltration in zone {local_vect.parentzone.myname}"
+
+            else:
+                # Affectation de l'indice de la zone d'infiltration
+                for i,j in ij:
+                    self._infil_idx.array[i,j] = self.local_infiltrations[local_vect]
 
-            # Vérification du nombre de mailles affectées
-            assert len(ij) == np.count_nonzero(self._infil_idx.array == self.local_infiltrations[local_vect]), "Bad count for {}".format(type_name)
+                # Vérification du nombre de mailles affectées
+                assert len(ij) == np.count_nonzero(self._infil_idx.array == self.local_infiltrations[local_vect]), "Bad count for {}".format(type_name)
 
         else:
             # Une injection existe déjà dans cette zone
@@ -707,8 +793,8 @@ class Coupling_Hydrology_2D():
                             col_name:str,
                             factor:float,
                             lag:float):
-        """ 
-        Ajoute une injection le long de la rivière 
+        """
+        Ajoute une injection le long de la rivière
         et remplissage de la matrice d'infiltration
 
         :param list_part: liste des coordonnées des points de la rivière
@@ -727,22 +813,22 @@ class Coupling_Hydrology_2D():
 
     def write_infil_array(self, dirout:Path):
         """ Sauvegarde de la matrice d'infiltration """
-        
+
         self._infil_idx.mask_data(0)
         self._infil_idx.nullvalue = 99999
         self._infil_idx.set_nullvalue_in_mask()
         self._infil_idx.write_all(dirout / f'infiltration.tif')
 
     def _get_reaches_in_sub(self, subbasin:SubWatershed, rivers_names:list[str]) -> list[list[int]]:
-        """ 
-        Retourne une liste de listes des biefs dans le sous-bassin 
-        
+        """
+        Retourne une liste de listes des biefs dans le sous-bassin
+
         :param rivers: liste des noms des rivières
         :return: liste des biefs dans le sous-bassin
         """
 
         ret = []
-        
+
         if rivers_names[0] not in self._searching:
             logging.error(f"River {rivers_names[0]} not found")
             return ret
@@ -750,7 +836,7 @@ class Coupling_Hydrology_2D():
         reaches1 = self._searching[rivers_names[0]].downstream_reaches
 
         reaches_in_sub = [idx for idx in reaches1 if subbasin.is_reach_in_sub(idx)]
-        
+
         if len(reaches_in_sub) == 0:
             logging.error(f"No reaches in subbasin for river {rivers_names[0]}")
 
@@ -762,7 +848,7 @@ class Coupling_Hydrology_2D():
             for loc in locret:
                 ret.append(loc)
         else:
-            
+
             if rivers_names[1] not in self._searching:
                 logging.error(f"River {rivers_names[1]} not found")
                 return ret
@@ -778,9 +864,9 @@ class Coupling_Hydrology_2D():
         return ret
 
     def _get_outlet_reaches(self, subbasin:SubWatershed, idx_reaches:list[int]) -> Node_Watershed:
-        """ 
-        Retourne le noeud de sortie du sous-bassin 
-        
+        """
+        Retourne le noeud de sortie du sous-bassin
+
         :param reaches: liste des biefs dans le sous-bassin
         :return: noeud de sortie du sous-bassin
         """
@@ -800,16 +886,16 @@ class Coupling_Hydrology_2D():
         return newsub1, newsub2
 
     def _split_hydrographs(self, subbasin:SubWatershed | str, river_names:list[str, list[str]]):
-        """ 
-        Séparation de l'hydrogramme partiel en fonction 
-        des surfaces drainées par chaque rivère 
-        
+        """
+        Séparation de l'hydrogramme partiel en fonction
+        des surfaces drainées par chaque rivère
+
         On attend au maximum 2 rivières ou 1 rivière et une liste de rivières.
 
         Les rivières seront traitées 2 par 2 de façon récursive.
 
         La seconde rivière et l'affluent de la première rivière.
-        
+
         """
 
         if isinstance(subbasin, str):
@@ -821,7 +907,7 @@ class Coupling_Hydrology_2D():
         fraction2 = sub2.area / subbasin.area
 
         assert fraction1 + fraction2 == 1., "Bad fractions"
-        
+
         self.add_virtual_hydrograph(sub1.name, subbasin.name, fraction1, 0.)
         self.add_virtual_hydrograph(sub2.name, subbasin.name, fraction2, 0.)
 
@@ -835,18 +921,18 @@ class Coupling_Hydrology_2D():
             added.append((sub2.name, river_names[1]))
 
         return added
-    
+
     def get_locale_injection_names(self):
         """ Print the names of the local injections """
-        
+
         return list(self.locale_injections.keys())
-    
+
     def get_along_injection_names(self) -> tuple[list[str], list[str]]:
-        """ Get the names of the along injections 
-        
+        """ Get the names of the along injections
+
         :return: The names of the rivers along which the injections are made and the columns of the hydrographs
         """
-        
+
         return list(self.lists_part.keys()), list(self.hydrographs_local.columns)
 
     def reset_injections(self):
@@ -858,7 +944,7 @@ class Coupling_Hydrology_2D():
             self._infil_idx.array[:,:] = 0
 
         self._hydrographs_virtual = []
-        
+
         self.infiltrations = []
         self.local_infiltrations = {}
 
@@ -871,7 +957,7 @@ class Coupling_Hydrology_2D():
         self.injections_along()
 
         self.create_hydrographs()
-    
+
     def injections_locales(self, couplings:list[tuple[str, str, InjectionType]] = None):
         """ Ajoute les injections locales """
 
@@ -890,9 +976,9 @@ class Coupling_Hydrology_2D():
 
 
     def link_area2nodes(self):
-        """ 
+        """
         Searching cells in dem associated to the river nodes in the hydrological model.
-        
+
         We use the river axis to select the cells in the dem.
 
         Then we search the nearest river nodes in the hydrological
@@ -901,7 +987,7 @@ class Coupling_Hydrology_2D():
         We create local lists of cells associated to one river node.
 
         Due to the fact that the river axis is not exactly the same
-        as the river nodes (not the same spatial resolution, rester vs vector), 
+        as the river nodes (not the same spatial resolution, rester vs vector),
         all river nodes in the hydrological model
         are not necessarely associated to cells in the dem.
 
@@ -914,22 +1000,22 @@ class Coupling_Hydrology_2D():
             nodes = self._searching[key_river].nodes
 
             # Mise à 0 des zones sélectionnées
-            self._dem.SelectionData.reset()   
+            self._dem.SelectionData.reset()
             # Sélection des mailles sur l'axe du lit mineur
             self._dem.SelectionData.select_underpoly(river_axis)
 
             # Coordonnées XY des mailles sélectionnées
             xy_selected = self._dem.SelectionData.myselection
-            
-            # Recherche des mailles rivières les plus proches 
+
+            # Recherche des mailles rivières les plus proches
             # dans la modélisation hydrologique
             dist, nearest = kdtree.query(xy_selected, k=1)
             # Récupération des noeuds correspondants aux index fournis par l'objet KDTree
             nearest:list[Node_Watershed] = [nodes[i] for i in nearest]
-            
+
             # Surface drainée par les mailles
             drained_surface = np.array([cur.uparea for cur in nearest])
-            
+
             # Valeurs de BV uniques
             unique_area = np.unique(drained_surface)
 
@@ -950,7 +1036,7 @@ class Coupling_Hydrology_2D():
         if along is None:
             logging.error(_("No along injections defined"))
             return
-        
+
         along = along.copy()
 
         # ## Création de bassins virtuels afin de séparer les hydrogrammes en plusieurs rivières
@@ -964,7 +1050,7 @@ class Coupling_Hydrology_2D():
 
         # La rivière secondaire peut également être décomposée en plusieurs selon le même principe.
 
-        # **La procédure de calcul est récursive.**        
+        # **La procédure de calcul est récursive.**
         to_split = [cur for cur in along if isinstance(cur[1], list)]
 
         replace = []
@@ -975,16 +1061,16 @@ class Coupling_Hydrology_2D():
             along.remove(cur)
 
         for cur in replace:
-            along.append(cur)      
+            along.append(cur)
 
         for cur in along:
-            self._injection_along(cur)  
-    
+            self._injection_along(cur)
+
     def _injection_along(self, name_subwatershed_river:tuple[str, str]):
 
-        # Nom de colonne et liste de mailles potentielles à utiliser 
+        # Nom de colonne et liste de mailles potentielles à utiliser
         # pour la répartition
-        
+
         name_subwatershed, river = name_subwatershed_river
 
         list_rivers, used_reaches = self.lists_part[river], self._searching[river].downstream_reaches
@@ -1006,14 +1092,14 @@ class Coupling_Hydrology_2D():
         local_areas = 0.
         # liste contenant la maille de connection au réseau et la maille d'injection locale
         to_remove:list[tuple[Node_Watershed, Node_Watershed, float]] = []
-        
+
         for cur_locinj in local_injections:
 
             # Recherche du noeud rivière le plus proche de la zone d'injection locale
             dist, node_local_injection = self.river_system.get_nearest_nodes(cur_locinj)
 
             if node_local_injection.reach not in used_reaches:
-                # Recherche de la maille rivière en aval 
+                # Recherche de la maille rivière en aval
                 # qui fait partie de la distribution en long
                 down = self.river_system.go_downstream_until_reach_found(node_local_injection, used_reaches)
             else:
@@ -1022,8 +1108,8 @@ class Coupling_Hydrology_2D():
                 down = node_local_injection
                 while down is not None and down.uparea not in unique_areas:
                     down = down.down
-            
-        
+
+
             # surface su sous-bassin qui sera injectée localement
             local_area = node_local_injection.uparea - subbasin.get_area_outside_sub_if_exists(node_local_injection, node_local_injection.get_up_reaches_same_sub())
 
@@ -1043,7 +1129,7 @@ class Coupling_Hydrology_2D():
 
         # aire drainée à la limite amont du ss-bassin, le long de la distribution en long
         up_node = subbasin.get_up_rivernode_outside_sub(subbasin.outlet, used_reaches)
-        
+
         if up_node is None:
             starting_node = subbasin.get_list_nodes_river(min(used_reaches))[-1]
             area_min = subbasin.get_area_outside_sub_if_exists(starting_node, starting_node.get_up_reaches_same_sub())
@@ -1059,7 +1145,7 @@ class Coupling_Hydrology_2D():
         frac_sum=0.
 
         def area_to_remove(node:Node_Watershed) -> float:
-            
+
             uparea = 0.
 
             # injections locales
@@ -1086,10 +1172,10 @@ class Coupling_Hydrology_2D():
 
             if fraction_loc > 0.:
 
-                self._add_along_injection(lists[unique_areas[idx]], 
-                                    InjectionType.PARTIAL if not subbasin._is_virtual else InjectionType.VIRTUAL, 
-                                    name_subwatershed, 
-                                    fraction_loc, 
+                self._add_along_injection(lists[unique_areas[idx]],
+                                    InjectionType.PARTIAL if not subbasin._is_virtual else InjectionType.VIRTUAL,
+                                    name_subwatershed,
+                                    fraction_loc,
                                     lag =0.)
 
                 frac_sum += fraction_loc
@@ -1100,26 +1186,26 @@ class Coupling_Hydrology_2D():
 
         fraction_loc = delta_loc / delta_area
 
-        self._add_along_injection(lists[unique_areas[-1]], 
-                            InjectionType.PARTIAL if not subbasin._is_virtual else InjectionType.VIRTUAL, 
-                            name_subwatershed, 
-                            fraction_loc, 
+        self._add_along_injection(lists[unique_areas[-1]],
+                            InjectionType.PARTIAL if not subbasin._is_virtual else InjectionType.VIRTUAL,
+                            name_subwatershed,
+                            fraction_loc,
                             lag =0.)
 
         frac_sum += fraction_loc
 
         if frac_sum > 1.001 or frac_sum < 0.999:
-            logging.error(f"Bad sum of fractions {frac_sum} " + name_subwatershed)     
+            logging.error(f"Bad sum of fractions {frac_sum} " + name_subwatershed)
 
 
     def create_hydrographs(self):
-        """ Création des hydrogrammes 
-        
+        """ Création des hydrogrammes
+
         Les étapes précédentes ont ajouté à la liste "infiltrations" les éléments suivants:
 
         - l'index de la zone d'infiltration (1-based)
         - l'hydrogramme de référence
-        - la fecteur pondérateur
+        - le facteur pondérateur
         - le temps de déphasage
 
         Une zone peut contenir plusieurs apports.
@@ -1128,7 +1214,7 @@ class Coupling_Hydrology_2D():
 
         Le fichier final est ordonné comme la matrice d'infiltration.
 
-        Avant de sommer, il faut tout d'abord créer les hydrogrammes associés au BV virtuels (décomposition d'un BV, modélisé comme un tout, en plusieurs rivières distinctes pour la répartition en long)        
+        Avant de sommer, il faut tout d'abord créer les hydrogrammes associés au BV virtuels (décomposition d'un BV, modélisé comme un tout, en plusieurs rivières distinctes pour la répartition en long)
         """
 
         dt = self.hydrographs_total.index[1] - self.hydrographs_total.index[0]
@@ -1146,7 +1232,7 @@ class Coupling_Hydrology_2D():
 
             if src_hydrograph_name in self.hydrographs_local.columns:
                 df_virtual[name] = self.hydrographs_local.shift(decal, fill_value=0.)[src_hydrograph_name] * factor
-                
+
             elif src_hydrograph_name in df_virtual.columns:
                 df_virtual[name] = df_virtual.shift(decal, fill_value=0.)[src_hydrograph_name] * factor
 
@@ -1176,26 +1262,26 @@ class Coupling_Hydrology_2D():
                     loc_count += 1
 
                     if type_name == InjectionType.GLOBAL:
-                        
+
                         if loc_count == 1:
                             df_2d_dict[idx]  = self.hydrographs_total.shift(decal, fill_value = 0.)[col_name] * factor
                         else:
                             df_2d_dict[idx] += self.hydrographs_total.shift(decal, fill_value = 0.)[col_name] * factor
-                    
+
                     elif type_name == InjectionType.PARTIAL:
-                        
+
                         if loc_count == 1:
                             df_2d_dict[idx]  = self.hydrographs_local.shift(decal, fill_value = 0.)[col_name] * factor
                         else:
                             df_2d_dict[idx] += self.hydrographs_local.shift(decal, fill_value = 0.)[col_name] * factor
-                    
+
                     elif type_name == InjectionType.ANTHROPOGENIC:
 
                         if loc_count == 1:
                             df_2d_dict[idx]  = self.hydrographs_total.shift(decal, fill_value = 0.)[col_name] * factor
                         else:
                             df_2d_dict[idx] += self.hydrographs_total.shift(decal, fill_value = 0.)[col_name] * factor
-                    
+
                     elif type_name == InjectionType.VIRTUAL:
 
                         if loc_count == 1:
@@ -1210,9 +1296,17 @@ class Coupling_Hydrology_2D():
                         else:
                             df_2d_dict[idx] += col_name * factor
 
+                    elif type_name == InjectionType.FORCED_UNSTEADY:
+
+                        col_name:pd.Series
+                        if loc_count == 1:
+                            df_2d_dict[idx]  = col_name.loc[self.dateBegin:self.dateEnd].values * factor
+                        else:
+                            df_2d_dict[idx] += col_name.loc[self.dateBegin:self.dateEnd].values * factor
+
                     else:
                         logging.error(f"Unknown type {type_name}")
-            
+
             if loc_count != counter[i-1]:
                 logging.error(f"Bad count for {i}")
 
@@ -1221,9 +1315,18 @@ class Coupling_Hydrology_2D():
 
 
     def save_hydrographs(self, dirout:Path, name:str):
-        """ Write the hydrographs"""
+        """ Write the hydrographs
 
-        with open(dirout / (name + f'_infiltration_zones.txt'), 'w') as f:
+        :param dirout: The output directory
+        :param name: The name of the output file (if no suffix .txt, it will be added)
+        """
+
+        # ensure suffix .txt
+        if not name.endswith('.txt'):
+            name += '.txt'
+
+        locname = name.replace('.txt', '_infiltration_zones.txt')
+        with open(dirout / locname, 'w') as f:
             f.write("Zone\tType\tColonne\tFacteur\tLag\n")
             for cur in self.infiltrations:
                 idx, type_name, col_name, factor, lag = cur.index, cur.type.value, cur.colref, cur.factor, cur.lagtime
@@ -1232,5 +1335,5 @@ class Coupling_Hydrology_2D():
         if self.df_2d is None:
             logging.error("No hydrographs created")
             return
-        
-        self.df_2d.to_csv(dirout / name, sep='\t', decimal='.', encoding='latin1')        
+
+        self.df_2d.to_csv(dirout / name, sep='\t', decimal='.', encoding='latin1')