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

wolfhece/acceptability/func.py

@@ -7,6 +7,42 @@ import glob
 from pathlib import Path
 import logging
 from tqdm import tqdm
+from pyogrio import list_layers, read_dataframe
+from enum import Enum   
+import numba as nb
+
+ENGINE = 'pyogrio' # or 'Fiona -- Pyogrio is faster
+EXTENT = '.gpkg'
+class Modif_Type(Enum):
+    """
+    Enum class for the type of modification
+    """
+
+    WALOUS = 'Walous layers changed to PICC buidings'
+    POINT2POLY_EPURATION = 'Change BDREF based on AJOUT_PDET sent by Perrine (SPI)'
+    POINT2POLY_PICC = 'Convert the points to polygons based on PICC'
+    POINT2POLY_CAPAPICC = 'Convert the points to polygons based on PICC and CaPa'
+    INHABITED = 'Select only inhabited buildings'
+    ROAD = 'Create a buffer around the roads'
+    COPY = 'Copy the data'
+
+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"]
+
 
 def get_data_type(fname:Path):
 
@@ -97,6 +133,10 @@ class Accept_Manager():
                  CaPa_Walloon:str = 'Cadastre_Walloon.gpkg',
                  PICC_Walloon:str = 'PICC_vDIFF.gdb',
                  CE_IGN_top10v:str = 'CE_IGN_TOP10V/CE_IGN_TOP10V.shp',
+                 EPU_Stations:str = 'AJOUT_PDET_EPU_DG03_STATIONS.shp',
+                 Ponderation_csv:str = 'Ponderation.csv',
+                 Vulnerability_csv:str = 'Vulnerability.csv',
+                 Intermediate_csv:str = 'Intermediate.csv'
                                                          ) -> None:
 
         self.old_dir:Path    = Path(os.getcwd())
@@ -123,39 +163,54 @@ class Accept_Manager():
         self.IN_STUDY_AREA  = self.IN_DIR / "STUDY_AREA"
         self.IN_CSV         = self.IN_DIR / "CSVs"
         self.IN_WATER_DEPTH = self.IN_DIR / "WATER_DEPTH"
+        self.IN_EPU_STATIONS= self.IN_DIR / "EPU_STATIONS_NEW"
 
         self.ORIGINAL_GDB   = self.IN_DATABASE / self._original_gdb
         self.CAPA_WALLOON   = self.IN_DATABASE / self._capa_walloon
         self.PICC_WALLOON   = self.IN_DATABASE / self._picc_walloon
         self.CE_IGN_TOP10V  = self.IN_DATABASE / self._ce_ign_top10v
+        self.EPU_STATIONS   = self.IN_EPU_STATIONS / EPU_Stations
 
-        self.VULNERABILITY_CSV = self.IN_CSV / "Vulnerability.csv"
-        self.POINTS_CSV        = self.IN_CSV / "Intermediate.csv"
-        # self.PONDERATION_CSV   = self.IN_CSV / "Ponderation.csv"
+        self.VULNERABILITY_CSV = self.IN_CSV / Vulnerability_csv
+        self.POINTS_CSV        = self.IN_CSV / Intermediate_csv
+        self.PONDERATION_CSV   = self.IN_CSV / Ponderation_csv
 
-        self._CSVs = [self.VULNERABILITY_CSV, self.POINTS_CSV] #, self.PONDERATION_CSV]
+        self._CSVs = [self.VULNERABILITY_CSV, self.POINTS_CSV] 
         self._GPKGs= [self.CAPA_WALLOON, self.PICC_WALLOON]
         self._GDBs = [self.ORIGINAL_GDB]
-        self._SHPs = [self.CE_IGN_TOP10V]
+        self._SHPs = [self.CE_IGN_TOP10V, self.EPU_STATIONS]
         self._ALLS = self._CSVs + self._GPKGs + self._GDBs + self._SHPs
 
         self.TMP_DIR            = self.main_dir / "TEMP"
 
-        self.TMP_DATABASE       = self.TMP_DIR / "DATABASES"
-
         self.OUT_DIR        = self.main_dir / "OUTPUT"
 
+        self.points2polys = []
+        self.lines2polys = []
+
         self.create_paths()
         self.create_paths_scenario()
 
     def create_paths(self):
         """ Create the paths for the directories and files """
 
+        self.points2polys = []
+        self.lines2polys = []
+
         if self._study_area is not None:
 
             self.Study_area:Path = Path(self._study_area)
 
-            self.TMP_STUDYAREA      = self.TMP_DATABASE / self.Study_area.stem
+            self.TMP_STUDYAREA      = self.TMP_DIR / self.Study_area.stem
+            self.TMP_DATABASE       = self.TMP_STUDYAREA / "DATABASES"
+
+            self.TMP_CLIPGDB        = self.TMP_DATABASE / "CLIP_GDB"
+            self.TMP_CADASTER       = self.TMP_DATABASE / "CLIP_CADASTER"
+            self.TMP_PICC           = self.TMP_DATABASE / "CLIP_PICC"
+            self.TMP_IGNCE          = self.TMP_DATABASE / "CLIP_IGN_CE"
+            self.TMP_WMODIF         = self.TMP_DATABASE / "WITH_MODIF"
+            self.TMP_CODEVULNE      = self.TMP_DATABASE / "CODE_VULNE"
+
             self.TMP_VULN_DIR       = self.TMP_STUDYAREA / "VULNERABILITY"
             self.TMP_RASTERS        = self.TMP_VULN_DIR / "RASTERS"
             self.TMP_RASTERS_CODE   = self.TMP_RASTERS / "Code"
@@ -164,12 +219,13 @@ class Accept_Manager():
             self.OUT_STUDY_AREA = self.OUT_DIR / self.Study_area.stem
 
             self.SA          = self.IN_STUDY_AREA / self.Study_area
-            self.SA_DATABASE = self.TMP_STUDYAREA / "database.gpkg"
-            self.SA_CAPA     = self.TMP_STUDYAREA / "CaPa.gpkg"
-            self.SA_PICC     = self.TMP_STUDYAREA / "PICC.gpkg"
+
+            # self.SA_DATABASE = self.TMP_STUDYAREA / "database.gpkg"
+            # self.SA_CAPA     = self.TMP_STUDYAREA / "CaPa.gpkg"
+            # self.SA_PICC     = self.TMP_STUDYAREA / "PICC.gpkg"
             self.SA_FINAL    = self.TMP_STUDYAREA / "database_final.gpkg"
             self.SA_FINAL_V  = self.TMP_STUDYAREA / "database_final_V.gpkg"
-            self.SA_MASKED_RIVER = self.TMP_STUDYAREA / "CE_IGN_TOP10V.tiff"
+            self.SA_MASKED_RIVER = self.TMP_IGNCE / "CE_IGN_TOP10V.tiff"
 
             self.SA_VULN    = self.TMP_VULN_DIR / "Vulnerability.tiff"
             self.SA_CODE    = self.TMP_VULN_DIR / "Vulnerability_Code.tiff"
