wolfhece 2.1.25__py3-none-any.whl → 2.1.28__py3-none-any.whl

wolfhece/acceptability/acceptability.py

@@ -1,5 +1,7 @@
-from .Parallels import parallel_gpd_clip, parallel_v2r 
-from .func import data_modification, Comp_Vulnerability, Comp_Vulnerability_Scen, match_vuln_modrec, VulMod, shp_to_raster, Accept_Manager, cleaning_directory
+from .Parallels import parallel_gpd_clip, parallel_v2r, parallel_datamod 
+from .func import data_modification, compute_vulnerability, compute_vulnerability4scenario
+from .func import match_vulnerability2sim, compute_acceptability, shp_to_raster
+from .func import Accept_Manager, cleaning_directory, EXTENT, Vulnerability_csv, compute_code
 
 import pandas as pd
 import os
@@ -11,26 +13,30 @@ import geopandas as gpd
 from pathlib import Path
 import logging
 from tqdm import tqdm
+from enum import Enum
+from pyogrio import read_dataframe
 
-
-
-
-class Vulnerability_csv():
-
-    def __init__(self, file:Path) -> None:
-        self.file = file
-        self.data = pd.read_csv(file, sep=",", encoding='latin-1')
-
-    def get_layers(self) -> list:
-        return [a[1] for a in self.data["Path"].str.split('/')]
-    
-    def get_vulnerability_level(self, layer:str) -> str:
-        idx = self.get_layers().index(layer)
-        return self.data.iloc[idx]["Vulne"]
-    
-    def get_vulnerability_code(self, layer:str) -> str:
-        idx = self.get_layers().index(layer)
-        return self.data.iloc[idx]["Code"]
+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
+    CREATE_RASTERS_VULN = 10
+    CREATE_RASTERS_CODE = 11
+    APPLY_MODIFS = 2
+    MATCH_SIMUL = 3
 
 def Base_data_creation(main_dir:str = 'Data', 
                        Original_gdb:str = 'GT_Resilence_dataRisques202010.gdb', 
@@ -39,7 +45,9 @@ def Base_data_creation(main_dir:str = 'Data',
                        PICC_Walloon:str = 'PICC_vDIFF.gdb', 
                        CE_IGN_top10v:str = 'CE_IGN_TOP10V/CE_IGN_TOP10V.shp',
                        resolution:float = 1.,
-                       number_procs:int = 8):
+                       number_procs:int = 8,
+                       steps:list[int] | list[steps_base_data_creation] = [1,2,3,4,5,6,7],
+                       Vulnerability_csv:str = 'Vulnerability.csv'):
     """
     Create the databse.
 
@@ -61,109 +69,158 @@ def Base_data_creation(main_dir:str = 'Data',
     :param number_procs: The number of processors to use for parallel processing
     
     """
-    NUMBER_PROCS = number_procs
+    LAYER_CABU = "CaBu"
+    LAYER_CAPA = "CaPa"
+    LAYER_BATIEMPRISE = "CONSTR_BATIEMPRISE"
 
-    dirsnames = Accept_Manager(main_dir, 
+    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)
+                           CE_IGN_top10v=CE_IGN_top10v,
+                           Vulnerability_csv=Vulnerability_csv)
 
-    if not dirsnames.check_before_database_creation():
+    if not manager.check_before_database_creation():
         logging.error("The necessary files are missing - Verify logs for more information")
         return
     
-    dirsnames.change_dir()
+    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)
     
-    # Clean the directory to avoid any conflict
-    # GPKG driver does not overwrite the existing file but adds new layers
-    cleaning_directory(dirsnames.TMP_STUDYAREA)
+    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
+        # ********************************************************************************************************************
+        # Step 1, Clip Original GDB
 
-    # Load the vulnerability CSV to get the layers
-    vulnerability_csv = Vulnerability_csv(dirsnames.VULNERABILITY_CSV)
-    # Clip the GDB file and store it in dirsnames.SA_DATABASE
-    parallel_gpd_clip(vulnerability_csv.get_layers(), dirsnames.ORIGINAL_GDB, dirsnames.SA, dirsnames.SA_DATABASE, NUMBER_PROCS)
+        # 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)
     
