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

wolfhece/acceptability/acceptability_gui.py

@@ -7,34 +7,32 @@ Copyright (c) 2025 University of Liege. All rights reserved.
 This script and its content are protected by copyright law. Unauthorized
 copying or distribution of this file, via any medium, is strictly prohibited.
 """
-from .acceptability import Base_data_creation, Database_to_raster, Vulnerability, Acceptability
-from .acceptability import steps_base_data_creation, steps_vulnerability, steps_acceptability
-from .func import Accept_Manager
-from ..wolf_array import WolfArray, header_wolf
-from ..scenario.config_manager import Config_Manager_2D_GPU
-from ..PyDraw import WolfMapViewer, draw_type
-from ..Results2DGPU import wolfres2DGPU
-from ..PyGui import MapManager
-
 import wx
-import wx.lib.dialogs
+import numpy as np
 import logging
 import subprocess
-import matplotlib
 import shutil
 import os
 import geopandas as gpd
+import pandas as pd
 import matplotlib.pyplot as plt
 from matplotlib.figure import Figure
 from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg as FigureCanvas
 from matplotlib.backends.backend_wxagg import NavigationToolbar2WxAgg as NavigationToolbar2Wx
 from pathlib import Path
 from scipy.ndimage import label
-import pandas as pd
 from gettext import gettext as _
 import rasterio
 from shapely.geometry import Polygon
-import numpy as np
+
+from .acceptability import Base_data_creation, Database_to_raster, Vulnerability, Acceptability
+from .acceptability import steps_base_data_creation, steps_vulnerability, steps_acceptability
+from .func import Accept_Manager
+from ..wolf_array import WolfArray, header_wolf
+from ..scenario.config_manager import Config_Manager_2D_GPU
+from ..PyDraw import WolfMapViewer, draw_type
+from ..Results2DGPU import wolfres2DGPU
+from ..PyGui import MapManager
 
 def nullvalue_for_hole(WA):
     """
@@ -710,7 +708,7 @@ class AcceptabilityGui(wx.Frame):
                 dlg.ShowModal()
             return
         else :
-            if (self._manager._study_area == None) or (self._manager._scenario == None):
+            if (self._manager._study_area is None) or (self._manager._scenario is None):
                 logging.error(f"No study area and/or scenario selected, no check of TEMP and OUTPUT.")
                 with wx.MessageDialog(self, f"INPUT is well structured, but TEMP and OUTPUT have not been checked because there is no study area and scenario selected.", "Checking", wx.OK | wx.ICON_INFORMATION) as dlg:
                         dlg.ShowModal()
@@ -1075,7 +1073,8 @@ class AcceptabilityGui(wx.Frame):
         return
 
     def OnInterpolation(self,e):