@@ -179,6 +235,12 @@ class Accept_Manager():
             self._scenario = None
 
             self.TMP_STUDYAREA      = None
+            self.TMP_DATABASE       = None
+            self.TMP_CADASTER       = None
+            self.TMP_PICC           = None
+            self.TMP_IGNCE          = None
+            self.TMP_WMODIF         = None
+            self.TMP_CODEVULNE      = None
             self.TMP_VULN_DIR       = None
             self.TMP_RASTERS        = None
             self.TMP_RASTERS_CODE   = None
@@ -204,7 +266,7 @@ class Accept_Manager():
         self.check_outputs()
 
     def create_paths_scenario(self):
-
+        
         if self._scenario is not None:
 
             self.scenario:str       = str(self._scenario)
@@ -300,10 +362,25 @@ class Accept_Manager():
             logging.error("The scenario does not exist in the water depth directory")
 
     def get_files_in_rm_buildings(self) -> list[Path]:
-        return [Path(a) for a in glob.glob(str(self.IN_RM_BUILD_DIR / "*.shp"))]
+        return [Path(a) for a in glob.glob(str(self.IN_RM_BUILD_DIR / ("*"+ EXTENT)))]
 
     def get_files_in_rasters_vulne(self) -> list[Path]:
         return [Path(a) for a in glob.glob(str(self.TMP_RASTERS_VULNE / "*.tiff"))]
+    
+    def get_layers_in_gdb(self) -> list[str]:
+        return [a[0] for a in list_layers(str(self.ORIGINAL_GDB))]
+
+    def get_layer_types_in_gdb(self) -> list[str]:
+        return [a[1] for a in list_layers(str(self.ORIGINAL_GDB))]
+    
+    def get_layers_in_clipgdb(self) -> list[str]:
+        return [Path(a).stem for a in glob.glob(str(self.TMP_CLIPGDB / ("*"+ EXTENT)))]
+
+    def get_layers_in_wmodif(self) -> list[str]:
+        return [Path(a).stem for a in glob.glob(str(self.TMP_WMODIF / ("*"+ EXTENT)))]
+    
+    def get_layers_in_codevulne(self) -> list[str]:
+        return [Path(a).stem for a in glob.glob(str(self.TMP_CODEVULNE / ("*"+ EXTENT)))]
 
     def get_files_in_rasters_code(self) -> list[Path]:
         return [Path(a) for a in glob.glob(str(self.TMP_RASTERS_CODE / "*.tiff"))]
@@ -343,23 +420,114 @@ class Accept_Manager():
                     return cursim
 
         return None
+    
+    def get_types_in_file(self, file:str) -> list[str]:
+        """ Get the types of the geometries in the Shape file """
+
+        return [a[1] for a in list_layers(str(file))]
+    
+    def is_type_unique(self, file:str) -> bool:
+        """ Check if the file contains only one type of geometry """
+
+        types = self.get_types_in_file(file)
+        return len(types) == 1
+    
+    def is_polygons(self, set2test:set) -> bool:
+        """ Check if the set contains only polygons """
+
+        set2test = list(set2test)
+        firstone = set2test[0]
+        if 'Polygon' in firstone:
+            for curtype in set2test:
+                if 'Polygon' not in curtype:
+                    return False
+            return True
+        else:
+            return False
+    
+    def is_same_types(self, file:str) -> tuple[bool, str]:
+        """ Check if the file contains only the same type of geometry """
+
+        types = self.get_types_in_file(file)
+
+        if len(types) == 1:
+            if 'Point' in types[0]:
+                return True, 'Point'
+            elif 'Polygon' in types[0]:
+                return True, 'Polygon'
+            elif 'LineString' in types[0]:
+                return True, 'LineString'
+            else:
+                raise ValueError(f"The type of geometry {types[0]} is not recognized")
+        else:
+            firstone = types[0]
+            if 'Point' in firstone:
+                for curtype in types:
+                    if 'Point' not in curtype:
+                        return False, None
+                return True, 'Point'
+            
+            elif 'Polygon' in firstone:
+                for curtype in types:
+                    if 'Polygon' not in curtype:
+                        return False, None
+                    
+                return True, 'Polygon'
+            
+            elif 'LineString' in firstone:
+                for curtype in types:
+                    if 'LineString' not in curtype:
+                        return False, None
+                    
+                return True, 'LineString'
+            else:
+                raise ValueError(f"The type of geometry {firstone} is not recognized")
+
 
     def get_return_periods(self) -> list[int]:
+        """ 
+        Get the return periods from the simulations 
+        
+        :return list[int]: the **sorted list** of return periods
+        """
 
+        # List files in directory
         sims = self.get_sims_files_for_scenario()
 
         if len(sims)==0:
             logging.error("No simulations found")
             return None
 
+        # Two cases: 
+        # - Return periods are named as T2.tif, T5.tif, T10.tif, ...
+        # - Return periods are named as *_T2_h.tif, *_T5_h.tif, *_T10_h.tif, ...
         if "_h.tif" in sims[0].name:
-            idx_T = [cursim.stem.find("_T") for cursim in sims]
-            idx_h = [cursim.stem.find("_h.tif") for cursim in sims]
-            sims = [int(cursim.stem[idx_T[i]+2:idx_h[i]-1]) for i, cursim in enumerate(sims)]
+
+            # Searching for the position of the return period in the name
+            idx_T = [cursim.name.find("_T") for cursim in sims]
+            idx_h = [cursim.name.find("_h.tif") for cursim in sims]
+
+            assert len(idx_T) == len(idx_h), "The number of T and h are not the same"
+            for curT, curh in zip(idx_T, idx_h):
+                assert curT != -1, "The T is not found"
+                assert curh != -1, "The h is not found"
+                assert curh > curT, "The h is before the T"
+
+            # Create the list of return periods -- only the numeric part
+            sims = [int(cursim.name[idx_T[i]+2:idx_h[i]]) for i, cursim in enumerate(sims)]
         else:
-            idx_T = [cursim.stem.find("T") for cursim in sims]
-            idx_h = [cursim.stem.find(".tif") for cursim in sims]
-            sims = [int(cursim.stem[idx_T[i]+1:idx_h[i]]) for i, cursim in enumerate(sims)]
+            # searching for the position of the return period in the name
+            idx_T = [cursim.name.find("T") for cursim in sims]
+            idx_h = [cursim.name.find(".tif") for cursim in sims]
+
+            assert len(idx_T) == len(idx_h), "The number of T and h are not the same"
+            for curT, curh in zip(idx_T, idx_h):
+                assert curT != -1, "The T is not found"
+                assert curh != -1, "The h is not found"
+                assert curh > curT, "The h is before the T"
+            
+            # create the list of return periods -- only the numeric part
+            sims = [int(cursim.name[idx_T[i]+1:idx_h[i]]) for i, cursim in enumerate(sims)]
 
         return sorted(sims)
 