-    # ********************************************************************************************************************
-    # Step 2, Clip Cadaster data
+    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
-    LAYER_CABU = "CaBu"
-    LAYER_CAPA = "CaPa"
-    # Clip the Cadastre Walloon file and store it in dirsnames.SA_CAPA
-    parallel_gpd_clip([LAYER_CABU, LAYER_CAPA], dirsnames.CAPA_WALLOON, dirsnames.SA, dirsnames.SA_CAPA, min(2, NUMBER_PROCS))
+        # 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))
 
-    # ********************************************************************************************************************
-    # Step 3, Clip PICC data
+        done.append(steps_base_data_creation.CLIP_CADASTER)
 
-    # ONly 1 layer is needed from the PICC Walloon file
-    LAYER_BATIEMPRISE = "CONSTR_BATIEMPRISE"
-    # Clip the PICC Walloon file and store it in dirsnames.SA_PICC
-    parallel_gpd_clip([LAYER_BATIEMPRISE], dirsnames.PICC_WALLOON, dirsnames.SA, dirsnames.SA_PICC, min(1, NUMBER_PROCS))
+    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)
 	
-    # ********************************************************************************************************************
-    # Step 4, create database based on changes in report
+    if 4 in steps or steps_base_data_creation.POINTS2POLYS in steps:
+        # ********************************************************************************************************************
+        # Step 4, create database based on changes in report
 
-    layers = fiona.listlayers(dirsnames.SA_DATABASE)
-    # PreLoad Picc and CaPa from clipped files
-    Picc:gpd.GeoDataFrame = gpd.read_file(dirsnames.SA_PICC, layer = LAYER_BATIEMPRISE)
-    CaPa:gpd.GeoDataFrame = gpd.read_file(dirsnames.SA_CAPA, layer = LAYER_CAPA)
+        cleaning_directory(manager.TMP_WMODIF)
 
-    assert Picc.crs == CaPa.crs, "The crs of the two shapefiles are different"
+        # 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)
 
-    for curlayer in tqdm(layers, desc="Vulnerability : Processing layers"):
-        data_modification(dirsnames.SA_DATABASE, curlayer, dirsnames.SA_FINAL, Picc, CaPa)
+        assert Picc.crs == CaPa.crs, "The crs of the two shapefiles are different"
 
-    # ********************************************************************************************************************
-    # Step 5 : Rasaterize the IGN data "Course d'eau" to get the riverbed mask
-    shp_to_raster(dirsnames.CE_IGN_TOP10V, dirsnames.SA_MASKED_RIVER, resolution)
-    
-    # ********************************************************************************************************************
-    # Step 6 :  Pre-processing for Vulnerability
-    #           Save the database with vulnerability levels and codes
-    # This database will be rasterized in 'Database_to_raster'
+        parallel_datamod(manager=manager, picc=Picc, capa=CaPa, number_procs=number_procs)
 
-    layers_sa = fiona.listlayers(dirsnames.SA_FINAL)
-    layers_csv = vulnerability_csv.get_layers()
-    
-    # Search difference between the two lists of layers
-    list_shp = list(set(layers_csv).difference(layers_sa))
+        done.append(steps_base_data_creation.POINTS2POLYS)
 
-    logging.info("Excluded layers due to no features in shapefiles:")
-    logging.info(list_shp)
+    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)
 
-    logging.info("STEP1: Saving the database for Vulnerability with attributes Vulne and Code")
-    
-    for curlayer in layers_sa:
-        logging.info(curlayer)
+        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)
 
-        shp:gpd.GeoDataFrame = gpd.read_file(dirsnames.SA_FINAL, layer=curlayer)
+        logging.info("STEP1: Saving the database for Vulnerability with attributes Vulne and Code")
         
-        x, y = shp.shape
-        if x > 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(dirsnames.SA_FINAL_V, layer=curlayer)
-    
-    # Rasterize the database
-    Database_to_raster(main_dir, Study_area, resolution)
+        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,
+                           Vulnerability_csv=Vulnerability_csv)
 
-    dirsnames.restore_dir()
+        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):
+                       number_procs:int = 16,
+                       Vulnerability_csv:str = 'Vulnerability.csv'):
     """ 
     Convert the vector database to raster database based on their vulnerability values 
     
-    Ecah leyer is converted to a raster file with the 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:
@@ -175,33 +232,34 @@ def Database_to_raster(main_dir:str = 'Data',
     :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 parellel processing is safe as each layer is processed independently.
+    The parallel processing is safe as each layer is processed independently.
     """
 