-        """Interpolates the last extracted time steps present in LAST_STEP_EXTRACTED using the fast marching
+        """Interpolates the last extracted time steps present in
+        LAST_STEP_EXTRACTED using the fast marching
         interpolation routine holes.exe, by creating a batch file
         while performing multiple checks on the required input files."""
         if not hasattr(self, 'file_paths'):
@@ -1121,7 +1120,7 @@ class AcceptabilityGui(wx.Frame):
                     D = file_path
                 else:
                     C = file_path
-        if D == None:
+        if D is None:
             logging.info("DEM (.bin) not found in DEM_FILES. The file must begins by 'MNT_' and CANNOT include the word 'mask'")
             with wx.MessageDialog(self,
                         f"DEM (.bin) not found in DEM_FILES. The file must begins by 'MNT_' and CANNOT include the word 'mask'",
@@ -1130,7 +1129,7 @@ class AcceptabilityGui(wx.Frame):
                 dlg.ShowModal()
             return
 
-        if C == None:
+        if C is None:
             logging.info("DEM mask (.bin) not found in DEM_FILES. The file must begins by 'MNT_' and MUST include the word 'mask'")
             with wx.MessageDialog(self,
                         f"DEM mask (.bin) not found in DEM_FILES. The file must begins by 'MNT_' and MUST include the word 'mask'",
@@ -1189,7 +1188,19 @@ class AcceptabilityGui(wx.Frame):
 
             empty_folder(self._manager.IN_SA_INTERP)
             path_bat_file = os.path.join(self._manager.IN_SCEN_DIR, "process_files.bat")
-            subprocess.run([path_bat_file], check=True)
+
+            if True:
+                # FORTRAN HOLES.EXE
+                subprocess.run([path_bat_file], check=True)
+            else:
+                #Python eikonal model
+                from ..eikonal import inpaint_array, inpaint_waterlevel
+                for a, b in zip(A, B):
+                    in_wa = WolfArray(a)
+                    mask_wa = WolfArray(C)
+                    dem_wa = WolfArray(D)
+                    inpaint_array(in_wa.array, mask_wa.array, dem_wa.array, avoid_last=1)
+                    in_wa.write_all(b)
 
             renamed_files = []
             path_fichier=self._manager.IN_SA_INTERP

wolfhece/acceptability/func.py

@@ -287,14 +287,14 @@ class Accept_Manager():
 
             self.scenario:str       = str(self._scenario)
 
-            
+
             self.IN_SA_BASE         = self.IN_WATER_DEPTH / self.SA.stem / "Scenario_baseline"
             self.IN_SA_BASE_INTERP  = self.IN_SA_BASE / "INTERP_WD"
-            
+
             self.IN_SCEN_DIR        = self.IN_WATER_DEPTH / self.SA.stem / self.scenario
             self.IN_SA_INTERP       = self.IN_SCEN_DIR / "INTERP_WD"
             self.IN_SA_EXTRACTED    = self.IN_SCEN_DIR / "EXTRACTED_LAST_STEP_WD"
-            self.IN_SA_DEM          = self.IN_SCEN_DIR / "DEM_FILES"            
+            self.IN_SA_DEM          = self.IN_SCEN_DIR / "DEM_FILES"
             self.IN_CH_SA_SC        = self.IN_CH_VULN /self.SA.stem  / self.scenario
             self.IN_CH_SA_SC_MNT_VRT = self.IN_CH_SA_SC / "__MNT_assembly.vrt"
             self.IN_CH_SA_SC_MNT_tif = self.IN_CH_SA_SC / "MNTassembly"
@@ -312,19 +312,19 @@ class Accept_Manager():
 
             self.OUT_WITHVULN       = self.OUT_SCEN_DIR / "vuln_ scenarios"
             self.OUT_VULN_VRT       = self.OUT_WITHVULN / "__vuln_assembly.vrt"
-            self.OUT_VULN_S         = self.OUT_WITHVULN / "Vulnerability_scenarios" 
+            self.OUT_VULN_S         = self.OUT_WITHVULN / "Vulnerability_scenarios"
             self.OUT_VULN_Stif      = self.OUT_WITHVULN / "Vulnerability_scenarios.tif"
             self.OUT_MASKED_RIVER_S = self.OUT_WITHVULN / "Masked_River_extent_scenarios.tiff"
             self.OUT_ACCEPT_Stif           = self.OUT_WITHVULN / "Acceptability_scenarios.tiff"
             self.OUT_ACCEPT_RESAMP_Stif    = self.OUT_WITHVULN / "Acceptability_scenarios_resampled.tiff"
-            
+
             self.OUT_BASELINE       = self.OUT_SCEN_DIR / "baseline"
             self.OUT_VULN           = self.OUT_BASELINE / "Vulnerability_baseline.tiff"
             self.OUT_CODE           = self.OUT_BASELINE / "Vulnerability_Code_baseline.tiff"
             self.OUT_MASKED_RIVER   = self.OUT_BASELINE / "Masked_River_extent_baseline.tiff"
             self.OUT_ACCEPT         = self.OUT_BASELINE / "Acceptability_baseline.tiff"
             self.OUT_ACCEPT_RESAMP  = self.OUT_BASELINE / "Acceptability_baseline_resampled.tiff"
-            
+
         else:
             self.scenario = None
 
@@ -472,7 +472,7 @@ class Accept_Manager():
         sims = self.get_sims_files_for_scenario()
 
         if len(sims)==0:
-            logging.info("No simulations found at this stage") 
+            logging.info("No simulations found at this stage")
             return None
 
         if "_h.tif" in sims[0].name:
@@ -561,7 +561,7 @@ class Accept_Manager():
             os.path.join(os.path.dirname(path), os.path.basename(path).replace("Q", "T"))
             for path in sims
             ]
-        
+
         if len(sims)==0:
             logging.info("No simulations found at this stage.")
             return []
@@ -570,22 +570,22 @@ class Accept_Manager():
         # searching for the position of the return period in the name
         idx_T = [Path(cursim).name.find("T") for cursim in sims_modif]
         idx_h = [Path(cursim).name.find(".tif") for cursim in sims_modif]
-        
+
         # create the list of return periods -- only the numeric part
         sims = [int(Path(cursim).name[idx_T[i]+1:idx_h[i]]) for i, cursim in enumerate(sims_modif)]
         return sorted(sims)
-    
+
     def get_modifiedrasters(self):
         folder = Path(self.IN_CH_SA_SC)
         vuln_tiff_files = [str(file.name) for file in folder.rglob("*.tiff") if file.name.startswith('vuln_')]
         vuln_tif_files = [str(file.name)for file in folder.rglob("*.tif") if file.name.startswith('vuln_')]
-        vuln_files = vuln_tiff_files + vuln_tif_files  
+        vuln_files = vuln_tiff_files + vuln_tif_files
 
         folder = Path(self.IN_CH_SA_SC)
         mnt_tiff_files = [str(file.name) for file in folder.rglob("*.tiff") if file.name.startswith('MNTmodifs_')]
         mnt_tif_files = [str(file.name) for file in folder.rglob("*.tif") if file.name.startswith('MNTmodifs_')]
         mnt_files = mnt_tiff_files + mnt_tif_files
-        
+
         return vuln_files + mnt_files
 
     def get_ponderations(self) -> pd.DataFrame:
@@ -732,7 +732,7 @@ class Accept_Manager():
             self.OUT_SCEN_DIR.mkdir(parents=True, exist_ok=True)
             self.OUT_WITHVULN.mkdir(parents=True, exist_ok=True)
             self.OUT_BASELINE.mkdir(parents=True, exist_ok=True)
-            
+
 
         return True
 
@@ -898,15 +898,15 @@ class Accept_Manager():
 
         if len(code) == 0:
             logging.error("The code rasters do not exist")
-            return False
+            return ["The code rasters do not exist"]
 
         if len(vuln) == 0:
             logging.error("The vulnerability rasters do not exist")
-            return False
+            return ["The vulnerability rasters do not exist"]
 
         if len(code) != len(vuln):
             logging.error("The number of code and vulnerability rasters do not match")
-            return False
+            return ["The number of code and vulnerability rasters do not match"]
 
         # we take a reference raster
         ref = gdal.Open(str(code[0]))
@@ -1026,7 +1026,7 @@ class Accept_Manager():
             dataset = None
 
         logging.info("All the existing .tif files have been copied to the destination directory.")
-    
+
     def wich_river_trace(self):
         """ Searches for existing riverbed traces: if none ending with '_scenarios' are found, it selects the baseline trace."""
         trace = None
@@ -1037,8 +1037,8 @@ class Accept_Manager():
         else :
             logging.error("No Masked_River_extent files. Please provide them.")
         return trace
-        
-        
+
+
 
 
 def clip_layer(layer:str,
@@ -1503,7 +1503,7 @@ def match_vulnerability2sim(inRas:Path, outRas:Path, MODREC:Path):
     :param MODREC: the MODREC/simulation extent file
 
     """