@@ -376,8 +544,12 @@ class Accept_Manager():
 
         pond.append(1./float(rt[0]) + (1./float(rt[0]) - 1./float(rt[1]))/2.)
         for i in range(1, len(rt)-1):
+            # Full formula 
             # pond.append((1./float(rt[i-1]) - 1./float(rt[i]))/2. + (1./float(rt[i]) - 1./float(rt[i+1]))/2.)
+
+            # More compact formula
             pond.append((1./float(rt[i-1]) - 1./float(rt[i+1]))/2.)
+
         pond.append(1./float(rt[-1]) + (1./float(rt[-2]) - 1./float(rt[-1]))/2.)
 
         return pd.DataFrame(pond, columns=["Ponderation"], index=rt)
@@ -419,6 +591,10 @@ class Accept_Manager():
             logging.error("INPUT : The water depth directory does not exist")
             err = True
 
+        if not self.IN_EPU_STATIONS.exists():
+            logging.error("INPUT : The EPU stations directory does not exist")
+            err = True
+
         if self.Study_area is not None:
             if not self.SA.exists():
                 logging.error("INPUT : The study area file does not exist")
@@ -441,7 +617,7 @@ class Accept_Manager():
             err = True
 
         if self.scenario is None:
-            logging.warning("The scenario has not been defined")
+            logging.debug("The scenario has not been defined")
         else:
             if not self.IN_SCEN_DIR.exists():
                 logging.error("The scenario directory does not exist")
@@ -457,11 +633,20 @@ class Accept_Manager():
         """
 
         self.TMP_DIR.mkdir(parents=True, exist_ok=True)
-        self.TMP_DATABASE.mkdir(parents=True, exist_ok=True)
 
         if self.Study_area is not None:
             self.TMP_STUDYAREA.mkdir(parents=True, exist_ok=True)
+            self.TMP_DATABASE.mkdir(parents=True, exist_ok=True)
+            self.TMP_CLIPGDB.mkdir(parents=True, exist_ok=True)
+            self.TMP_CADASTER.mkdir(parents=True, exist_ok=True)
+            self.TMP_WMODIF.mkdir(parents=True, exist_ok=True)
+            self.TMP_CODEVULNE.mkdir(parents=True, exist_ok=True)
+            self.TMP_PICC.mkdir(parents=True, exist_ok=True)
+            self.TMP_IGNCE.mkdir(parents=True, exist_ok=True)
             self.TMP_VULN_DIR.mkdir(parents=True, exist_ok=True)
+            self.TMP_RASTERS.mkdir(parents=True, exist_ok=True)
+            self.TMP_RASTERS_CODE.mkdir(parents=True, exist_ok=True)
+            self.TMP_RASTERS_VULNE.mkdir(parents=True, exist_ok=True)
 
         if self.scenario is not None:
             self.TMP_SCEN_DIR.mkdir(parents=True, exist_ok=True)
@@ -533,12 +718,12 @@ class Accept_Manager():
 
     def check_before_rasterize(self) -> bool:
 
-        if not self.SA_FINAL_V.exists():
+        if not self.TMP_CODEVULNE.exists():
             logging.error("The final database with vulnerability levels does not exist")
             return False
 
-        if not self.SA.exists():
-            logging.error("The study area file does not exist")
+        if not self.TMP_WMODIF.exists():
+            logging.error("The vector data with modifications does not exist")
             return False
 
         return True
@@ -587,44 +772,145 @@ class Accept_Manager():
 
         return True
 
-# Step 1, Clip GDB data
+    def compare_original_clipped_layers(self) -> str:
+        """ Compare the original layers with the clipped ones """
+
+        layers = self.get_layers_in_gdb()
+        layers_clip = self.get_layers_in_clipgdb()
+
+        ret = 'These layers have not been clipped:\n'
+        for layer in layers:
+            if layer not in layers_clip:
+                ret += " - {}\n".format(layer)
+
+        ret += '\nThese layers have been clipped but are not present in the GDB:\n'
+        for layer in layers_clip:
+            if layer not in layers:
+                ret += " - {}\n".format(layer)
+
+        ret+='\n'
+
+        return ret
+    
+    def compare_clipped_raster_layers(self) -> str:
+        """ Compare the clipped layers with the rasterized ones """
+
+        layers = self.get_layers_in_clipgdb()
+        layers_rast = self.get_layers_in_codevulne()
+
+        ret = 'These layers {} have not been rasterized:\n'
+        for layer in layers:
+            if layer not in layers_rast:
+                ret += " - {}\n".format(layer)
+
+        ret += '\nThese layers have been rasterized but are not in the orginal GDB:\n'
+        for layer in layers_rast:
+            if layer not in layers:
+                ret += " - {}\n".format(layer)
+
+        ret+='\n'
+
+        return ret
+    
+    def get_operand(self, file:str) -> Modif_Type:
+        """ Get the operand based on the layer name """
+        LAYERS_WALOUS = ["WALOUS_2018_LB72_112",
+                        "WALOUS_2018_LB72_31",
+                        "WALOUS_2018_LB72_32",
+                        "WALOUS_2018_LB72_331",
+                        "WALOUS_2018_LB72_332",
+                        "WALOUS_2018_LB72_333",
+                        "WALOUS_2018_LB72_34"]
+
+        ret, curtype = self.is_same_types(file)
+        layer = Path(file).stem
+
+        if not ret:
+            raise ValueError("The layer contains different types of geometries")
+
+        if layer in LAYERS_WALOUS: 
+            return Modif_Type.WALOUS
+        
+        elif curtype=="Point":
+
+            self.points2polys.append(layer)
+
+            if layer =="BDREF_DGO3_PASH__SCHEMA_STATIONS_EPU": 
+                return Modif_Type.POINT2POLY_EPURATION
+            elif layer =="INFRASIG_SOINS_SANTE__ETAB_AINES":
+                return Modif_Type.POINT2POLY_PICC
+            else:
+                return Modif_Type.POINT2POLY_CAPAPICC
+        
+        elif layer =="Hab_2018_CABU":
+            return Modif_Type.INHABITED
+        
+        elif layer =="INFRASIG_ROUTE_RES_ROUTIER_TE_AXES":
+            
+            self.lines2polys.append(layer)
+
+            return Modif_Type.ROAD        
+        
+        else:
+            return Modif_Type.COPY
 
-def gpd_clip(layer:str,
+
+def clip_layer(layer:str,
              file_path:str,
              Study_Area:str,
-             geopackage:str):
+             output_dir:str):
     """
-    Clip the input data based on the selected bassin and saves it in a separate database
+    Clip the input data based on the selected bassin and saves it 
+    in separate shape files.
+
+    As shape file doen not support DateTime, the columns with DateTime
+    are converted to string.
 
     :param layer: the layer name in the GDB file
     :param file_path: the path to the GDB file
     :param Study_Area: the path to the study area shapefile