-    dirsnames = Accept_Manager(main_dir, Study_area)
+    manager = Accept_Manager(main_dir, Study_area, Vulnerability_csv=Vulnerability_csv)
 
     resolution = float(resolution)
 
-    if not dirsnames.check_before_rasterize():
+    if not manager.check_before_rasterize():
         logging.error("The necessary files are missing - Verify logs for more information")
         return
 
-    dirsnames.change_dir()
+    manager.change_dir()
 
     logging.info("Convert vectors to raster based on their vulnerability values")
-    layers = fiona.listlayers(dirsnames.SA_FINAL_V)
     
     attributes = ["Vulne", "Code"]
     for cur_attrib in attributes:
-        parallel_v2r(layers, dirsnames.SA_FINAL_V, dirsnames.SA, cur_attrib, resolution, number_procs)
+        parallel_v2r(manager, cur_attrib, resolution, number_procs, convert_to_sparse=True)
 
-    dirsnames.restore_dir()
+    manager.restore_dir()
 
 def Vulnerability(main_dir:str = 'Data',
                   scenario:str = 'Scenario1',
                   Study_area:str = 'Bassin_Vesdre.shp',
                   resolution:float = 1.,
-                  steps:list[int] = [1,2,3]):
+                  steps:list[int] | list[steps_vulnerability] = [1,10,11,2,3],
+                  Vulnerability_csv:str = 'Vulnerability.csv',
+                  Intermediate_csv:str = 'Intermediate.csv'):
     """
     Compute the vulnerability for the study area and the scenario, if needed.
 
@@ -228,81 +286,105 @@ def Vulnerability(main_dir:str = 'Data',
 
     """
 
-    dirsnames = Accept_Manager(main_dir, Study_area, scenario=scenario)
+    manager = Accept_Manager(main_dir, 
+                             Study_area, 
+                             scenario=scenario, 
+                             Vulnerability_csv=Vulnerability_csv,
+                             Intermediate_csv=Intermediate_csv)
 
-    if not dirsnames.check_before_vulnerability():
+    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))
     
-    dirsnames.change_dir()
+    manager.change_dir()
+    done = []	
     
-    if 1 in steps:
+    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(dirsnames.TMP_SCEN_DIR)
+        cleaning_directory(manager.TMP_SCEN_DIR)
 
-        Comp_Vulnerability(dirsnames)
+        if 10 in steps or steps_vulnerability.CREATE_RASTERS_VULN in steps:
+            compute_vulnerability(manager)
+            done.append(steps_vulnerability.CREATE_RASTERS_VULN)
+        
+        if 11 in steps or steps_vulnerability.CREATE_RASTERS_CODE in steps:
+            compute_code(manager)
+            done.append(steps_vulnerability.CREATE_RASTERS_CODE)
 
-    if 2 in steps:
+        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 dirsnames.check_vuln_code_sa():
+        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] = dirsnames.get_files_in_rm_buildings()
+        bu:list[Path] = manager.get_files_in_rm_buildings()
 
         if len(bu)>0:
             for curfile in bu:
-                tiff_file = dirsnames.TMP_RM_BUILD_DIR / (curfile.stem + ".tiff")
+                tiff_file = manager.TMP_RM_BUILD_DIR / (curfile.stem + ".tiff")
                 shp_to_raster(curfile, tiff_file)
 
-            Comp_Vulnerability_Scen(dirsnames)
+            compute_vulnerability4scenario(manager)
         else:
-            logging.warning(f"No buildings were removed in water depth analysis OR No shapefiles in {dirsnames.IN_RM_BUILD_DIR}")
+            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:
+    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 = dirsnames.get_return_periods()
-        TMAX = dirsnames.get_filepath_for_return_period(return_periods[-1])
+        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_vuln_modrec(dirsnames.SA_MASKED_RIVER,dirsnames.OUT_MASKED_RIVER, TMAX)
-        match_vuln_modrec(dirsnames.SA_VULN,        dirsnames.OUT_VULN,         TMAX)
-        match_vuln_modrec(dirsnames.SA_CODE,        dirsnames.OUT_CODE,         TMAX)
+        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)
 