-    
+
     inRas  = str(inRas)
     outRas = str(outRas)
     MODREC = str(MODREC)
@@ -1524,7 +1524,7 @@ def update_accept(accept, model_h, ij, bounds, loc_accept):
     for idx in range(len(bounds)):
         for i,j in ij:
             #lit dans wd vs Ti où on est et associe son score d'accept
-            if bounds[idx,0] < model_h[i,j] <= bounds[idx,1]: 
+            if bounds[idx,0] < model_h[i,j] <= bounds[idx,1]:
                 accept[i,j] = loc_accept[idx]
 
 def compute_acceptability(manager:Accept_Manager,
@@ -1666,6 +1666,8 @@ def shp_to_raster(vector_fn:str | Path, raster_fn:str | Path, pixel_size:float =
                         layer = source_layer,
                         burn_values = [1],
                         options=["ALL_TOUCHED=TRUE"])
+
+    target_ds.FlushCache()
     target_ds = None
     vector_fn = raster_fn = None
 

wolfhece/apps/version.py

@@ -4,8 +4,8 @@ class WolfVersion():
     def __init__(self):
 
         self.major = 2
-        self.minor = 1
-        self.patch = 128
+        self.minor = 2
+        self.patch = 1
 
     def __str__(self):
 

wolfhece/eikonal.py

@@ -78,7 +78,7 @@ def __solve_eikonal_with_data(sources:list[list[int,int]],
     # store the fixed points
     #  - fix sources points
     #  - fix every first element of the heap after pop
-    fixed = np.zeros(speed.shape, dtype = np.bool8)
+    fixed = np.zeros(speed.shape, dtype = np.uint8)
 
     # fix the border
     fixed[:, 0] = True

wolfhece/hydrology/Catchment.py

@@ -33,8 +33,8 @@ else:
     print(_('Note: do not forget to install the graphviz app and add it to the PATH to make it work'))
 # --------------------------------
 
-from ..wolf_texture import genericImagetexture
-from ..PyDraw import WolfMapViewer
+# from ..wolf_texture import genericImagetexture
+# from ..PyDraw import WolfMapViewer
 from .SubBasin import *
 from .RetentionBasin import *
 from .read import *
@@ -67,7 +67,8 @@ class Catchment:
     iP_Cloud:cloud_vertices                                                 # cloud of points containing the given coordinates (given in param files) of all subbasin outlets
 
     catchmentDict:dict[Union[str, int], Union[SubBasin, RetentionBasin]]    # dictionnary containing all the elements of the catchment
-    subBasinDict:dict[int, SubBasin]                                        # dictionnary containing all the subbasins
+    subBasinDict:dict[int, SubBasin]                                        # dictionnary containing all the subbasins with the convention dict{ID Interior Point : SubBasin object}
+    retentionBasinDict:dict[str, RetentionBasin]                            # dictionnary containing all the anthropogenic modules
 
     def __init__(self, _name, _workingDir, _plotAllSub, _plotNothing, _initWithResults=True, _catchmentFileName="", _rbFileName="", _tz=0, version=cst.VERSION_WOLFHYDRO):
         "This is the constructor of the class Catchment in which all the caractertics and the network of sub-basins will be created"
@@ -1390,6 +1391,75 @@ class Catchment:
         writer.close()
 
 
+
+    def save_hydro_for_2D(self, fileName:str="Hydros_2_simul2D.txt", directory:str="", format:str='%1.5e'):
+        """
+        Procedure that saves the data in an text file that can be read and used in a 2D model.
+
+        Args:
+            fileName (str, optional): The name of the file to save the data to. Defaults to "Hydros_2_simul2D.txt".
+            directory (str, optional): The directory to save the file in. Defaults to an empty string.
+
+        Returns:
+            None
+        """
+        # Writes subbasins' hydrographs
+        if(directory==""):
+            directory = join(self.workingDir,"PostProcess")
+
+        cur_file = join(directory,fileName)
+        time = np.reshape(self.time - self.time[0],(len(self.time),1))
+        # Extract the data for the hydrological and anthropogenic modules
+        data_subs = [cur_sub.outFlow for cur_sub in sorted(self.subBasinDict.values(), key=lambda sub: sub.iDSorted)]
+        data_anth = [cur_anth.get_outFlow(whichOutFlow=name) for cur_anth in self.retentionBasinDict.values() for name in cur_anth.get_outFlow_names()]
+        # Extract the column names according to their sorted subbasin indices
+        col_time = ["Time [s]"]
+        col_subs = [cur_sub.name for cur_sub in sorted(self.subBasinDict.values(), key=lambda sub: sub.iDSorted)]
+        col_anth = [" : ".join([cur_anth.name, name]) 
+                    for cur_anth in self.retentionBasinDict.values() 
+                    for name in cur_anth.get_outFlow_names()]
+        
+        
+        all_data = np.concatenate((time, np.array(data_subs).T, np.array(data_anth).T), axis=1)
+        all_columns = "\t".join(col_time+col_subs+col_anth)
+        
+        # Save the data in a text file
+        np.savetxt(cur_file, all_data, delimiter='\t', newline="\n", header=all_columns, fmt=format)
+
+
+    def save_own_hydro_for_2D(self, fileName:str="HydrosSub_2_simul2D.txt", directory:str="", format:str='%1.5e'):
+        """
+        Saves subbasins' hydrographs from their own drained surface only (not taking into account the 
+        surface drained by the inlets or upstream elements) to a text file that can be read and used in a 2D model.
+
+        Args:
+            fileName (str, optional): Name of the output file. Defaults to "HydrosSub_2_simul2D.txt".
+            directory (str, optional): Directory where the file will be saved. Defaults to an empty string.
+            format (str, optional): Format string for the data values. Defaults to '%1.5e'.
+
+        Returns:
+            None
+        """
+        # Writes subbasins' hydrographs
+        if(directory==""):
+            directory = join(self.workingDir,"PostProcess")
+
+        cur_file = join(directory,fileName)
+        time = np.reshape(self.time - self.time[0],(len(self.time),1))
+        # Extract the data for the hydrological and anthropogenic modules
+        data_subs = [cur_sub.get_myHydro(unit="m3/s") for cur_sub in sorted(self.subBasinDict.values(), key=lambda sub: sub.iDSorted)]
+        # Extract the column names according to their sorted subbasin indices
+        col_time = ["Time [s]"]
+        col_subs = [cur_sub.name for cur_sub in sorted(self.subBasinDict.values(), key=lambda sub: sub.iDSorted)]
+        
+        
+        all_data = np.concatenate((time, np.array(data_subs).T), axis=1)
+        all_columns = "\t".join(col_time+col_subs)
+        
+        # Save the data in a text file
+        np.savetxt(cur_file, all_data, delimiter='\t', newline="\n", header=all_columns, fmt=format)
+
+
     def save_characteristics(self):
         "Procedure that saves the data in an Excel file."
         # Writes subbasins' main characteristics
@@ -1857,8 +1927,8 @@ class Catchment:
                 # paramsInput.ApplytoMemory(None)
                 paramsInput.SavetoFile(None)
 
-
-    def _correct_Umax_from_old_model(self, adapt_with_rain:bool=True):
+    
+    def _correct_Umax_from_old_model(self, adapt_with_rain:bool=True, k_opt:float=0.0, U_max_opt=0.0):
         fileName = "simul_soil.param"
         which="Umax"
 
@@ -1870,8 +1940,10 @@ class Catchment:
 
             paramsInput = Wolf_Param(to_read=False,toShow=False)
             paramsInput.ReadFile(fileToModif)
-
-            if adapt_with_rain:
+            
+            if U_max_opt>0.0:
+                maxRain = U_max_opt
+            elif adapt_with_rain:
                 myInterval = paramsInput.get_param("Distributed production model parameters", "Time span soil", default_value=0.0)
                 if myInterval==0.0:
                     nbIntervals = len(myBasin.myRain)-1
@@ -1885,10 +1957,13 @@ class Catchment:
                 if maxRain==0.0:
                     logging.warning("The Umax is not adapted with the rain and its value is 0.0. It might be better to put 'adapt_with_rain' to True.")
 
-            k = paramsInput.get_param("Horton parameters", "k", default_value=0.0)
-            if k==0.0:
-                continue
-
+            if k_opt==0.0:
+                k = paramsInput.get_param("Horton parameters", "k", default_value=0.0)
+                if k==0.0:
+                    continue
+            else:
+                k = k_opt
+            
             U_max = maxRain/k
 
             paramsInput.change_param("Distributed production model parameters", which, U_max)
@@ -1899,7 +1974,7 @@ class Catchment:
 
 
 
-    def plot_all_diff_cumulRain_with_lagtime(self, interval, lagTime, selection_by_iD=[], graph_title="", show=True, writeDir="", lawNetRain=0, netRainParams={}):
+    def plot_all_diff_cumulRain_with_lagtime(self, interval=0, lagTime=0, selection_by_iD=[], graph_title="", show=True, writeDir="", lawNetRain=0, netRainParams={}):
         """
 
         """
@@ -2835,6 +2910,32 @@ class Catchment:
         self._set_temporal_parameters(value)
 
 
+    def _set_IC_qif(self, keys:list[str], values:np.ndarray):
+        assert len(keys) == len(values), "The number of keys should be equal to the number of values !"
+        # assert len(keys) == len(self.subBasinDict), "The number of keys should be equal to the number of sub-basins !"
+        # assert len(values) == len(self.subBasinDict), "The number of values should be equal to the number of sub-basins !"
+        fileName = "simul_if.param"
+        group = "Initial conditions"
+        key = "Outflow"
+
+        for iBasin in range(1,len(self.subBasinDict)+1):
+            if self.subBasinDict[iBasin].name in keys:
+                index = np.where(np.array(keys) == self.subBasinDict[iBasin].name)[0][0]
+            else:
+                logging.warning(f"The sub-basin {self.subBasinDict[iBasin].name} is not in the keys list !")
+                continue
+            myBasin = self.subBasinDict[iBasin]
+            dirID = myBasin.iDSorted
+
+            fileToModif = os.path.join(self.workingDir, "Subbasin_" + str(dirID), fileName)
+
+            paramsInput = Wolf_Param(to_read=False,toShow=False)
+            paramsInput.ReadFile(fileToModif)
+            paramsInput.change_param(group, key, values[index])
+            paramsInput.SavetoFile(None)
+            paramsInput.Reload(None)
+        
+
     def make_nd_array(self, c_pointer, shape, dtype=np.float64, order='C', own_data=True,readonly=False):
         arr_size = np.prod(shape[:]) * np.dtype(dtype).itemsize