wolfhece 2.1.23__py3-none-any.whl → 2.1.27__py3-none-any.whl

wolfhece/PyPalette.py

@@ -24,6 +24,7 @@ class wolfpalette(wx.Frame,LinearSegmentedColormap):
     nb:int
     colors:np.array
     colorsflt:np.array
+    colorsuint8:np.array
 
     def __init__(self, parent=None, title=_('Colormap'),w=100,h=500,nseg=1024):
 
@@ -45,17 +46,32 @@ class wolfpalette(wx.Frame,LinearSegmentedColormap):
         LinearSegmentedColormap.__init__(self,'wolf',{},nseg)
         self.set_bounds()
 
+    @property
+    def colormin_uint8(self):
+        return self.colormin.astype(np.uint8)*255
+    
+    @property
+    def colormax_uint8(self):
+        return self.colormax.astype(np.uint8)*255
+
     def get_colors_f32(self):
 
         colors = self.colorsflt[:,:3].astype(np.float32)
 
         return colors
+    
+    def get_colors_uint8(self):
+            
+        colors = self.colorsflt[:,:3].astype(np.uint8) * 255
+
+        return colors
 
     def set_bounds(self):
         self.set_under(tuple(self.colormin))
         self.set_over(tuple(self.colormax))
 
-    def get_rgba(self,x):
+    def get_rgba(self, x:np.ndarray):
+        """Récupération de la couleur en fonction de la valeur x"""
 
         dval=self.values[-1]-self.values[0]
         if dval==0.:
@@ -63,23 +79,24 @@ class wolfpalette(wx.Frame,LinearSegmentedColormap):
         xloc = (x-self.values[0])/dval
 
         if self.interval_cst:
-            rgba = np.ones((xloc.shape[0],xloc.shape[1],4))
+            rgba = np.ones((xloc.shape[0],xloc.shape[1],4), dtype=np.uint8)
 
             ij = np.where(xloc<0.)
-            rgba[ij[0],ij[1]] = self.colormin
+            rgba[ij[0],ij[1]] = self.colormin_uint8
             ij = np.where(xloc>=1.)
-            rgba[ij[0],ij[1]] = self.colormax
+            rgba[ij[0],ij[1]] = self.colormax_uint8
 
             for i in range(self.nb-1):
                 val1 = (self.values[i]-self.values[0])/dval
                 val2 = (self.values[i+1]-self.values[0])/dval
-                c1   = self.colorsflt[i]
+                # c1   = self.colorsflt[i]
+                c1   = self.colorsuint8[i]
                 ij = np.where((xloc>=val1) & (xloc<val2))
                 rgba[ij[0],ij[1]] = c1
 
             return rgba
         else:
-            return self(xloc)
+            return self(xloc, bytes=True)
 
     def export_palette_matplotlib(self,name):
         cmaps = OrderedDict()
@@ -110,7 +127,7 @@ class wolfpalette(wx.Frame,LinearSegmentedColormap):
 
         return self.nb,self.values,self._segmentdata,self.colorsflt
 