-    :param geopackage: the path to the geopackage file
+    :param output_dir: the path to the output directory
     """
 
     layer = str(layer)
     file_path = str(file_path)
     Study_Area = str(Study_Area)
-    geopackage = str(geopackage)
+    output_dir = Path(output_dir)
 
-    St_Area = gpd.read_file(Study_Area)
+    St_Area = gpd.read_file(Study_Area, engine=ENGINE)
 
     logging.info(layer)
 
     # The data is clipped during the reading
     # **It is more efficient than reading the entire data and then clipping it**
-    df:gpd.GeoDataFrame = gpd.read_file(file_path, layer=layer, mask=St_Area)
+    #
+    # FIXME: "read_dataframe" is used directly rather than "gpd.read_file" cause
+    # the "layer" parameter is well transmitted to the "read_dataframe" function...
+    df:gpd.GeoDataFrame = read_dataframe(file_path, layer=layer, mask=St_Area['geometry'][0])
+
+    if len(df) == 0:
+        logging.warning("No data found for layer " + str(layer))
+        return "No data found for layer " + str(layer)
 
     # Force Lambert72 -> EPSG:31370
     df.to_crs("EPSG:31370", inplace=True)
-
-    df.to_file(geopackage, layer=layer, mode='w')
-
-    return "Saved the clipped " +str(layer)+ " to GPKG"
-
-def data_modification(input_database:str,
-                      layer:str,
-                      output_database:str,
+    try:
+        date_columns = df.select_dtypes(include=['datetimetz']).columns.tolist()
+        if len(date_columns)>0:
+            df[date_columns] = df[date_columns].astype(str)
+
+        df.to_file(str(output_dir / (layer+EXTENT)), mode='w', engine=ENGINE)
+    except Exception as e:
+        logging.error("Error while saving the clipped " + str(layer) + " to file")
+        logging.error(e)
+        pass
+    
+    logging.info("Saved the clipped " + str(layer) + " to file")
+    return "Saved the clipped " +str(layer)+ " to file"
+
+
+def data_modification(layer:str,
+                      manager:Accept_Manager,
                       picc:gpd.GeoDataFrame,
                       capa:gpd.GeoDataFrame ):
     """