-    dirsnames.restore_dir()
+        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'):
+                  Study_area:str = 'Bassin_Vesdre.shp',
+                  coeff_auto:bool = True,
+                  Ponderation_csv:str = 'Ponderation.csv'):
     """ Compute acceptability for the scenario """
     
-    dirsnames = Accept_Manager(main_dir, Study_area, scenario=scenario)
+    manager = Accept_Manager(main_dir, 
+                             Study_area, 
+                             scenario=scenario,
+                             Ponderation_csv=Ponderation_csv)
 
-    dirsnames.change_dir()
+    manager.change_dir()
 
     # Load the vulnerability raster **for the scenario**
-    vulne = gdal.Open(str(dirsnames.OUT_VULN))
+    vulne = gdal.Open(str(manager.OUT_VULN))
     # Convert to numpy array
     vulne = vulne.GetRasterBand(1).ReadAsArray() 
 
     # Load the river mask
-    riv = gdal.Open(str(dirsnames.OUT_MASKED_RIVER))
+    riv = gdal.Open(str(manager.OUT_MASKED_RIVER))
 
     # Get the geotransform and projection for the output tiff
     geotrans = riv.GetGeoTransform()  
@@ -312,7 +394,7 @@ def Acceptability(main_dir:str = 'Vesdre',
     riv = riv.GetRasterBand(1).ReadAsArray()    
 
     # Get the return periods available
-    return_periods = dirsnames.get_return_periods()
+    return_periods = manager.get_return_periods()
 
     # Prepare the river bed filter
     # Useful as we iterate over the return periods
@@ -323,24 +405,25 @@ def Acceptability(main_dir:str = 'Vesdre',
     for curT in tqdm(return_periods):
 
         # Load the **FILLED** modelled water depth for the return period
-        model_h = gdal.Open(str(dirsnames.get_sim_file_for_return_period(curT)))
+        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
+        # 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
-        VulMod(dirsnames, model_h, vulne, curT, (geotrans, proj))
+        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 = dirsnames.get_q_files()
+    qs = manager.get_q_files()
     # Initialize the dictionary to store the acceptability values
     q_dict = {}
 
@@ -349,7 +432,7 @@ def Acceptability(main_dir:str = 'Vesdre',
         logging.info("vm"+str(curT))
 
         # We set the filename from the return period, not the "qs" list
-        q_filename = dirsnames.TMP_QFILES / "Q{}.tif".format(curT)
+        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)
@@ -391,10 +474,19 @@ def Acceptability(main_dir:str = 'Vesdre',
     # pond.set_index("Interval", inplace=True)
 
     # Get ponderations for the return periods
-    pond = dirsnames.get_ponderations()
+    if coeff_auto:
+        pond = manager.get_ponderations()
+        assert pond["Ponderation"].sum() > 0.999999 and pond["Ponderation"].sum()<1.0000001, "The sum of the ponderations is not equal to 1"
+
+    elif manager.is_valid_ponderation_csv:
+        pond = pd.read_csv(manager.PONDERATION_CSV)
+        pond.set_index("Interval", inplace=True)
+    else:
+        logging.error("The ponderation file is missing")
+        logging.info("Please provide the ponderation file or set 'coeff_auto' to True")
+        return
 
     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)
@@ -406,7 +498,7 @@ def Acceptability(main_dir:str = 'Vesdre',
 
     # Set up output GeoTIFF
     driver = gdal.GetDriverByName('GTiff')
-    dataset = driver.Create(str(dirsnames.OUT_ACCEPT), x_pixels, y_pixels, 1, gdal.GDT_Float32, options=["COMPRESS=LZW"])
+    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)
@@ -414,7 +506,9 @@ def Acceptability(main_dir:str = 'Vesdre',
     del(dataset)
 
     # Resample to 100m
-    Agg = gdal.Warp(str(dirsnames.OUT_ACCEPT_100M), str(dirsnames.OUT_ACCEPT), xRes=100, yRes=100, resampleAlg='Average')
+    Agg = gdal.Warp(str(manager.OUT_ACCEPT_100M), str(manager.OUT_ACCEPT), xRes=100, yRes=100, resampleAlg='Average')
     del(Agg)
 
-    dirsnames.restore_dir()
+    manager.restore_dir()
+
+    return 0