-    def distribute_values(self, minval=-99999, maxval=-99999, step=0, wx_permitted=True):
+    def distribute_values(self, minval:float=-99999, maxval:float=-99999, step=0, wx_permitted=True):
         """ Distribution des valeurs de la palette 
         
         :param minval: valeur minimale
@@ -460,8 +477,7 @@ class wolfpalette(wx.Frame,LinearSegmentedColormap):
                     self.colors[curcol,1] = colors[curcol,1]
                     self.colors[curcol,2] = colors[curcol,2]
                     self.colors[curcol,3] = colors[curcol,3]
-
-
+        
         self.fill_segmentdata()
 
     def defaultgray(self):
@@ -469,7 +485,6 @@ class wolfpalette(wx.Frame,LinearSegmentedColormap):
         self.nb=2
         self.values = np.asarray([0.,1.])
         self.colors = np.asarray([[0,0,0,255],[255,255,255,255]],dtype=np.int32)
-        self.colorsflt = np.asarray([[0.,0.,0.,1.],[1.,1.,1.,1.]],dtype=np.float64)
 
         self.fill_segmentdata()
 
@@ -477,6 +492,7 @@ class wolfpalette(wx.Frame,LinearSegmentedColormap):
         """Mise à jour de la palatte de couleurs"""
 
         self.colorsflt = self.colors.astype(float)/255.
+        self.colorsuint8 = self.colors.astype(np.uint8)
 
         dval=self.values[-1]-self.values[0]
 

wolfhece/acceptability/Parallels.py

@@ -0,0 +1,106 @@
+from .func import clip_layer, data_modification, vector_to_raster, compute_vulnerability, match_vulnerability2sim, compute_acceptability, shp_to_raster, Accept_Manager
+import geopandas as gpd
+import multiprocessing
+from functools import partial
+import os
+from pathlib import Path
+
+def parallel_gpd_clip(layer:list[str], 
+                      file_path:str, 
+                      Study_Area:str, 
+                      output_dir:str, 
+                      number_procs:int = 1):
+    """ 
+    Clip the layers to the study area.
+    
+    Process the layers in parallel.
+
+    FIXME: The GPKG driver is it totally parallel compliant?
+
+    :param layer: List of layers to clip
+    :param file_path: The path to the file
+    :param Study_Area: The study area
+    :param output_dir: The output directory where the clipped layers are stored
+    :param number_procs: The number of processors to use
+
+    """
+    file_path = str(file_path)
+    Study_Area = str(Study_Area)
+    output_dir = str(output_dir)
+
+    if number_procs == 1:
+
+        for curlayer in layer:
+            clip_layer(curlayer, file_path, Study_Area, output_dir)
+
+    else:
+        pool = multiprocessing.Pool(processes=number_procs)
+        prod_x=partial(clip_layer,
+                    file_path=file_path,
+                    Study_Area=Study_Area,
+                    output_dir=output_dir)
+        result_list = pool.map(prod_x, layer)
+
+def parallel_v2r(manager:Accept_Manager,
+                 attribute:str, 
+                 pixel:float,
+                 number_procs:int = 1):
+    """ 
+    Convert the vector layers to raster.
+
+    Process the layers in parallel.
+
+    :remark: It is permitted to execute this function in multiprocessing because we write separate files.
+
+    :param manager: The Accept_Manager object
+    :param attribute: The attribute to convert to raster
+    :param pixel: The pixel size of the raster
+    :param number_procs: The number of processors to use
+
+    """
+    
+    attribute = str(attribute)
+    layers = manager.get_layers_in_codevulne()
+
+    if number_procs == 1:
+        for curlayer in layers:
+            vector_to_raster(curlayer, manager, attribute, pixel)
+    else:
+        pool = multiprocessing.Pool(processes=number_procs)
+        prod_x=partial(vector_to_raster,
+                       manager=manager, 
+                       attribute=attribute, 
+                       pixel_size=pixel) 
+        
+        result_list = pool.map(prod_x, layers)
+
+def parallel_datamod(manager:Accept_Manager, 
+                     picc:gpd.GeoDataFrame,
+                     capa:gpd.GeoDataFrame,
+                     number_procs:int = 1):
+    """ 
+    Apply the data modification to the layers.
+
+    Process the layers in parallel.
+
+    :remark: It is permitted to execute this function in multiprocessing because we write separate files.
+
+    :param manager: The Accept_Manager object
+    :param number_procs: The number of processors to use
+
+    """
+    
+    layers = manager.get_layers_in_clipgdb()
+
+    if number_procs == 1:
+        for curlayer in layers:
+            data_modification(curlayer, manager, picc, capa)
+    else:
+        pool = multiprocessing.Pool(processes=number_procs)
+        prod_x=partial(data_modification,
+                          manager=manager,
+                          picc=picc, 
+                          capa=capa) 
+        
+        result_list = pool.map(prod_x, layers)
+

wolfhece/acceptability/__init__.py

@@ -0,0 +1,3 @@
+# from .acceptability import base_data_creation, Vulnerability, acceptability
+#from .Parallels import parallel_gpd_clip, parallel_v2r 
+#from .func gpd_clip, data_modification, vector_to_raster, Comp_Vulnerability, match_vuln_modrec, VulMod, shp_to_raster

wolfhece/acceptability/acceptability.py

@@ -0,0 +1,477 @@
+from .Parallels import parallel_gpd_clip, parallel_v2r, parallel_datamod 
+from .func import data_modification, compute_vulnerability, compute_vulnerability4scenario, match_vulnerability2sim, compute_acceptability, shp_to_raster, Accept_Manager, cleaning_directory, EXTENT, Vulnerability_csv
+
+import pandas as pd
+import os
+from osgeo import gdal
+import fiona
+import glob
+import numpy as np
+import geopandas as gpd
+from pathlib import Path
+import logging
+from tqdm import tqdm
+from enum import Enum
+from pyogrio import read_dataframe
+
+class steps_base_data_creation(Enum):
+    """ 
+    Enum for the steps in the base data creation
+    """
+    CLIP_GDB = 1
+    CLIP_CADASTER = 2
+    CLIP_PICC = 3
+    POINTS2POLYS = 4
+    RASTERIZE_IGN = 5
+    PREPROCESS_VULNCODE = 6
+    DATABASE_TO_RASTER = 7
+
+class steps_vulnerability(Enum):
+    """ 
+    Enum for the steps in the vulnerability computation
+    """
+    CREATE_RASTERS = 1
+    APPLY_MODIFS = 2
+    MATCH_SIMUL = 3
+
+def Base_data_creation(main_dir:str = 'Data', 
+                       Original_gdb:str = 'GT_Resilence_dataRisques202010.gdb', 
+                       Study_area:str = 'Bassin_Vesdre.shp', 
+                       CaPa_Walloon:str = 'Cadastre_Walloon.gpkg', 
+                       PICC_Walloon:str = 'PICC_vDIFF.gdb', 
+                       CE_IGN_top10v:str = 'CE_IGN_TOP10V/CE_IGN_TOP10V.shp',
+                       resolution:float = 1.,
+                       number_procs:int = 8,
+                       steps:list[int] | list[steps_base_data_creation] = [1,2,3,4,5,6,7]):
+    """
+    Create the databse.
+
+    In this step, the following operations are performed:
+        - Clip the original gdb file to the study area
+        - Clip the Cadastre Walloon file to the study area
+        - Clip the PICC Walloon file to the study area
+        - Clip and Rasterize the IGN top10v file
+        - Create the study area database with the vulnerability levels
+
+
+    :param main_dir: The main data directory
+    :param Original_gdb: The original gdb file from SPW - GT Resilience
+    :param Study_area: The study area shapefile -- Data will be clipped to this area
+    :param CaPa_Walloon: The Cadastre Walloon file -- Shapfeile from SPW
+    :param PICC_Walloon: The PICC Walloon file -- Shapefile from SPW
+    :param CE_IGN_top10v: The CE "Cours d'eau" IGN top10v file -- Shapefile from IGN with river layer
+    :param resolution: The output resolution of the raster files
+    :param number_procs: The number of processors to use for parallel processing
+    
+    """
+    LAYER_CABU = "CaBu"
+    LAYER_CAPA = "CaPa"
+    LAYER_BATIEMPRISE = "CONSTR_BATIEMPRISE"
+
+    manager = Accept_Manager(main_dir, 
+                           Study_area,
+                           Original_gdb=Original_gdb,
+                           CaPa_Walloon=CaPa_Walloon,
+                           PICC_Walloon=PICC_Walloon,
+                           CE_IGN_top10v=CE_IGN_top10v)
+
+    if not manager.check_before_database_creation():
+        logging.error("The necessary files are missing - Verify logs for more information")
+        return
+    
+    manager.change_dir()
+    done = []
+
+    if 1 in steps or 6 in steps or steps_base_data_creation.PREPROCESS_VULNCODE in steps or steps_base_data_creation.CLIP_GDB in steps:
+        # Load the vulnerability CSV to get the layers
+        vulnerability_csv = Vulnerability_csv(manager.VULNERABILITY_CSV)
+    
+    if 1 in steps or steps_base_data_creation.CLIP_GDB in steps:
+        # Clean the directory to avoid any conflict
+        # GPKG driver does not overwrite the existing file but adds new layers
+        cleaning_directory(manager.TMP_CLIPGDB)
+
+        # ********************************************************************************************************************
+        # Step 1, Clip Original GDB
+
+        # Clip the GDB file and store it in dirsnames.SA_DATABASE
+        parallel_gpd_clip(vulnerability_csv.get_layers(), manager.ORIGINAL_GDB, manager.SA, manager.TMP_CLIPGDB, number_procs)
+
+        done.append(steps_base_data_creation.CLIP_GDB)
+    
+    if 2 in steps or steps_base_data_creation.CLIP_CADASTER in steps:
+        # ********************************************************************************************************************
+        # Step 2, Clip Cadaster data
+        cleaning_directory(manager.TMP_CADASTER)
+
+        # Only 2 layers are present in the Cadastre Walloon file
+        # Clip the Cadastre Walloon file and store it in dirsnames.SA_CAPA
+        parallel_gpd_clip([LAYER_CABU, LAYER_CAPA], manager.CAPA_WALLOON, manager.SA, manager.TMP_CADASTER, min(2, number_procs))
+
+        done.append(steps_base_data_creation.CLIP_CADASTER)
+
+    if 3 in steps or steps_base_data_creation.CLIP_PICC in steps:
+        # ********************************************************************************************************************
+        # Step 3, Clip PICC data
+        cleaning_directory(manager.TMP_PICC)
+
+        # ONly 1 layer is needed from the PICC Walloon file
+        # Clip the PICC Walloon file and store it in dirsnames.SA_PICC
+        parallel_gpd_clip([LAYER_BATIEMPRISE], manager.PICC_WALLOON, manager.SA, manager.TMP_PICC, min(1, number_procs))
+
+        done.append(steps_base_data_creation.CLIP_PICC)
+	
+    if 4 in steps or steps_base_data_creation.POINTS2POLYS in steps:
+        # ********************************************************************************************************************
+        # Step 4, create database based on changes in report
+
+        cleaning_directory(manager.TMP_WMODIF)
+
+        # PreLoad Picc and CaPa from clipped files
+        Picc:gpd.GeoDataFrame = read_dataframe(str(manager.TMP_PICC / (LAYER_BATIEMPRISE+EXTENT)), layer=LAYER_BATIEMPRISE)
+        CaPa:gpd.GeoDataFrame = read_dataframe(str(manager.TMP_CADASTER / (LAYER_CAPA+EXTENT)), layer=LAYER_CAPA)
+
+        assert Picc.crs == CaPa.crs, "The crs of the two shapefiles are different"
+
+        parallel_datamod(manager=manager, picc=Picc, capa=CaPa, number_procs=number_procs)
+
+        done.append(steps_base_data_creation.POINTS2POLYS)
+
+    if 5 in steps or steps_base_data_creation.RASTERIZE_IGN in steps:
+        # ********************************************************************************************************************
+        # Step 5 : Rasaterize the IGN data "Course d'eau" to get the riverbed mask
+        shp_to_raster(manager.CE_IGN_TOP10V, manager.SA_MASKED_RIVER, resolution)
+
+        done.append(steps_base_data_creation.RASTERIZE_IGN)
+        
+    if 6 in steps or steps_base_data_creation.PREPROCESS_VULNCODE in steps:
+        # ********************************************************************************************************************
+        # Step 6 :  Pre-processing for Vulnerability
+        #           Save the database with vulnerability levels and codes
+        # This database will be rasterized in 'Database_to_raster'
+
+        layers_sa = manager.get_layers_in_wmodif()
+        layers_csv = vulnerability_csv.get_layers()
+        
+        # Search difference between the two lists of layers
+        list_shp = list(set(layers_csv).difference(layers_sa))
+
+        logging.info("Excluded layers due to no features in shapefiles:")
+        logging.info(list_shp)
+
+        not_in_csv = [curlayer for curlayer in layers_sa if curlayer not in layers_csv]
+        if len(not_in_csv) > 0:
+            logging.error("Not treated layers due to no vulnerability level or code:")
+            logging.error(not_in_csv)
+
+        logging.info("STEP1: Saving the database for Vulnerability with attributes Vulne and Code")
+        
+        for curlayer in layers_sa:
+            logging.info(curlayer)
+
+            in_file  = str(manager.TMP_WMODIF    / (curlayer+EXTENT))
+            out_file = str(manager.TMP_CODEVULNE / (curlayer+EXTENT))
+            
+            shp:gpd.GeoDataFrame = gpd.read_file(in_file)
+            
+            nb_lines, _ = shp.shape
+            if nb_lines > 0:
+                shp["Path"]  = curlayer
+                shp["Vulne"] = vulnerability_csv.get_vulnerability_level(curlayer)
+                shp["Code"]  = vulnerability_csv.get_vulnerability_code(curlayer)
+                shp = shp[["geometry", "Path", "Vulne","Code"]]
+                shp.to_file(out_file)
+            else:
+                # Normally, Phase 1 should have removed the empty shapefiles
+                # But, we never know... ;-)
+                logging.warning(f"Empty shapefile {curlayer} in {in_file}")
+
+        done.append(steps_base_data_creation.PREPROCESS_VULNCODE)
+
+    if 7 in steps or steps_base_data_creation.DATABASE_TO_RASTER in steps:
+        # Rasterize the database
+        cleaning_directory(manager.TMP_RASTERS)
+        cleaning_directory(manager.TMP_RASTERS_CODE)
+        cleaning_directory(manager.TMP_RASTERS_VULNE)
+        
+        Database_to_raster(main_dir, Study_area, resolution, number_procs=number_procs)
+
+        done.append(steps_base_data_creation.DATABASE_TO_RASTER)
+
+    manager.restore_dir()
+
+    return done
+
+def Database_to_raster(main_dir:str = 'Data',
+                       Study_area:str = 'Bassin_Vesdre.shp',
+                       resolution:float = 1.,
+                       number_procs:int = 16):
+    """ 
+    Convert the vector database to raster database based on their vulnerability values 
+    
+    Each leyer is converted to a raster file with the vulnerability values
+    and the code values.
+
+    They are stored in the TEMP/DATABASES/*StudyArea*/VULNERABILITY/RASTERS in:
+        - Code
+        - Vulne
+
+    :param main_dir: The main data directory
+    :param Study_area: The study area shapefile
+    :param resolution: The resolution of the output raster files - default is 1 meter
+    :param number_procs: The number of processors to use for parallel processing
+
+    The parallel processing is safe as each layer is processed independently.
+    """
+
+    manager = Accept_Manager(main_dir, Study_area)
+
+    resolution = float(resolution)
+
+    if not manager.check_before_rasterize():
+        logging.error("The necessary files are missing - Verify logs for more information")
+        return
+
+    manager.change_dir()
+
+    logging.info("Convert vectors to raster based on their vulnerability values")
+    
+    attributes = ["Vulne", "Code"]
+    for cur_attrib in attributes:
+        parallel_v2r(manager, cur_attrib, resolution, number_procs)
+
+    manager.restore_dir()
+
+def Vulnerability(main_dir:str = 'Data',
+                  scenario:str = 'Scenario1',
+                  Study_area:str = 'Bassin_Vesdre.shp',
+                  resolution:float = 1.,
+                  steps:list[int] | list[steps_vulnerability] = [1,2,3]):
+    """
+    Compute the vulnerability for the study area and the scenario, if needed.
+
+    The vulnerability is computed in 3 steps:
+        1.  Compute the vulnerability for the study area
+        2.  Compute the vulnerability for the scenario
+        3.  Clip the vulnerability rasters to the simulation area
+
+    During step 3, three matrices are computed and clipped to the simulation area:
+        - Vulnerability
+        - Code
+        - Masked River
+    
+    :param main_dir: The main data directory    
+    :param scenario: The scenario name
+    :param Study_area: The study area shapefile
+    :param resolution: The resolution of the output raster files - default is 1 meter
+    :param steps: The steps to compute the vulnerability - default is [1,2,3]
+
+    To be more rapid, the steps can be computed separately.
+        - [1,2,3] : All steps are computed - Necessary for the first time
+        - [2,3]   : Only the scenario and clipping steps are computed -- Useful for scenario changes
+        - [3]     : Only the clipping step is computed -- Useful if simulation area changes but scenario is the same
+
+    """
+
+    manager = Accept_Manager(main_dir, Study_area, scenario=scenario)
+
+    if not manager.check_before_vulnerability():
+        logging.error("The necessary files are missing - Verify logs for more information")
+        return
+
+    logging.info("Starting VULNERABILITY computations at {} m resolution".format(resolution))
+    
+    manager.change_dir()
+    done = []	
+    
+    if 1 in steps or steps_vulnerability.CREATE_RASTERS in steps:
+        # Step 1 :  Compute the vulnerability rasters for the study area
+        #           The data **will not** be impacted by the scenario modifications
+    
+        logging.info("Generate Vulnerability rasters {}m".format(resolution))
+
+        cleaning_directory(manager.TMP_SCEN_DIR)
+
+        compute_vulnerability(manager)
+
+        done.append(steps_vulnerability.CREATE_RASTERS)
+
+    if 2 in steps or steps_vulnerability.APPLY_MODIFS in steps:
+        # Step 2 :  Compute the vulnerability rasters for the scenario
+        #           The data **will be** impacted by the scenario modifications  
+
+        if not manager.check_vuln_code_sa():
+            logging.error("The vulnerability and code files for the study area are missing")
+            logging.warning("Force the computation even if not prescribed in the steps")
+
+            Vulnerability(main_dir, scenario, Study_area, resolution, [1])
+
+        bu:list[Path] = manager.get_files_in_rm_buildings()
+
+        if len(bu)>0:
+            for curfile in bu:
+                tiff_file = manager.TMP_RM_BUILD_DIR / (curfile.stem + ".tiff")
+                shp_to_raster(curfile, tiff_file)
+
+            compute_vulnerability4scenario(manager)
+        else:
+            logging.warning(f"No buildings were removed in water depth analysis OR No shapefiles in {manager.IN_RM_BUILD_DIR}")
+
+        done.append(steps_vulnerability.APPLY_MODIFS)
+
+    if 3 in steps or steps_vulnerability.MATCH_SIMUL in steps:
+        # Step 3 :  Clip the vulnerability/code rasters to the **simulation area**
+
+        logging.info("Save Vulnerability files for the area of interest")
+        
+        return_periods = manager.get_return_periods()
+        TMAX = manager.get_filepath_for_return_period(return_periods[-1])
+
+        if TMAX is None:
+            logging.error("The file for the maximum return period is missing")
+            return
+
+        match_vulnerability2sim(manager.SA_MASKED_RIVER,manager.OUT_MASKED_RIVER, TMAX)
+        match_vulnerability2sim(manager.SA_VULN,        manager.OUT_VULN,         TMAX)
+        match_vulnerability2sim(manager.SA_CODE,        manager.OUT_CODE,         TMAX)
+
+        done.append(steps_vulnerability.MATCH_SIMUL)
+
+    manager.restore_dir()
+
+    return done
+
+def Acceptability(main_dir:str = 'Vesdre',
+                  scenario:str = 'Scenario1',
+                  Study_area:str = 'Bassin_Vesdre.shp'):
+    """ Compute acceptability for the scenario """
+    
+    manager = Accept_Manager(main_dir, Study_area, scenario=scenario)
+
+    manager.change_dir()
+
+    # Load the vulnerability raster **for the scenario**
+    vulne = gdal.Open(str(manager.OUT_VULN))
+    # Convert to numpy array
+    vulne = vulne.GetRasterBand(1).ReadAsArray() 
+
+    # Load the river mask
+    riv = gdal.Open(str(manager.OUT_MASKED_RIVER))
+
+    # Get the geotransform and projection for the output tiff
+    geotrans = riv.GetGeoTransform()  
+    proj = riv.GetProjection()  
+
+    # Convert to numpy array
+    riv = riv.GetRasterBand(1).ReadAsArray()    
+
+    # Get the return periods available
+    return_periods = manager.get_return_periods()
+
+    # Prepare the river bed filter
+    # Useful as we iterate over the return periods
+    # and the river bed is the same for all return periods
+    ij_riv = np.where(riv == 1)
+    
+    # Compute acceptability for each return period
+    for curT in tqdm(return_periods):
+
+        # Load the **FILLED** modelled water depth for the return period
+        model_h = gdal.Open(str(manager.get_sim_file_for_return_period(curT)))
+        # Convert to numpy array
+        model_h = model_h.GetRasterBand(1).ReadAsArray()
+
+        # Set nan if the water depth is 0.
+        # 'nan' is a good choice as it will not be considered in the computation.
+        model_h[model_h == 0] = np.nan
+        # Set nan in the river bed
+        model_h[ij_riv] = np.nan
+
+        logging.info("Return period {}".format(curT))
+        # Compute the local acceptability for the return period
+        compute_acceptability(manager, model_h, vulne, curT, (geotrans, proj))
+
+    # At this point, the local acceptability for each return period is computed
+    # and stored in tiff files in the TEMP/SutyArea/scenario/Q_FILES directory
+    
+    # Get the list of Q files
+    qs = manager.get_q_files()
+    # Initialize the dictionary to store the acceptability values
+    q_dict = {}
+
+    # Iterate over the return periods
+    for curT in return_periods:
+        logging.info("vm"+str(curT))
+
+        # We set the filename from the return period, not the "qs" list
+        q_filename = manager.TMP_QFILES / "Q{}.tif".format(curT)
+        
+        # Check if the file exists
+        assert q_filename.exists(), "The file {} does not exist".format(q_filename)
+        # Check if the file is in the "qs" list
+        assert q_filename in qs, "The file {} is not in the list of Q files".format(q_filename)
+
+        # Load the Q file for the return period
+        tmp_data = gdal.Open(str(q_filename))
+        # Convert to numpy array
+        q_dict["vm"+str(curT)] = tmp_data.GetRasterBand(1).ReadAsArray()
+
+        # Force the deletion of the variable, rather than waiting for the garbage collector
+        # May be useful if the files are large
+        del tmp_data
+
+    # Pointing the last return period, maybe 1000 but not always
+    array_t1000 = q_dict["vm{}".format(return_periods[-1])]
+    # Get the indices where the value is -99999
+    # We will force the same mask for all lower return periods
+    ij_t1000 = np.where(array_t1000 == -99999)
+
+    # Iterate over the return periods
+    for curT in return_periods:
+      
+      if curT != return_periods[-1]:
+        logging.info(curT)
+        
+        # Alias
+        tmp_array = q_dict["vm{}".format(curT)]
+        
+        # Set the -99999 values to 0
+        tmp_array[tmp_array == -99999] = 0.
+        # Set the masked values, for the last return period, to nan
+        tmp_array[ij_t1000] = np.nan
+
+    # # Load the ponderation file
+    # pond = pd.read_csv(dirsnames.PONDERATION_CSV)
+    # # Set the index to the interval, so we can use the interval as a key
+    # pond.set_index("Interval", inplace=True)
+
+    # Get ponderations for the return periods
+    pond = manager.get_ponderations()
+
+    assert len(pond) == len(return_periods), "The number of ponderations is not equal to the number of return periods"
+    assert pond["Ponderation"].sum() > 0.999999 and pond["Ponderation"].sum()<1.0000001, "The sum of the ponderations is not equal to 1"
+
+    # Initialize the combined acceptability matrix -- Ponderate mean of the local acceptability
+    comb = np.zeros(q_dict["vm{}".format(return_periods[-1])].shape)
+    
+    for curT in return_periods:
+         comb += q_dict["vm{}".format(curT)] * pond["Ponderation"][curT]
+
+    y_pixels, x_pixels = comb.shape  # number of pixels in x
+
+    # Set up output GeoTIFF
+    driver = gdal.GetDriverByName('GTiff')
+    dataset = driver.Create(str(manager.OUT_ACCEPT), x_pixels, y_pixels, 1, gdal.GDT_Float32, options=["COMPRESS=LZW"])
+    dataset.GetRasterBand(1).WriteArray(comb.astype(np.float32))   
+    dataset.SetGeoTransform(geotrans)
+    dataset.SetProjection(proj)
+    dataset.FlushCache()
+    del(dataset)
+
+    # Resample to 100m
+    Agg = gdal.Warp(str(manager.OUT_ACCEPT_100M), str(manager.OUT_ACCEPT), xRes=100, yRes=100, resampleAlg='Average')
+    del(Agg)
+
+    manager.restore_dir()
+
+    return 0