@@ -642,163 +928,153 @@ def data_modification(input_database:str,
     df1:gpd.GeoDataFrame
     df2:gpd.GeoDataFrame
 
-    LAYERS_WALOUS = ["WALOUS_2018_LB72_112",
-                     "WALOUS_2018_LB72_31",
-                     "WALOUS_2018_LB72_32",
-                     "WALOUS_2018_LB72_331",
-                     "WALOUS_2018_LB72_332",
-                     "WALOUS_2018_LB72_333",
-                     "WALOUS_2018_LB72_34"]
-
-    input_database = str(input_database)
     layer = str(layer)
-    output_database = str(output_database)
-
-    df:gpd.GeoDataFrame = gpd.read_file(input_database, layer = layer)
-    x1,y1 = df.shape
-    a = df.geom_type.unique()
-    #print(layers[i])
-    x,=a.shape
-    if x1>0:
-        if layer in LAYERS_WALOUS: #Walous layers changed to PICC buidings
-                #print("walous")
-
-                assert picc.crs == df.crs, "CRS of PICC and input data do not match"
-
-                df1= gpd.sjoin(picc, df, how="inner", predicate="intersects" )
-                cols=df.columns
-                cols = np.append(cols, "GEOREF_ID")
-                cols = np.append(cols, "NATUR_CODE")
-                df1=df1[cols]
-                df1.to_file(output_database,layer=layer)
-        elif layer =="BDREF_DGO3_PASH__SCHEMA_STATIONS_EPU": #Change BDREF based on AJOUT_PDET sent by Perrine
-                #print("yes")
-                df1 = gpd.read_file(os.getcwd()+"//INPUT//EPU_STATIONS_NEW//AJOUT_PDET_EPU_DG03_STATIONS.shp")
-
-                assert df1.crs == df.crs, "CRS of AJOUT_PDET and input data do not match"
-
-                df2 = gpd.sjoin(picc, df1, how="inner", predicate="intersects" )
-                df2.to_file(output_database, layer=layer)
-        elif layer =="INFRASIG_SOINS_SANTE__ETAB_AINES":
-
-                assert capa.crs == df.crs, "CRS of CaPa and input data do not match"
-
-                df1= gpd.sjoin(capa, df, how="inner", predicate="intersects" )
-                cols=df.columns
-                #print(cols)
-                cols = np.append(cols, "CaPaKey")
-                #print(cols)
-                df1=df1[cols]
-                df2=gpd.sjoin(picc, df1, how="inner", predicate="intersects" )
-                cols = np.append(cols, "GEOREF_ID")
-                cols = np.append(cols, "NATUR_CODE")
-                #df2=df2[cols]
-                #print(df2.columns)
-                df2.to_file(output_database, layer=layer)
-
-        elif a[0,]=="Point" and layer!="BDREF_DGO3_PASH__SCHEMA_STATIONS_EPU" and layer!="INFRASIG_SOINS_SANTE__ETAB_AINES":
-
-                assert capa.crs == df.crs, "CRS of CaPa and input data do not match"
-                assert picc.crs == df.crs, "CRS of PICC and input data do not match"
-
-                df1= gpd.sjoin(capa, df, how="inner", predicate="intersects" )
-                cols=df.columns
-                #print(cols)
-                cols = np.append(cols, "CaPaKey")
-                #print(cols)
-                df1=df1[cols]
-                df2=gpd.sjoin(picc, df1, how="inner", predicate="intersects" )
-                cols = np.append(cols, "GEOREF_ID")
-                cols = np.append(cols, "NATUR_CODE")
-                df2=df2[cols]
-                #print(df2.columns)
-                df2.to_file(output_database, layer=layer)
-                #print(layers[i])
-        elif layer =="Hab_2018_CABU":
-                df1=df[df["NbsHabTOT"]>0]
-                #print(df1.shape)
-                df1.to_file(output_database, layer=layer)
-        elif layer =="INFRASIG_ROUTE_RES_ROUTIER_TE_AXES":
-                df1=df.buffer(6, cap_style=2)
-                df1.to_file(output_database, layer=layer)
-        else:
-                df.to_file(output_database, layer=layer)
-    else:
-        logging.info("skipped" + str(layer) + "due to no polygon in the study area")
 
-def vector_to_raster(layer:str,
-                     vector_input:Path,
-                     extent:Path,
-                     attribute:str,
-                     pixel_size:float):
-    """
-    Convert a vector layer to a raster tiff file
+    dir_input = manager.TMP_CLIPGDB
+    dir_output = manager.TMP_WMODIF
 
-    :param layer: the layer name in the GDB file
-    :param vector_input: the path to the vector file
-    :param extent: the path to the extent file
-    :param attribute: the attribute to rasterize
-    :param pixel_size: the pixel size of the raster
+    input_file  = str(dir_input  / (layer + EXTENT))
+    output_file = str(dir_output / (layer + EXTENT))
 
-    """
+    # Read the data
+    df:gpd.GeoDataFrame = gpd.read_file(input_file, engine=ENGINE)
+    nblines, _ = df.shape
 
-    old_dir = os.getcwd()
+    if nblines>0:
+        op = manager.get_operand(input_file)
 
-    layer = str(layer)
-    vector_input = Path(vector_input)
-    extent = Path(extent)
-    attribute = str(attribute)
-    pixel_size = float(pixel_size)
+        if op == Modif_Type.WALOUS: 
+            # Walous layers changed to PICC buidings
 
-    OUT_DIR = vector_input.parent / "VULNERABILITY/RASTERS" / attribute
-    OUT_NAME =  layer + ".tiff"
+            assert picc.crs == df.crs, "CRS of PICC and input data do not match"
 
-    OUT_DIR.mkdir(parents=True, exist_ok=True)
+            assert "GEOREF_ID" in picc.columns, "The PICC file does not contain the GEOREF_ID column"
+            assert "NATUR_CODE" in picc.columns, "The PICC file does not contain the NATUR_CODE column"
 
-    if (OUT_DIR/OUT_NAME).exists():
-        os.remove(OUT_DIR/OUT_NAME)
+            df1  = gpd.sjoin(picc, df, how="inner", predicate="intersects" )
+            cols = df.columns
 
-    os.chdir(OUT_DIR)
+            cols = np.append(cols, "GEOREF_ID")
+            cols = np.append(cols, "NATUR_CODE")
 
-    NoData_value = 0
+            df1  = df1[cols]
+            
+            if df1.shape[0] > 0: 
+                assert manager.is_polygons(set(df1.geom_type)), f"The layer does not contains polygons - {op}"
+                df1.to_file(output_file, engine=ENGINE)
+            else:
+                logging.warning("No data found for layer " + str(layer))
 
-    extent_ds:ogr.DataSource = ogr.Open(str(extent))
-    extent_layer = extent_ds.GetLayer()
+        elif op == Modif_Type.POINT2POLY_EPURATION: 
+            # Change BDREF based on AJOUT_PDET sent by Perrine (SPI)
+            
+            # The original layer is a point layer.
+            # The EPU_STATIONS shape file (from SPI) is a polygon layer.
 
-    x_min, x_max, y_min, y_max = extent_layer.GetExtent()
+            df1 = gpd.read_file(str(manager.EPU_STATIONS), engine=ENGINE)
 
-    x_min = float(int(x_min))
-    x_max = float(np.ceil(x_max))
-    y_min = float(int(y_min))
-    y_max = float(np.ceil(y_max))
+            assert df1.crs == df.crs, "CRS of AJOUT_PDET and input data do not match"
 
-    # Open the data sources and read the extents
-    source_ds:ogr.DataSource = ogr.Open(str(vector_input))
-    source_layer = source_ds.GetLayer(layer)
+            df2 = gpd.sjoin(picc, df1, how="inner", predicate="intersects" )
 
-    # Create the destination data source
-    x_res = int((x_max - x_min) / pixel_size)
-    y_res = int((y_max - y_min) / pixel_size)
-    target_ds:gdal.Driver = gdal.GetDriverByName('GTiff').Create(str(OUT_NAME),
-                                                     x_res, y_res, 1,
-                                                     gdal.GDT_Byte,
-                                                     options=["COMPRESS=LZW"])
+            if df2.shape[0] > 0:
+                assert manager.is_polygons(set(df2.geom_type)), f"The layer does not contains polygons - {op}"
+                df2.to_file(output_file, engine=ENGINE)
+            else:
+                logging.warning("No data found for layer " + str(layer))
 
-    target_ds.SetGeoTransform((x_min, pixel_size, 0, y_max, 0, -pixel_size))
-    srs = osr.SpatialReference()
-    srs.ImportFromEPSG(31370)
-    target_ds.SetProjection(srs.ExportToWkt())
+        elif op == Modif_Type.POINT2POLY_PICC:
+            # Select the polygons that contains the points
+            #  in theCadaster and PICC files
 
-    band = target_ds.GetRasterBand(1)
-    band.SetNoDataValue(NoData_value)
+            assert capa.crs == df.crs, "CRS of CaPa and input data do not match"
+            assert "CaPaKey" in capa.columns, "The CaPa file does not contain the CaPaKey column"
 
-    # Rasterize the areas
-    gdal.RasterizeLayer(target_ds, [1], source_layer, options=["ATTRIBUTE="+attribute, "ALL_TOUCHED=TRUE"])
-    target_ds = None
+            df1= gpd.sjoin(capa, df, how="inner", predicate="intersects" )
+            cols=df.columns
+
+            cols = np.append(cols, "CaPaKey")
+            df1=df1[cols]
+            df2=gpd.sjoin(picc, df1, how="inner", predicate="intersects" )
+
+            if df2.shape[0] > 0:
+                assert manager.is_polygons(set(df2.geom_type)), f"The layer does not contains polygons - {op}"
+                df2.to_file(output_file, engine=ENGINE)
+            else:
+                logging.warning("No data found for layer " + str(layer))
+
+        elif op == Modif_Type.POINT2POLY_CAPAPICC:
+            
+            # Select the polygons that contains the points
+            #  in theCadaster and PICC files
+
+            assert capa.crs == df.crs, "CRS of CaPa and input data do not match"
+            assert picc.crs == df.crs, "CRS of PICC and input data do not match"
+
+            # Join the Layer and CaPa DataFrames : https://geopandas.org/en/stable/docs/reference/api/geopandas.sjoin.html
+            # ‘inner’: use intersection of keys from both dfs; retain only left_df geometry column
+            # "intersects" : Binary predicate. Valid values are determined by the spatial index used.
+            df1= gpd.sjoin(capa, df, how="inner", predicate="intersects" )
+            
+            # Retain only the columns of the input data
+            cols = df.columns
+            # but add the CaPaKey
+            cols = np.append(cols, "CaPaKey")
+
+            df1  = df1[cols]
+
+            # Join the df1 and PICC DataFrames : https://geopandas.org/en/stable/docs/reference/api/geopandas.sjoin.html
+            df2  = gpd.sjoin(picc, df1, how="inner", predicate="intersects" )
+            
+            # Add only the GEOREF_ID and NATUR_CODE columns from PICC
+            cols = np.append(cols, "GEOREF_ID")
+            cols = np.append(cols, "NATUR_CODE")
+            
+            df2 = df2[cols]
+
+            if df2.shape[0] > 0:
+                assert manager.is_polygons(set(df2.geom_type)), f"The layer does not contains polygons - {op}"
+                df2.to_file(output_file, engine=ENGINE)
+            else:
+                logging.warning("No data found for layer " + str(layer))
 
-    os.chdir(old_dir)
+        elif op == Modif_Type.INHABITED:
+            # Select only the buildings with a number of inhabitants > 0
+            df1=df[df["NbsHabTOT"]>0]
 
-def Comp_Vulnerability(dirsnames:Accept_Manager):
+            if df1.shape[0] > 0:
+                assert manager.is_polygons(set(df1.geom_type)), f"The layer does not contains polygons - {op}"
+                df1.to_file(output_file, engine=ENGINE)
+            else:
+                logging.warning("No data found for layer " + str(layer))
+
+        elif op == Modif_Type.ROAD:
+            # Create a buffer around the roads
+            df1=df.buffer(distance=6, cap_style=2)
+
+            if df1.shape[0] > 0:
+                assert set(df1.geom_type) == {'Polygon'}, f"The layer does not contains polygons - {op}"
+                df1.to_file(output_file, engine=ENGINE)
+            else:
+                logging.warning("No data found for layer " + str(layer))
+        
+        elif op == Modif_Type.COPY:
+            # just copy the data if it is polygons
+            if manager.is_polygons(set(df.geom_type)):
+                df.to_file(output_file, engine=ENGINE)
+            else:
+                logging.error("The layer does not contains polygons - " + str(layer))
+        else:
+            raise ValueError(f"The operand {op} is not recognized")
+
+        return "Data modification done for " + str(layer)
+    else:
+        # Normally, phase 1 does not create empty files
+        # But it is better to check... ;-)
+        logging.error("skipped" + str(layer) + "due to no polygon in the study area")
+        return "skipped" + str(layer) + "due to no polygon in the study area"
+
+def compute_vulnerability(manager:Accept_Manager):
     """
     Compute the vulnerability for the Study Area
 
@@ -807,45 +1083,77 @@ def Comp_Vulnerability(dirsnames:Accept_Manager):
     :param dirsnames: the Dirs_Names object from the calling function
     """
 
-    rasters_vuln = dirsnames.get_files_in_rasters_vulne()
-    rasters_code = dirsnames.get_files_in_rasters_code()
+    vuln_csv = Vulnerability_csv(manager.VULNERABILITY_CSV)
+
+    rasters_vuln = manager.get_files_in_rasters_vulne()
 
     logging.info("Number of files",len(rasters_vuln))
 
-    ds:gdal.Dataset = gdal.Open(str(rasters_vuln[0]))
-    ds1:gdal.Dataset = gdal.Open(str(rasters_code[0]))
+    ds:gdal.Dataset = gdal.OpenEx(str(rasters_vuln[0]), gdal.GA_ReadOnly, open_options=["SPARSE_OK=TRUE"])
 
-    tmp_vuln = np.array(ds.GetRasterBand(1).ReadAsArray())
-    tmp_code = np.array(ds1.GetRasterBand(1).ReadAsArray())
+    tmp_vuln = ds.GetRasterBand(1)
 
-    x, y = tmp_vuln.shape
+    # REMARK: The XSize and YSize are the number of columns and rows
+    col, row = tmp_vuln.XSize, tmp_vuln.YSize
 
     logging.info("Computing Vulnerability")
 
-    array_vuln = np.zeros((x, y), dtype=np.int8)
-    array_code = np.zeros((x, y), dtype=np.int8)
-
-    for i in tqdm(range(len(rasters_vuln))):
+    array_vuln = np.ones((row, col), dtype=np.int8)
+
+    # Create a JIT function to update the arrays
+    # Faster than the classical Python loop or Numpy
+    @nb.jit(nopython=True, boundscheck=False, inline='always')
+    # @cuda.jit(device=True, inline=True)
+    def update_arrays_jit(tmp_vuln, array_vuln):
+        for i in range(tmp_vuln.shape[0]):
+            for j in range(tmp_vuln.shape[1]):
+                if tmp_vuln[i, j] >= array_vuln[i, j]:
+                    array_vuln[i, j] = tmp_vuln[i, j]
+
+        return array_vuln
+
+    @nb.jit(nopython=True, boundscheck=False, inline='always')
+    # @cuda.jit(device=True, inline=True)
+    def update_arrays_jit_coo(row, col, locvuln, array_vuln):
+        for i,j in zip(row, col):
+            if locvuln >= array_vuln[i, j]:
+                array_vuln[i, j] = locvuln
+
+        return array_vuln
+    
+    for i in tqdm(range(len(rasters_vuln)), 'Computing Vulnerability : '):
         logging.info("Computing layer {} / {}".format(i, len(rasters_vuln)))
-        ds  = gdal.Open(str(rasters_vuln[i]))
-        ds1 = gdal.Open(str(rasters_code[i]))
-
-        tmp_vuln = ds.GetRasterBand(1).ReadAsArray()
-        tmp_code = ds1.GetRasterBand(1).ReadAsArray()
-
-        ij = np.where(tmp_vuln >= array_vuln)
-        array_vuln[ij] = tmp_vuln.max()
-        array_code[ij] = tmp_code.max()
-
-    ij = np.where(array_vuln == 0)
-    array_vuln[ij] = 1
-    array_code[ij] = 1
+        
+        locvuln = vuln_csv.get_vulnerability_level(rasters_vuln[i].stem)
+
+        if locvuln == 1:
+            logging.info("No need to apply the matrice, the vulnerability is 1 which is the lower value")
+            continue
+    
+        if rasters_vuln[i].with_suffix('.npz').exists():
+            ij_npz = np.load(rasters_vuln[i].with_suffix('.npz'))
+            ii = ij_npz['row']
+            jj = ij_npz['col']
+            # We use the jit
+            update_arrays_jit_coo(ii, jj, locvuln, array_vuln)
+        
+        else:
+            ds  = gdal.OpenEx(str(rasters_vuln[i]), open_options=["SPARSE_OK=TRUE"])
+            tmp_vuln = ds.GetRasterBand(1).ReadAsArray()
+            # We use the jit
+            update_arrays_jit(tmp_vuln, array_vuln)
 
-    dst_filename= str(dirsnames.SA_VULN)
+    logging.info("Saving the computed vulnerability")
+    dst_filename= str(manager.SA_VULN)
     y_pixels, x_pixels = array_vuln.shape  # number of pixels in x
 
     driver = gdal.GetDriverByName('GTiff')
-    dataset = driver.Create(dst_filename, x_pixels, y_pixels, gdal.GDT_Byte, 1, options=["COMPRESS=LZW"])
+    dataset = driver.Create(dst_filename, 
+                            x_pixels, y_pixels, 
+                            gdal.GDT_Byte, 
+                            1, 
+                            options=["COMPRESS=LZW"])
+    
     dataset.GetRasterBand(1).WriteArray(array_vuln.astype(np.int8))
     # follow code is adding GeoTranform and Projection
     geotrans = ds.GetGeoTransform()  # get GeoTranform from existed 'data0'
@@ -855,11 +1163,83 @@ def Comp_Vulnerability(dirsnames:Accept_Manager):
     dataset.FlushCache()
     dataset = None
 
+    logging.info("Computed Vulnerability for the Study Area - Done")
+
+def compute_code(manager:Accept_Manager):
+    """
+    Compute the code for the Study Area
+
+    This function **will not modify** the data by the removed buildings/scenarios.
+
+    :param dirsnames: the Dirs_Names object from the calling function
+    """
+
+    vuln_csv = Vulnerability_csv(manager.VULNERABILITY_CSV)
+
+    rasters_code = manager.get_files_in_rasters_code()
+
+    logging.info("Number of files",len(rasters_code))
+
+    ds:gdal.Dataset = gdal.OpenEx(str(rasters_code[0]), gdal.GA_ReadOnly, open_options=["SPARSE_OK=TRUE"])
+
+    tmp_code = ds.GetRasterBand(1)
 
-    dst_filename= str(dirsnames.SA_CODE)
+    # REMARK: The XSize and YSize are the number of columns and rows
+    col, row = tmp_code.XSize, tmp_code.YSize
+
+    logging.info("Computing Code")
+
+    array_code = np.ones((row, col), dtype=np.int8)
+
+    # Create a JIT function to update the arrays
+    # Faster than the classical Python loop or Numpy
+    @nb.jit(nopython=True, boundscheck=False, inline='always')
+    # @cuda.jit(device=True, inline=True)
+    def update_arrays_jit(tmp_code, loccode, array_code):
+        for i in range(tmp_code.shape[0]):
+            for j in range(tmp_code.shape[1]):
+                if tmp_code[i, j] >= array_code[i, j]:
+                    array_code[i, j] = loccode
+
+        return array_code
+
+    @nb.jit(nopython=True, boundscheck=False, inline='always')
+    # @cuda.jit(device=True, inline=True)
+    def update_arrays_jit_coo(row, col, loccode, array_code):
+        for i,j in zip(row, col):
+            if loccode >= array_code[i, j]:
+                array_code[i, j] = loccode
+
+        return array_code
+    
+    for i in tqdm(range(len(rasters_code)), 'Computing Code : '):
+        logging.info("Computing layer {} / {}".format(i, len(rasters_code)))
+        
+        loccode = vuln_csv.get_vulnerability_code(rasters_code[i].stem)
+    
+        if rasters_code[i].with_suffix('.npz').exists():
+            ij_npz = np.load(rasters_code[i].with_suffix('.npz'))
+            ii = ij_npz['row']
+            jj = ij_npz['col']
+            # We use the jit
+            update_arrays_jit_coo(ii, jj, loccode, array_code)
+        
+        else:
+            ds  = gdal.OpenEx(str(rasters_code[i]), open_options=["SPARSE_OK=TRUE"])
+            tmp_code = ds.GetRasterBand(1).ReadAsArray()
+            # We use the jit
+            update_arrays_jit(tmp_code, loccode, array_code)
+
+    logging.info("Saving the computed codes")
+    dst_filename= str(manager.SA_CODE)
     y_pixels, x_pixels = array_code.shape  # number of pixels in x
     driver = gdal.GetDriverByName('GTiff')
-    dataset = driver.Create(dst_filename, x_pixels, y_pixels, gdal.GDT_Byte, 1, options=["COMPRESS=LZW"])
+    dataset = driver.Create(dst_filename, 
+                            x_pixels, y_pixels, 
+                            gdal.GDT_Byte, 
+                            1, 
+                            options=["COMPRESS=LZW"])
+    
     dataset.GetRasterBand(1).WriteArray(array_code.astype(np.int8))
     # follow code is adding GeoTranform and Projection
     geotrans = ds.GetGeoTransform()  # get GeoTranform from existed 'data0'
@@ -869,9 +1249,9 @@ def Comp_Vulnerability(dirsnames:Accept_Manager):
     dataset.FlushCache()
     dataset = None
 
-    logging.info("Computed Vulnerability for the Study Area - Done")
+    logging.info("Computed Code for the Study Area - Done")
 
-def Comp_Vulnerability_Scen(dirsnames:Accept_Manager):
+def compute_vulnerability4scenario(manager:Accept_Manager):
     """ Compute the vulnerability for the scenario
 
     This function **will modify** the data by the removed buildings/scenarios.
@@ -881,16 +1261,16 @@ def Comp_Vulnerability_Scen(dirsnames:Accept_Manager):
     :param dirsnames: the Dirs_Names object from the calling function
     """
 
-    array_vuln = gdal.Open(str(dirsnames.SA_VULN))
+    array_vuln = gdal.Open(str(manager.SA_VULN))
     geotrans = array_vuln.GetGeoTransform()  # get GeoTranform from existed 'data0'
     proj = array_vuln.GetProjection()  # you can get from a exsited tif or import
 
     array_vuln = np.array(array_vuln.GetRasterBand(1).ReadAsArray())
 
-    array_code = gdal.Open(str(dirsnames.SA_CODE))
+    array_code = gdal.Open(str(manager.SA_CODE))
     array_code = np.array(array_code.GetRasterBand(1).ReadAsArray())
 
-    Rbu = dirsnames.get_files_in_rm_buildings()
+    Rbu = manager.get_files_in_rm_buildings()
 
     if len(Rbu)>0:
         for curfile in Rbu:
@@ -901,7 +1281,7 @@ def Comp_Vulnerability_Scen(dirsnames:Accept_Manager):
             array_vuln[ij] = 1
             array_code[ij] = 1
 
-    dst_filename= str(dirsnames.TMP_VULN)
+    dst_filename= str(manager.TMP_VULN)
     y_pixels, x_pixels = array_vuln.shape  # number of pixels in x
 
     driver = gdal.GetDriverByName('GTiff')
@@ -914,7 +1294,7 @@ def Comp_Vulnerability_Scen(dirsnames:Accept_Manager):
     dataset = None
 
 
-    dst_filename= str(dirsnames.TMP_CODE)
+    dst_filename= str(manager.TMP_CODE)
     y_pixels, x_pixels = array_code.shape  # number of pixels in x
     driver = gdal.GetDriverByName('GTiff')
     dataset = driver.Create(dst_filename, x_pixels, y_pixels, gdal.GDT_Byte, 1, options=["COMPRESS=LZW"])
@@ -925,9 +1305,9 @@ def Comp_Vulnerability_Scen(dirsnames:Accept_Manager):
     dataset.FlushCache()
     dataset = None
 
-    logging.info("Computed Vulnerability for the scenario")
+    logging.info("Computed Vulnerability and code for the scenario")
 
-def match_vuln_modrec(inRas:Path, outRas:Path, MODREC:Path):
+def match_vulnerability2sim(inRas:Path, outRas:Path, MODREC:Path):
     """
     Clip the raster to the MODREC/simulation extent
 
@@ -951,7 +1331,7 @@ def match_vuln_modrec(inRas:Path, outRas:Path, MODREC:Path):
     ds = gdal.Translate(outRas, ds, projWin = [minx, maxy, maxx, miny])
     ds = None
 
-def VulMod(dirsnames:Accept_Manager,
+def compute_acceptability(manager:Accept_Manager,
            model_h:np.ndarray,
            vulnerability:np.ndarray,
            interval:int,
@@ -973,7 +1353,7 @@ def VulMod(dirsnames:Accept_Manager,
 
     logging.info(interval)
 
-    Qfile = pd.read_csv(dirsnames.POINTS_CSV)
+    Qfile = pd.read_csv(manager.POINTS_CSV)
 
     Qfile = Qfile[Qfile["Interval"]==interval]
     Qfile = Qfile.reset_index()
@@ -1003,7 +1383,7 @@ def VulMod(dirsnames:Accept_Manager,
                 accept[ij[0][loc_ij], ij[1][loc_ij]] = loc_accept[idx]
 
     #save raster
-    dst_filename = str(dirsnames.TMP_QFILES / "Q{}.tif".format(interval))
+    dst_filename = str(manager.TMP_QFILES / "Q{}.tif".format(interval))
 
     y_pixels, x_pixels = accept.shape  # number of pixels in x
     driver = gdal.GetDriverByName('GTiff')
@@ -1018,7 +1398,12 @@ def VulMod(dirsnames:Accept_Manager,
 
 def shp_to_raster(vector_fn:str, raster_fn:str, pixel_size:float = 1.):
     """
-    Convert a vector layer to a raster tiff file
+    Convert a vector layer to a raster tiff file.
+
+    The raster will contain only 2 values : 0 and 1
+
+    - 1 : the inside of the vector layer
+    - 0 : the rest == NoData/NullValue
 
     :param vector_fn: the path to the vector file
     :param raster_fn: the path to the raster file
@@ -1029,7 +1414,7 @@ def shp_to_raster(vector_fn:str, raster_fn:str, pixel_size:float = 1.):
     vector_fn = str(vector_fn)
     raster_fn = str(raster_fn)
 
-    NoData_value = np.nan
+    NoData_value = 0 # np.nan is not necessary a good idea
     # Open the data sources and read the extents
     source_ds = ogr.Open(vector_fn)
     source_layer = source_ds.GetLayer()
@@ -1043,8 +1428,13 @@ def shp_to_raster(vector_fn:str, raster_fn:str, pixel_size:float = 1.):
     # Create the destination data source
     x_res = int((x_max - x_min) / pixel_size)
     y_res = int((y_max - y_min) / pixel_size)
-    target_ds = gdal.GetDriverByName('GTiff').Create(raster_fn, x_res, y_res, 1, gdal.GDT_Float64,
-                                                     options=["COMPRESS=LZW"])
+
+    target_ds = gdal.GetDriverByName('GTiff').Create(raster_fn, 
+                                                     x_res, y_res, 
+                                                     1, 
+                                                     gdal.GDT_Byte,
+                                                     options=["COMPRESS=LZW", 
+                                                              'SPARSE_OK=TRUE'])
 
     target_ds.SetGeoTransform((x_min, pixel_size, 0, y_max, 0, -pixel_size))
     srs = osr.SpatialReference()
@@ -1053,6 +1443,92 @@ def shp_to_raster(vector_fn:str, raster_fn:str, pixel_size:float = 1.):
     band = target_ds.GetRasterBand(1)
     band.SetNoDataValue(NoData_value)
     # Rasterize the areas
-    gdal.RasterizeLayer(target_ds, [1], source_layer,None, None, [1], options=["ALL_TOUCHED=TRUE"])
+    gdal.RasterizeLayer(target_ds,
+                        bands = [1], 
+                        layer = source_layer,
+                        burn_values = [1], 
+                        options=["ALL_TOUCHED=TRUE"])
     target_ds = None
     vector_fn = raster_fn = None
+
+def vector_to_raster(layer:str,
+                     manager:Accept_Manager,
+                     attribute:str,
+                     pixel_size:float,
+                     convert_to_sparse:bool = True):
+    """
+    Convert a vector layer to a raster tiff file
+
+    :param layer: the layer name in the GDB file
+    :param vector_input: the path to the vector file
+    :param extent: the path to the extent file
+    :param attribute: the attribute to rasterize
+    :param pixel_size: the pixel size of the raster
+
+    """
+
+    layer = str(layer)
+
+    vector_input = str(manager.TMP_CODEVULNE / (layer + EXTENT))
+    extent = str(manager.SA)
+    attribute = str(attribute)
+    pixel_size = float(pixel_size)
+
+    out_file = manager.TMP_RASTERS / attribute / (layer + ".tiff")
+
+    if out_file.exists():
+        os.remove(out_file)
+
+    out_file = str(out_file)
+
+    NoData_value = 0
+
+    extent_ds:ogr.DataSource = ogr.Open(extent)
+    extent_layer = extent_ds.GetLayer()
+
+    x_min, x_max, y_min, y_max = extent_layer.GetExtent()
+
+    x_min = float(int(x_min))
+    x_max = float(np.ceil(x_max))
+    y_min = float(int(y_min))
+    y_max = float(np.ceil(y_max))
+
+    # Open the data sources and read the extents
+    source_ds:ogr.DataSource = ogr.Open(vector_input)
+    if source_ds is None:
+        logging.error(f"Could not open the data source {layer}")
+        return
+    source_layer = source_ds.GetLayer()
+
+    # Create the destination data source
+    x_res = int((x_max - x_min) / pixel_size)
+    y_res = int((y_max - y_min) / pixel_size)
+    target_ds:gdal.Driver = gdal.GetDriverByName('GTiff').Create(out_file,
+                                                     x_res, y_res, 1,
+                                                     gdal.GDT_Byte,
+                                                     options=["COMPRESS=DEFLATE",
+                                                              'SPARSE_OK=TRUE',])
+
+    target_ds.SetGeoTransform((x_min, pixel_size, 0, y_max, 0, -pixel_size))
+    srs = osr.SpatialReference()
+    srs.ImportFromEPSG(31370)
+    target_ds.SetProjection(srs.ExportToWkt())
+
+    band = target_ds.GetRasterBand(1)
+    band.SetNoDataValue(NoData_value)
+
+    # Rasterize the areas
+    gdal.RasterizeLayer(target_ds, [1], 
+                        source_layer, 
+                        options=["ATTRIBUTE="+attribute, 
+                                 "ALL_TOUCHED=TRUE"])
+    
+    if convert_to_sparse:
+        # Convert the raster to a npz containing the row and col of the non-null values
+        array = band.ReadAsArray()
+        ij = np.nonzero(array)
+        np.savez_compressed(Path(out_file).with_suffix('.npz'), row=ij[0].astype(np.int32), col=ij[1].astype(np.int32))
+
+    target_ds = None
+
+    return 0