wolfhece 2.1.120__py3-none-any.whl → 2.1.121__py3-none-any.whl

wolfhece/acceptability/acceptability_gui.py

@@ -1,8 +1,8 @@
 """
 Author: University of Liege, HECE
-Date: 2024
+Date: 2025
 
-Copyright (c) 2024 University of Liege. All rights reserved.
+Copyright (c) 2025 University of Liege. All rights reserved.
 
 This script and its content are protected by copyright law. Unauthorized
 copying or distribution of this file, via any medium, is strictly prohibited.
@@ -24,6 +24,7 @@ import matplotlib
 import shutil
 import os
 import geopandas as gpd
+import matplotlib.pyplot as plt
 from matplotlib.figure import Figure
 from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg as FigureCanvas
 from matplotlib.backends.backend_wxagg import NavigationToolbar2WxAgg as NavigationToolbar2Wx
@@ -40,7 +41,7 @@ def nullvalue_for_hole(WA):
     Sets the null value for a WolfArray to 0 (as per the convention in the interpolation routine).
     """
     WA.nullvalue = 0.
-    WA.set_nullvalue_in_mask()
+    WA.set_nullvalue_in_mask()  
 
 def read_export_z_bin(fn_read, fn_write, fn_laststep):
     """
@@ -58,15 +59,15 @@ def read_export_z_bin(fn_read, fn_write, fn_laststep):
     top = wolfres2DGPU_test.get_top_for_block(1)
     nullvalue_for_hole(wd)
     nullvalue_for_hole(top)
-    wd.array = wd.array + top.array
+    wd.array = wd.array + top.array 
     fn_write = fn_write.with_suffix('.bin')
     wd.write_all(fn_write)
     shutil.rmtree(fn_temp)
-
+    
 def riverbed_trace(fn_read_simu, fn_output, threshold):
     """
-    Recognizes the riverbed trace based on a simulation, where water depth above a given threshold is considered part of the riverbed.
-    Inputs:
+    Recognizes the riverbed trace based on a simulation, where water depth above a given threshold is considered part of the riverbed. 
+    Inputs: 
         - fn_read_simu: the simulation file to read.
         - fn_output: the location to save the riverbed trace as a .tiff file.
         - threshold: the water depth threshold above which the areas are considered riverbed.
@@ -79,7 +80,7 @@ def riverbed_trace(fn_read_simu, fn_output, threshold):
     wd.array[wd.array < threshold] = 0
     wd.as_WolfArray()
     wd.nodata=0
-    wd.write_all(Path(fn_output))
+    wd.write_all(Path(fn_output)) 
 
 def empty_folder(folder):
     """
@@ -90,9 +91,9 @@ def empty_folder(folder):
             fn = os.path.join(folder, files)
             try:
                 if os.path.isfile(fn) or os.path.islink(fn):
-                    os.unlink(fn)
+                    os.unlink(fn)  
                 elif os.path.isdir(fn):
-                    shutil.rmtree(fn)
+                    shutil.rmtree(fn)  
             except Exception as e:
                 print(f"Error when deleting file {fn}: {e}")
     else:
@@ -117,7 +118,7 @@ Note: the computations are perfomed with tifs .tif rasters but should be transla
 #----------------------------------------------------------------------------------------------------------
 
 #1 - Soustraction bathymetry.tif (from simulations) - DEM (MNT, cfr "projet tuilage") ---------------------
-
+   
 def soustraction(fn_a,fn_b,fn_result):
     with rasterio.open(fn_a) as src_a, rasterio.open(fn_b) as src_b:
         if (
@@ -127,36 +128,35 @@ def soustraction(fn_a,fn_b,fn_result):
             src_a.crs != src_b.crs
         ):
             logging.error(f"{fn_a} and {fn_b} do not have the same properties, please edit them.")
+        
 
-
-        data_a = src_a.read(1)
-        data_b = src_b.read(1)
-
+        data_a = src_a.read(1)  
+        data_b = src_b.read(1) 
+        
         #(A - B)
         data_diff = data_a - data_b
         nodata_value = src_a.nodata if src_a.nodata == src_b.nodata else None
         if nodata_value is not None:
             data_diff[(data_a == nodata_value) | (data_b == nodata_value)] = nodata_value
-
+        
         data_diff[data_diff > 5000] = 0
         labeled, n = label(data_diff)
         # Remove small objects
-        threshold = 5
+        threshold = 5 
         sizes = np.bincount(labeled.ravel())
-        idx_small = np.where(sizes <= threshold)[0]
-        data_diff[np.isin(labeled, idx_small)] = 0
-
+        idx_small = np.where(sizes <= threshold)[0] 
+        data_diff[np.isin(labeled, idx_small)] = 0    
+        
         out_meta = src_a.meta.copy()
         out_meta.update({
-            "dtype": "float32",
+            "dtype": "float32",  
             "driver": "GTiff"
         })
 
     with rasterio.open(fn_result, "w", **out_meta) as dst:
         dst.write(data_diff, 1)
-
-
-
+    
+    
 #2 - DEM (MNT) value in the buildings traces ------------------------------------------------------------------
 def mask_creation_data(mask_file, ground_file, output_file):
     with rasterio.open(mask_file) as mask_src:
@@ -170,23 +170,46 @@ def mask_creation_data(mask_file, ground_file, output_file):
 
     mask[indices] = bathy[indices]
     mask[mask <= 0] = 275
-
+    
     output_meta = mask_meta.copy()
     output_meta.update({"dtype": 'float32'})
 
     with rasterio.open(output_file, "w", **output_meta) as dst:
         dst.write(mask, 1)
-
+        
     WA_mask = WolfArray(output_file)
     WA_mask.write_all(Path(Path(output_file).parent / "MNT_computed_with_mask.bin"))
 
 def MTN_And_mask_creation_all(fn_bathy, fn_mtn_cropped, fn_where_buildings, fn_mask_final):
-    #couper_raster()
-    soustraction(fn_bathy, fn_mtn_cropped, fn_where_buildings)
+    #couper_raster() 
+    soustraction(fn_bathy, fn_mtn_cropped, fn_where_buildings) 
     mask_creation_data(fn_where_buildings, fn_mtn_cropped, fn_mask_final)
-
+    
 #--------------------------------------------------------------------------------------------------------------
 
+def create_INPUT_TEMP_OUTPUT_forScenario(maindir, study_area, scenario, simu_gpu):
+    """Creates folder for a new study area or/and scenario. The last argument simu_gpu is used when loading simulation (indicates path to the simulation folder), 
+    if not used, indicate None to ignore it."""
+    base_pathwd = Path(maindir) / "INPUT" / "WATER_DEPTH" / study_area / scenario 
+    subfolders = ["DEM_FILES", "INTERP_WD", "EXTRACTED_LAST_STEP_WD"]
+    os.makedirs(base_pathwd, exist_ok=True)
+    for folder in subfolders:
+        os.makedirs(os.path.join(base_pathwd, folder), exist_ok=True)
+    base_pathch = Path(maindir) / "INPUT" / "CHANGE_VULNE" / study_area / scenario 
+    os.makedirs(base_pathch, exist_ok=True)
+    
+    if simu_gpu != None:
+        path_bat_gpu = Path(simu_gpu) / "bathymetry.tif"
+        if path_bat_gpu.exists():
+            create_shapefile_from_prop_tif(path_bat_gpu, Path(maindir) / "INPUT" / "STUDY_AREA" / f"{study_area}.shp")
+            logging.info("Study area file created in INPUT/STUDY_AREA.")
+        else :
+            logging.error(f"Error in the study area creation : no bathymetry.tif file in the given simulation folder {simu_gpu}. Please provide it in this folder and try again.")
+
+    Accept_Manager(main_dir=maindir, Study_area=study_area, scenario=scenario)
+    logging.info(f"Files created in INPUT, TEMP and OUTPUT for the study area named '{study_area}', and the scenario named '{scenario}'")
+    return
+
 def get_transform_and_crs(tif_file):
     """
     For TIFF file manipulation, reads the CRS and the transform, and returns them.
@@ -205,17 +228,17 @@ def create_shapefile_from_prop_tif(fn_tif, shapefile_path):
         - shapefile_path: the location to save the output shapefile.
     """
     _,_,width,height,_,_ = get_header_info(fn_tif)
-    transform, crs = get_transform_and_crs(fn_tif)
+    transform, crs = get_transform_and_crs(fn_tif)                
     top_left = transform * (0, 0)
     bottom_left = transform * (0, height)
     top_right = transform * (width, 0)
     bottom_right = transform * (width, height)
-
+    
     rectangle = Polygon([top_left, top_right, bottom_right, bottom_left, top_left])
     gdf = gpd.GeoDataFrame({'geometry': [rectangle]})
     gdf.set_crs(crs, allow_override=True, inplace=True)
     gdf.to_file(shapefile_path)
-
+        
 def get_header_info(fn):
     """
     Reads the headers from the file at path 'fn'.
@@ -235,8 +258,8 @@ def get_header_comparison(list_fn):
     header_infos = [get_header_info(fn) for fn in list_fn]
     variable_names = ["dx", "dy", "nbx", "nby", "X", "Y"]
     for idx, name in enumerate(variable_names):
-        values = [header[idx] for header in header_infos]
-        if len(set(values)) > 1:
+        values = [header[idx] for header in header_infos] 
+        if len(set(values)) > 1:  
             comp = False
         else:
             comp = True
@@ -250,13 +273,13 @@ def display_info_header(self_dx, self_nbxy, self_O, fn):
     dx,dy,nbx,nby,X,Y= get_header_info(fn)
     self_dx.SetLabel(f"({dx},{dy})")
     self_nbxy.SetLabel(f"({nbx},{nby})")
-    self_O.SetLabel(f"({X},{Y})")
+    self_O.SetLabel(f"({X},{Y})")   
     return dx,dy,nbx,nby,X,Y
-
+    
 def vanish_info_header(self_dx, self_nbxy, self_O):
     self_dx.SetLabel("")
     self_nbxy.SetLabel("")
-    self_O.SetLabel("")
+    self_O.SetLabel("") 
 
 def update_info_header(self_dx, self_nbxy, self_O, fn):
     """
@@ -264,11 +287,11 @@ def update_info_header(self_dx, self_nbxy, self_O, fn):
     """
     if not os.path.exists(fn):
         os.makedirs(fn)
-
+        
     tif_files = [f for f in os.listdir(fn) if f.lower().endswith('.tif')]
     tif_list_fn = [os.path.join(fn, tif_file) for tif_file in tif_files]
-    if tif_files:
-        if get_header_comparison(tif_list_fn) :
+    if tif_files:           
+        if get_header_comparison(tif_list_fn) :        
             dx,dy,nbx,nby,X,Y = display_info_header(self_dx, self_nbxy, self_O, tif_list_fn[0])
             return dx,dy,nbx,nby,X,Y
         else:
@@ -276,8 +299,8 @@ def update_info_header(self_dx, self_nbxy, self_O, fn):
             return False, False, False, False, False, False
     else :
         vanish_info_header(self_dx, self_nbxy, self_O)
-        return False, False, False, False, False, False
-
+        return False, False, False, False, False, False       
+            
 def search_for_modif_bath_and_copy(main_gpu, from_path, path_vuln):
     """
     When loading gpu simulations for last step extraction, search for modified bath_ topography file, according to
@@ -290,9 +313,9 @@ def search_for_modif_bath_and_copy(main_gpu, from_path, path_vuln):
     curdicts = scen_manager.get_dicts(curtree)
     all_tif_bath = [scen_manager._select_tif_partname(curdict, 'bath_') for curdict in curdicts]
     all_tif_bath = [curel for curlist in all_tif_bath if len(curlist)>0 for curel in curlist  if curel.name.startswith('bath_')]
-    if len(all_tif_bath) :
+    if len(all_tif_bath) : 
         found_bath = True
-    for tif_file in all_tif_bath:
+    for tif_file in all_tif_bath: 
         found_bath = True
         with rasterio.open(tif_file) as src:
             #vuln_ files
@@ -308,7 +331,7 @@ def search_for_modif_bath_and_copy(main_gpu, from_path, path_vuln):
             output_file = path_vuln / tif_file.name.replace('bath_', 'MNTmodifs_')
             with rasterio.open(output_file, 'w', **metadata) as dst:
                 dst.write(data, 1)
-
+                
     return found_bath
 
 def mapviewer_display(list_path):
@@ -319,7 +342,7 @@ def mapviewer_display(list_path):
     dlg.Destroy()
     if ret != wx.ID_YES:
         return
-
+    
     mapviewer = WolfMapViewer(title="OUTPUT Acceptability manager")
     for path in list_path:
         myarray = WolfArray(path)
@@ -351,74 +374,74 @@ class AcceptabilityGui(wx.Frame):
             raise TypeError("The mapviewer must be a WolfMapViewer")
 
         self._mapviewer = value
-
+        
     def OnHoverEnter(self, event):
         """Dynamic colour layout 1"""
-        self._but_creation.SetBackgroundColour(wx.Colour(100,100,100))
+        self._but_creation.SetBackgroundColour(wx.Colour(100,100,100))  
         self._but_creation.Refresh()
         event.Skip()
 
     def OnHoverLeave(self, event):
         """Dynamic colour layout 2"""
-        self._but_creation.SetBackgroundColour(wx.Colour(150,150,150))
+        self._but_creation.SetBackgroundColour(wx.Colour(150,150,150))  
         self._but_creation.Refresh()
         event.Skip()
-
+        
     def layout(self, self_fct):
         """Update the layers for the main buttons"""
         font = self_fct.GetFont()
         font.SetWeight(wx.FONTWEIGHT_BOLD)
         self_fct.SetFont(font)
-        self_fct.SetBackgroundColour(wx.Colour(150,150,150))
+        self_fct.SetBackgroundColour(wx.Colour(150,150,150)) 
         self_fct.Bind(wx.EVT_ENTER_WINDOW, self.OnHoverEnter)
         self_fct.Bind(wx.EVT_LEAVE_WINDOW, self.OnHoverLeave)
-
+        
     def on_button_click(self, event):
         self.PopupMenu(self.menu)
 
     def on_menu_click(self, event):
-        """Two options for the 'Update Riverbed' button: either the new riverbed trace
-        file already exists and the user selects it, or it does not exist, and the user points to
+        """Two options for the 'Update Riverbed' button: either the new riverbed trace 
+        file already exists and the user selects it, or it does not exist, and the user points to 
         a no-overflow simulation, allowing the code to create the trace."""
         menu_id = event.GetId()
-        if menu_id == 1:
+        if menu_id == 1: 
             logging.info("Option 1 : the file exists, pointing towards it.")
-            dlg = wx.FileDialog(None, "Please select the .tiff file with the NEW trace of the riverbed.",
-                    style=wx.FD_OPEN | wx.FD_FILE_MUST_EXIST,
+            dlg = wx.FileDialog(None, "Please select the .tiff file with the NEW trace of the riverbed.", 
+                    style=wx.FD_OPEN | wx.FD_FILE_MUST_EXIST, 
                     wildcard="TIFF files (*.tiff)|*.tiff")
 
             if dlg.ShowModal() == wx.ID_OK:
-                selected_file = Path(dlg.GetPath())
+                selected_file = Path(dlg.GetPath())                 
                 copied_file = self._manager.OUT_SCEN_DIR / "copy_file"
                 shutil.copy(selected_file, copied_file)
                 logging.info(f"File copied to: {copied_file}")
-
+                
                 new_name = self._manager.OUT_MASKED_RIVER_S
-
+                
                 with wx.MessageDialog(self, f"Modified riverbed imported and called Masked_River_extent_scenarios.tiff.",
                     "File imported.", wx.OK | wx.ICON_INFORMATION) as dlg:
                     dlg.ShowModal()
-
+                
                 if new_name.exists():
                     new_name.unlink()
-
+                
                 copied_file.rename(new_name)
                 logging.info(f"File renamed to: {new_name}")
             else:
                 logging.info('No file selected. Please try again.')
-
+    
         elif menu_id == 2: #No file, so need to create
             logging.info("Option 2 : pointing to simulation with low discharge (no overflows!).")
-
+                    
             with wx.DirDialog(self, "Please select a simul_gpu_results folder of a simulation with low discharges (no overflows).", style=wx.DD_DEFAULT_STYLE) as dir_dlg:
-                if dir_dlg.ShowModal() == wx.ID_OK:
-                    selected_folder = Path(dir_dlg.GetPath())
-                    if os.path.basename(selected_folder) == "simul_gpu_results" :
-                        logging.info(f"Selected folder: {selected_folder}")
+                if dir_dlg.ShowModal() == wx.ID_OK: 
+                    selected_folder = Path(dir_dlg.GetPath())  
+                    if os.path.basename(selected_folder) == "simul_gpu_results" : 
+                        logging.info(f"Selected folder: {selected_folder}") 
                         fn_output = self._manager.OUT_MASKED_RIVER_S
                         dlg = wx.TextEntryDialog(self, "What water depth threshold (in meters) should be used to define the riverbed trace, above which\n"
                                                  "the water depth is considered part of the riverbed? Use a dot as a decimal separator (e.g 0.3).", "Type a water depth threshold in [m] (e.g 0.3)", "")
-
+                        
                         if dlg.ShowModal() == wx.ID_OK:
                             while True:
                                 try:
@@ -452,17 +475,19 @@ class AcceptabilityGui(wx.Frame):
 
                         else:
                             logging.info("Cancelled.")
-                            dlg.Destroy()
+                            dlg.Destroy() 
                     else:
                         logging.info("No folder (or wrong one) selected. Please try again (must be simul_gpu_results).")
-
+    
+        
     def layout_listbox(self, self_fct):
         """Changes the layout for the listbox : light grey."""
         self_fct.SetBackgroundColour(wx.Colour(220, 220, 220))
 
     def InitUI(self):
         self.gpu_bathy = None
-
+        self.maindir = None
+        
         sizer_hor_main = wx.BoxSizer(wx.HORIZONTAL)
         sizer_vert1 = wx.BoxSizer(wx.VERTICAL)
         sizer_hor_threads = wx.BoxSizer(wx.HORIZONTAL)
@@ -473,129 +498,132 @@ class AcceptabilityGui(wx.Frame):
         sizer_hor4 = wx.BoxSizer(wx.HORIZONTAL)
         sizer_hor_scen = wx.BoxSizer(wx.HORIZONTAL)
 
-        # 1st LINE
+        # 1st LINE - Loading acceptability folder
         panel = wx.Panel(self)
         self._but_maindir = wx.Button(panel, label='Main Directory')
+        self._but_maindir.SetToolTip("To indicate where the main acceptability\n folder is located.")
         self._but_maindir.SetFont(wx.Font(9, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_BOLD))
         self._but_maindir.Bind(wx.EVT_BUTTON, self.OnMainDir)
-
+        
         self._listbox_studyarea = wx.ListBox(panel, choices=[], style=wx.LB_SINGLE)
         self.layout_listbox(self._listbox_studyarea)
         self._listbox_studyarea.Bind(wx.EVT_LISTBOX, self.OnStudyArea)
-        self._listbox_studyarea.SetToolTip("Choose the study area")
+        self._listbox_studyarea.SetToolTip("Choose the study area existed in the folder.")
 
         self._listbox_scenario = wx.ListBox(panel, choices=[], style=wx.LB_SINGLE)
-        self.layout_listbox(self._listbox_scenario)
+        self.layout_listbox(self._listbox_scenario) 
         self._listbox_scenario.Bind(wx.EVT_LISTBOX, self.OnScenario)
-        self._listbox_scenario.SetToolTip("Choose the scenario")
-
-        # 2nd LINE
-        self._but_checkfiles = wx.Button(panel, label='Check directories\n structure')
+        self._listbox_scenario.SetToolTip("Choose the acceptability scenario.")
+        
+        sizer_ver_small = wx.BoxSizer(wx.VERTICAL)
+        self._but_checkfiles = wx.Button(panel, label='Check structure')
         self._but_checkfiles.Bind(wx.EVT_BUTTON, self.OnCheckFiles)
-        self._listbox_scenario.SetToolTip("Check if the folder is correctly structured")
-
-        sizer_hor1_1.Add(self._but_checkfiles, 1, wx.ALL | wx.EXPAND, 0)
-
-        # Hydrodynamic part
-        self._but_checksim = wx.Button(panel, label='Check existing interpolated\n free surfaces')
+        self._but_checkfiles.SetToolTip("Checks if the folder is correctly structured\n with INPUT, TEMP, OUTPUT.")
+        self._but_checksim = wx.Button(panel, label='Check simulations')
+        self._but_checksim.SetToolTip("Displays the loaded simulations, interpolated in INTERP_WD.")
         self._but_checksim.Bind(wx.EVT_BUTTON, self.OnHydrodynInput)
-
-        sizer_hor1_1.Add(self._but_checksim, 1, wx.ALL | wx.EXPAND, 0)
-
-        self._but_loadgpu = wx.Button(panel, label='Load and extract\n gpu simulations')
+        
+        self._but_checkpond= wx.Button(panel, label='Check ponderation')
+        self._but_checkpond.Bind(wx.EVT_BUTTON, self.OnCheckPond)
+        self._but_checkpond.SetToolTip("Displays a graph of the computed weighting coefficient\n of the final acceptability computations.")
+        
+        # 2nd LINE - Hydrodynamic part     
+        self._but_loadgpu = wx.Button(panel, label='Load new\n hydraulic scenarios')
+        self._but_loadgpu.SetToolTip("To load or change the hydraulic simulations")
+        self._but_loadgpu.SetFont(wx.Font(9, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_BOLD))
         self._but_loadgpu.Bind(wx.EVT_BUTTON, self.OnLoadingSimu)
         sizer_hor1_1.Add(self._but_loadgpu, 1, wx.ALL | wx.EXPAND, 0)
-
+        
 
         self._check_listbox = wx.CheckListBox(panel, choices=[], style=wx.LB_MULTIPLE | wx.CHK_CHECKED)
-        self.layout_listbox(self._check_listbox)
+        self.layout_listbox(self._check_listbox) 
         self.sims = {}
         sizer_hor1_1.Add(self._check_listbox, 1, wx.ALL | wx.EXPAND, 0) #ajouter!! sinon s'affiche pas
 
         self._but_DEM = wx.Button(panel, label='Check DEM inputs\n for interpolation')
+        self._but_DEM.SetToolTip("To display the existing DEM input for the interpolation of the simulated free surfaces.")
         self._but_DEM.Bind(wx.EVT_BUTTON, self.OnDEM)
         sizer_hor1_1.Add(self._but_DEM, 1, wx.ALL | wx.EXPAND, 0)
-
+        
         self._but_extrinterp = wx.Button(panel, label='Reading and interpolating\n free surface')
+        self._but_extrinterp.SetToolTip("To read the simulation, and created the hydraulic input for\n acceptability (interpolated simulated free surfaces)")
         self._but_extrinterp.Bind(wx.EVT_BUTTON, self.OnInterpolation)
         sizer_hor1_1.Add(self._but_extrinterp, 1, wx.ALL | wx.EXPAND, 0)
 
         sizer_hor1.Add(self._but_maindir, 2, wx.ALL | wx.EXPAND, 0)
         sizer_hor1.Add(self._listbox_studyarea, 1, wx.ALL | wx.EXPAND, 0)
         sizer_hor1.Add(self._listbox_scenario, 1, wx.ALL | wx.EXPAND, 0)
-
+        sizer_hor1.Add(sizer_ver_small, 0, wx.ALL | wx.EXPAND, 5)
 
         #3rd line
         sizer_hor_threads = wx.BoxSizer(wx.HORIZONTAL)
         text_dx = wx.StaticText(panel, label='Resolution (dx,dy) [m]:')
         self.input_dx = wx.StaticText(panel)
-        self.input_dx.SetMinSize((60, -1))
+        self.input_dx.SetMinSize((80, -1))
         text_nbxy = wx.StaticText(panel, label='(nbx, nby):')
         self.input_nbxy = wx.StaticText(panel)
-        self.input_nbxy.SetMinSize((70, -1))
+        self.input_nbxy.SetMinSize((90, -1))
         text_O = wx.StaticText(panel, label='Origin (X,Y):')
         self.input_O = wx.StaticText(panel)
-        self.input_O.SetMinSize((160, -1))
+        self.input_O.SetMinSize((170, -1))
         text_threads = wx.StaticText(panel, label='Number of threads:')
         self._nb_process = wx.SpinCtrl(panel, value=str(os.cpu_count()), min=1, max=os.cpu_count())
-        self._nb_process.SetToolTip("Number of threads to use")
-
-        self._but_sacreation = wx.Button(panel, label='SA creation')
-        self._but_sacreation.Bind(wx.EVT_BUTTON, self.OnSAcreation)
-
+        self._nb_process.SetToolTip("Number of threads to be used in the computations.")
+        
         sizer_hor_threads.Add(text_dx, 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 1)
         sizer_hor_threads.Add(self.input_dx, 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 1)
         sizer_hor_threads.Add(text_nbxy, 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 1)
         sizer_hor_threads.Add(self.input_nbxy, 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 1)
         sizer_hor_threads.Add(text_O, 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 1)
         sizer_hor_threads.Add(self.input_O, 1, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 1)
-        sizer_hor_threads.Add(self._but_sacreation, 1, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 2)
         sizer_hor_threads.Add(text_threads, 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 1)
         sizer_hor_threads.Add(self._nb_process, 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 1)
-
+        
         # 3 last lines + scenarios
         #--------------------------
         self._but_creation = wx.Button(panel, label='DataBase Creation')
-        self.layout(self._but_creation)
+        self.layout(self._but_creation) 
         self._but_creation.Bind(wx.EVT_BUTTON, self.OnCreation)
-
+        
         self._steps_db = wx.CheckListBox(panel, choices=steps_base_data_creation.get_list_names(), style=wx.LB_MULTIPLE | wx.CHK_CHECKED)
 
         self._but_vulnerability = wx.Button(panel, label='Vulnerability')
-        self.layout(self._but_vulnerability)
-        self._but_vulnerability.Bind(wx.EVT_BUTTON, self.OnVulnerability)
+        self.layout(self._but_vulnerability) 
+        self._but_vulnerability.Bind(wx.EVT_BUTTON, self.OnVulnerability)       
         step_Vuln_without_withoutscenarios = [item for item in steps_vulnerability.get_list_names() if item != 'APPLY_SCENARIOSVULN - 4']
         self._steps_vulnerability = wx.CheckListBox(panel, choices=step_Vuln_without_withoutscenarios, style=wx.LB_MULTIPLE | wx.CHK_CHECKED)
-
-
+        
         # Scenarios specifics --
         self._but_checkscenario = wx.Button(panel, label='Check existing scenarios')
+        self._but_checkscenario.SetToolTip("To display the scenario to be taken into account in CHANGE_VULNE.")
         self._but_checkscenario.Bind(wx.EVT_BUTTON, self.OnCheckScenario)
-
-
+        
         self._but_upriverbed = wx.Button(panel, label="Update riverbed")
+        self._but_upriverbed.SetToolTip("To create the raster of the riverbed trace.")
         self._but_upriverbed.Bind(wx.EVT_BUTTON, self.on_button_click)
 
         self.menu = wx.Menu()
         self.menu.Append(1, "File of riverbed trace exists.")
         self.menu.Append(2, "Point to a low discharge simulation and calculate the riverbed trace.")
         self.menu.Bind(wx.EVT_MENU, self.on_menu_click)
-
+        
         self._but_toggle_scen = wx.ToggleButton(panel, label="Accounting for scenarios")
+        self._but_toggle_scen.SetToolTip("To be activated to surimpose the vuln_ files, \n and so to take into account scenarios")
         self.toggle_state = False
         self._but_toggle_scen.Bind(wx.EVT_TOGGLEBUTTON, self.OnToggle)
-
+        
         sizer_hor_scen.Add(self._but_checkscenario, 1, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 1)
         sizer_hor_scen.Add(self._but_upriverbed, 1, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 1)
         sizer_hor_scen.Add(self._but_toggle_scen, 1, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 1)
-
+        
         self._but_toggle_resamp = wx.ToggleButton(panel, label="Resampling [m]:")
+        self._but_toggle_resamp.SetToolTip("To compute the final raster with a coarser resolution than the original one.")
         self.toggle_resamp_state = False
         self._but_toggle_resamp.Bind(wx.EVT_TOGGLEBUTTON, self.OnToggleResampling)
         sizer_hor_scen.Add(self._but_toggle_resamp, flag=wx.ALIGN_CENTER | wx.TOP)
         self._but_resampling = wx.SpinCtrl(panel, value="100", min=1, max=1000)
         sizer_hor_scen.Add(self._but_resampling, flag=wx.ALIGN_CENTER | wx.TOP)
-
+                
         #--
 
         self._but_acceptability = wx.Button(panel, label='Acceptability')
@@ -616,6 +644,10 @@ class AcceptabilityGui(wx.Frame):
         sizer_hor4.Add(self._steps_acceptability, 1, wx.ALL | wx.EXPAND, 0)
 
         #Lines order
+        sizer_ver_small.Add(self._but_checkfiles, 0, wx.ALL | wx.EXPAND, 1)
+        sizer_ver_small.Add(self._but_checksim, 0, wx.ALL | wx.EXPAND, 1)
+        sizer_ver_small.Add(self._but_checkpond, 0, wx.ALL | wx.EXPAND, 1)
+        
         sizer_vert1.Add(sizer_hor1, 1, wx.EXPAND, 0)
         sizer_vert1.Add(sizer_hor1_1, 1, wx.EXPAND, 0)
         sizer_vert1.Add(sizer_hor_threads, 0, wx.EXPAND, 0)
@@ -623,49 +655,8 @@ class AcceptabilityGui(wx.Frame):
         sizer_vert1.Add(sizer_hor_scen, 1, wx.EXPAND, 0)
         sizer_vert1.Add(sizer_hor3, 1, wx.EXPAND, 0)
         sizer_vert1.Add(sizer_hor4, 1, wx.EXPAND, 0)
-        # ------
-
-        sizer_vert2 = wx.BoxSizer(wx.VERTICAL)
-
-        self._listbox_returnperiods = wx.ListBox(panel, choices=[], style=wx.LB_SINGLE)
-        self._listbox_returnperiods.SetToolTip("All available return periods in the database")
-
-        self._listbox_sims = wx.ListBox(panel, choices=[], style=wx.LB_SINGLE)
-        self._listbox_sims.SetToolTip("All available simulations in the database")
-
-        self._listbox_sims.Bind(wx.EVT_LISTBOX, self.OnSims)
-        self._listbox_sims.Bind(wx.EVT_LISTBOX_DCLICK, self.OnSimsDBLClick)
-
-        sizer_vert2.Add(self._listbox_returnperiods, 1, wx.EXPAND, 0)
-        sizer_vert2.Add(self._listbox_sims, 1, wx.EXPAND, 0)
-
-        # ------
-
-        sizer_vert3 = wx.BoxSizer(wx.VERTICAL)
-
-        matplotlib.use('WXAgg')
-
-        self._figure = Figure(figsize=(5, 4), dpi=100)
-        self._axes = self._figure.add_subplot(111)
-        self._axes.set_ylabel("Weighting coefficients")
-        self._axes.set_xlabel("Return period")
-        self._axes.grid(axis='y', linestyle='--', alpha=0.7)
-
-        self._canvas = FigureCanvas(panel, -1, self._figure)
-        self._toolbar = NavigationToolbar2Wx(self._canvas)
-        self._toolbar.Realize()
-
-        sizer_vert3.Add(self._canvas, 1, wx.EXPAND, 0)
-        sizer_vert3.Add(self._toolbar, 0, wx.LEFT | wx.EXPAND, 0)
 
-        # ------
-
-        sizer_hor_main.Add(sizer_vert1, 1, wx.EXPAND, 0)
-        sizer_hor_main.Add(sizer_vert2, 1, wx.EXPAND, 0)
-        sizer_hor_main.Add(sizer_vert3, 1, wx.EXPAND, 0)
-
-        panel.SetSizer(sizer_hor_main)
-        panel.Layout()
+        sizer_hor_main.Add(sizer_vert1, proportion=1, flag=wx.EXPAND, border=0)
 
         #Disabled if Main Directory + SA + Scenario not selected
         self._but_acceptability.Enable(False)
@@ -674,15 +665,19 @@ class AcceptabilityGui(wx.Frame):
         self._but_checkfiles.Enable(False)
         self._but_DEM.Enable(False)
         self._but_extrinterp.Enable(False)
-        self._but_loadgpu.Enable(False)
         self._but_toggle_scen.Enable(False)
         self._but_toggle_resamp.Enable(False)
         self._but_upriverbed.Enable(False)
+        self._but_checkpond.Enable(False)
         self._but_checkscenario.Enable(False)
         self._but_checksim.Enable(False)
-        self._but_sacreation.Enable(False)
         self._but_creation.Enable(False)
-
+        self._but_loadgpu.Enable(False)
+        
+        panel.SetSizer(sizer_hor_main)
+        panel.Layout()
+        
+        
     def OnSims(self, e:wx.ListEvent):
         """ Load sim into the mapviewer """
         pass
@@ -707,122 +702,297 @@ class AcceptabilityGui(wx.Frame):
             logging.error("No main directory selected -- Nothing to check")
             return
 
-        ret = self._manager.check_files()
-
-        if ret == "":
-            logging.info("The folder is well structured")
-            with wx.MessageDialog(self, "The folder is well structured", "Info", wx.OK | wx.ICON_INFORMATION) as dlg:
-                dlg.ShowModal()
-        else:
-            logging.error(f"Missing files: {ret}")
-            with wx.MessageDialog(self, f"Missing files: \n{ret}", "Error", wx.OK | wx.ICON_ERROR) as dlg:
+        i=self._manager.check_inputs()
+            
+        if i == False :
+            logging.error(f"Missing files in INPUT. Please provide them by following the right structure.")
+            with wx.MessageDialog(self, f"Missing files in INPUT. Inputs can not be created automatically : you must provide them.\n Please read the logs and terminal to see the missing ones.", "Error", wx.OK | wx.ICON_ERROR) as dlg:
                 dlg.ShowModal()
+            return
+        else :
+            if (self._manager._study_area == None) or (self._manager._scenario == None):
+                logging.error(f"No study area and/or scenario selected, no check of TEMP and OUTPUT.")
+                with wx.MessageDialog(self, f"INPUT is well structured, but TEMP and OUTPUT have not been checked because there is no study area and scenario selected.", "Checking", wx.OK | wx.ICON_INFORMATION) as dlg:
+                        dlg.ShowModal()
+            else:
+                logging.info(f"The folder is well structured.")
+                t=self._manager.check_temporary()
+                o=self._manager.check_outputs()
+                with wx.MessageDialog(self, f"Main directory is checked.\nINPUT is well structured, and TEMP and OUTPUT have been checked. If folders were missing, they have been created\nMain directory at {self.maindir}", "Checking", wx.OK | wx.ICON_INFORMATION) as dlg:
+                        dlg.ShowModal()
 
-
+            
     def OnHydrodynInput(self,e):
         """ A test to check if the FILLED water depths files exist.
             -If YES : the code can go on
             -If NO : either need to be computed, either the code will use the baseline ones
         """
-
+        
         if self._manager is None:
             logging.error("No main directory selected -- Nothing to check")
             return
 
         paths_FilledWD = self._manager.get_sims_files_for_scenario()
-
+        
         if len(paths_FilledWD) == 0 :
             logging.info("There are no interpolated free surface files.")
-            dialog = wx.MessageDialog(None, "There are no interpolated free surface files. Please choose an action.", "Choose an option",
+            dialog = wx.MessageDialog(None, "There are no interpolated free surface files. Please choose an action.", "Checking- Choose an option", 
                                    wx.YES_NO | wx.CANCEL | wx.ICON_QUESTION)
-
-            dialog.SetYesNoLabels("Use the ones in the Scenario_baseline", "Load other simulations")
-            response = dialog.ShowModal()
+        
+            dialog.SetYesNoLabels("Use the ones in the scenario_baseline (assumption)", "Load other simulations")  
+            response = dialog.ShowModal() 
 
             if response == wx.ID_YES:
                 logging.info("Decision of using baseline simulations.")
                 paths_FilledWD_base = self._manager.get_sims_files_for_baseline()
                 if len(paths_FilledWD_base) == 0 :
-                    logging.info("Cannot select files in the _baseline folder.")
+                    logging.info("Cannot select files in the _baseline folder (no files or no folder!).")
                 else:
                     self._manager.copy_tif_files(paths_FilledWD_base, self._manager.IN_SA_INTERP)
-
+                                
             elif response == wx.ID_NO:
                 logging.info("Decision of loading simulations.")
-                with wx.MessageDialog(self, f"Please use the 'Load gpu simulations folder' button of the manager and follow the instructions.", "Redirecting",
-                                      wx.OK | wx.ICON_INFORMATION) as dlg:
+                with wx.MessageDialog(self, f"Please use the 'Load gpu simulations folder' button of the manager and follow the instructions.", "Redirecting", 
+                                      wx.OK | wx.ICON_INFORMATION) as dlg:                        
                     dlg.ShowModal()
             else:
                 logging.info("Cancelled")
-
-            dialog.Destroy()
-
+            
+            dialog.Destroy() 
+                
         else:
             name_paths_FilledWD = []
-
+        
             for names in paths_FilledWD:
-                logging.info(f"Interpolated free surface file found: {names.name}.")
+                logging.info(f"Interpolated free surface file(s) found: {names.name}. \n Reminder : the names of the simulations MUST be 'T.' or 'Q.' with '.' the return period.")
                 name_paths_FilledWD.append(names.name)
-            with wx.MessageDialog(self,
-                                f"{len(paths_FilledWD)} files of interpolated free surface found in the folder : {name_paths_FilledWD}. If you want to change them, click on the 'Load gpu simulations folder button.",
-                                "Information",
+            with wx.MessageDialog(self, 
+                                f"{len(paths_FilledWD)} file(s) of interpolated free surface found in the folder : {name_paths_FilledWD}.", 
+                                "Information", 
                                 style=wx.OK | wx.ICON_INFORMATION) as dlg:
                 dlg.ShowModal()
-            #display_info_header(self.input_dx, self.input_nbxy, self.input_O, paths_FilledWD[0].with_suffix(".tif"))
             update_info_header(self.input_dx,self.input_nbxy,self.input_O,self._manager.IN_SA_INTERP)
+                
+    def OnCheckPond(self,e):
+        ponds = self._manager.get_ponderations()
+        if isinstance(ponds, pd.DataFrame):
+            logging.info(f"Plotting the coefficients graph.")
+            ponds.plot(kind='bar', color='gray', edgecolor='black')
+            plt.ylabel("Weighting coefficients [-]")  
+            plt.xlabel("Return period [years]")  
+            plt.grid(axis='y', linestyle='--', alpha=0.7) 
+            plt.show()
+        else:
+            with wx.MessageDialog(self, 
+                                "No coefficients computed, because no return period found in the interpolated simulation folder. Try after loading gpu simulations", 
+                                "Checking", 
+                                style=wx.OK | wx.ICON_INFORMATION) as dlg:
+                dlg.ShowModal()
+
+    
+    def OnMainDir(self, e):
+        """Selects the main directory to be read."""
+        vanish_info_header(self.input_dx,self.input_nbxy,self.input_O)
+        
+        with wx.DirDialog(self, "Choose the main directory containing the data (folders INPUT, TEMP and OUTPUT):",
+                          style=wx.DD_DEFAULT_STYLE
+                          ) as dlg:
+
+            if dlg.ShowModal() == wx.ID_OK:
+                self._manager = Accept_Manager(dlg.GetPath())
+                self.maindir=dlg.GetPath()
+                folders = ["INPUT", "TEMP", "OUTPUT"]
+
+                if all(os.path.isdir(os.path.join(self.maindir, folder)) for folder in folders) == False:
+                    logging.info("Folder not loaded (incorrect structure).")
+                    wx.MessageBox(
+                            f"Missing folders among INPUT, TEMP and OUTPUT. Please organize correctly this folder.",
+                            "Error",
+                            wx.OK | wx.ICON_ERROR
+                            )
+                    return
+
+                self._but_acceptability.Enable(True)
+                self._but_vulnerability.Enable(True)
+                self._but_creation.Enable(True)
+                self._but_checkfiles.Enable(True)
+                self._but_toggle_scen.Enable(True)
+                self._but_toggle_resamp.Enable(True)
+                self._but_upriverbed.Enable(True)
+                self._but_checkscenario.Enable(True)
+                self._but_checkpond.Enable(True)
+                self._but_checksim.Enable(True)
+                self._but_loadgpu.Enable(True)
+
+                self._listbox_scenario.Clear()
+                studyareas = self._manager.get_list_studyareas()
+                if len(studyareas) == 0 :
+                    logging.info("Folder loaded but no study areas found in the folder (INPUT/STUDY_AREA). Please use the button to load hydraulic simulations in the manager.")
+                    return
+                self._listbox_studyarea.Clear()
+                self._listbox_studyarea.InsertItems(studyareas, 0)
+                
+                logging.info("All the files are present")
+            else:
+                return
+
+    def OnStudyArea(self, e):
+        """ Change the study area """
+        if self._manager is None:
+            return
+        vanish_info_header(self.input_dx,self.input_nbxy,self.input_O)
+        self._listbox_scenario.Clear()
+        study_area:str = self._manager.get_list_studyareas(with_suffix=True)[e.GetSelection()]
+        
+        self._manager.change_studyarea(study_area)
+
+        sc = self._manager.get_list_scenarios()
+        if len(sc)!=0:
+            self._listbox_scenario.InsertItems(sc, 0)
+        else :
+            logging.error("No scenario available associated with this study area.")
+                   
+        if self.mapviewer is not None:
+            tmp_path = self._manager.IN_STUDY_AREA / study_area
+
+            from ..PyDraw import draw_type
+            if not tmp_path.stem in self.mapviewer.get_list_keys(drawing_type=draw_type.VECTORS):
+                self.mapviewer.add_object('vector', filename=str(tmp_path), id=tmp_path.stem)
+                self.mapviewer.Refresh()
 
+    def OnScenario(self, e):
+        """ Change the scenario """
+        if self._manager is None:
+            return
+        scenario = self._manager.get_list_scenarios()[e.GetSelection()]
+        
+        self._manager.change_scenario(scenario)
+        create_INPUT_TEMP_OUTPUT_forScenario(self.maindir, self._manager.Study_area, self._manager.scenario, None)
+        update_info_header(self.input_dx,self.input_nbxy,self.input_O,self._manager.IN_SA_INTERP)      
+        
+    def OnCreation(self, e):
+        """ Create the database """
+        if self._manager is None:
+            return
+        
+        dx,_,_,_,_,_ = update_info_header(self.input_dx,self.input_nbxy,self.input_O,self._manager.IN_SA_INTERP)
+        resolution = dx
+        if resolution == '':
+            wx.MessageBox(
+                        f"There are no files in INTERP_WD lease, use first the buttons at the second line.",
+                        "Attention",
+                        wx.OK | wx.ICON_ERROR
+                        )
+        else :           
+            steps = list(self._steps_db.GetCheckedStrings())
+            steps = [int(cur.split('-')[1]) for cur in steps]
+            
+            if len(steps) != 0:
+                
+                wx.MessageBox(
+                        f"The database will now be created, with a resolution of {dx}. This process may take some time, and the window may temporarily stop responding.",
+                        "Information",
+                        wx.OK | wx.ICON_INFORMATION
+                        )
+                Base_data_creation(self._manager.main_dir, 
+                                   Study_area=self._manager.Study_area,
+                                   number_procs=self._nb_process.GetValue(), 
+                                   resolution=dx, 
+                                   steps=steps)
+            
+                wx.MessageBox(
+                            "The database is created with the selected steps.",
+                            "Information",
+                            wx.OK | wx.ICON_INFORMATION
+                            )
+            else :
+                wx.MessageBox(
+                            f"No steps selected. The code for the DataBase creation will consider all steps by default, , with a resolution of {dx}. This process may take some time, and the window may temporarily stop responding.",
+                            "Information",
+                            wx.OK | wx.ICON_INFORMATION
+                            )
+                Base_data_creation(self._manager.main_dir, 
+                                Study_area=self._manager.Study_area,
+                                number_procs=self._nb_process.GetValue(), 
+                                resolution=dx)
+                wx.MessageBox(
+                            "The database is created for every steps.",
+                            "Information",
+                            wx.OK | wx.ICON_INFORMATION
+                            )
+                
     def OnLoadingSimu(self,e):
         """ Link between acceptability and simulations
-            -Either the last steps of the steady simulations for the scenarios already exist : only have to point towards them, then the free surfaces are filled
-            -Or they dont exist and need to be done outside this manager
+            -Load a hydraulic scenarios from the scenario manager
+            -Create scenario and study area if needed.
         """
-
-        dlg = wx.DirDialog(None, "Please select the scenario manager folder of the scenario manager (containing the scenarios, the folder discharge, the scripts.py...)", style=wx.DD_DEFAULT_STYLE)
+        
+        dlg = wx.DirDialog(None, "Please select the main scenario manager folder (containing the scenarios, the folder discharge, the scripts.py...), named after the STUDY AREA.", style=wx.DD_DEFAULT_STYLE)
         if dlg.ShowModal() == wx.ID_OK:
-            main_gpu = Path(dlg.GetPath())
-            logging.info(f"Selected folder for GPU result : {main_gpu}")
-            dlg = wx.DirDialog(None, "Please select the simulations folder (containing the sim_ folders) of the specific hydraulic scenario.", defaultPath=str(main_gpu), style=wx.DD_DEFAULT_STYLE)
+            main_gpu = Path(dlg.GetPath()) 
+            study_area = main_gpu.name
+            logging.info(f"Selected folder for GPU result such as the STUDY AREA is {study_area}")
+            dlg = wx.DirDialog(None, "Please select the scenarios folder (containing the 'simulations' folder) of the specific HYDRAULIC SCENARIO.", defaultPath=str(main_gpu), style=wx.DD_DEFAULT_STYLE)
             if dlg.ShowModal() == wx.ID_OK:
-                hydraulic_scen = Path(dlg.GetPath())
-                logging.info(f"Selected hydraulic scenario : {hydraulic_scen}")
+                scenario = Path(dlg.GetPath())
+                hydraulic_scen=scenario.joinpath("simulations")
+                scenario=scenario.name
+                logging.info(f"Selected hydraulic scenario : {scenario}")
+                create_INPUT_TEMP_OUTPUT_forScenario(self.maindir, study_area, scenario, main_gpu)
+                self._manager.change_studyarea(study_area+'.shp')
+                self._manager.change_scenario(scenario)
+                
+                
+ 
+                self._listbox_studyarea.Clear()
+                self._listbox_studyarea.InsertItems(self._manager.get_list_studyareas(), 0)
+                self._listbox_scenario.Clear()
+                self._listbox_scenario.InsertItems(self._manager.get_list_scenarios(), 0)
+                
+                #Blue color of selection even if not directly clicked :
+                index_to_select = self._listbox_scenario.FindString(scenario)
+                if index_to_select != wx.NOT_FOUND:
+                    self._listbox_scenario.SetSelection(index_to_select)
+                self._listbox_scenario.SetItemBackgroundColour(index_to_select, wx.Colour(0, 120, 215))  
+                
+                index_to_select = self._listbox_studyarea.FindString(study_area)
+                if index_to_select != wx.NOT_FOUND:
+                    self._listbox_studyarea.SetSelection(index_to_select)
+                self._listbox_studyarea.SetItemBackgroundColour(index_to_select, wx.Colour(0, 120, 215))  
+                self._listbox_studyarea.Refresh()
+                self._listbox_scenario.Refresh()                
+                
             else:
                 logging.error('No hydraulic scenario selected.')
         else:
             logging.error('No folder found / selected. Please try again.')
-
         self._check_listbox.Clear()
         self.sims = {}
-        path_LastSteps = Path(self._manager.IN_SA_EXTRACTED)
-        empty_folder(path_LastSteps)
-
-        #self.datadir_gpu_sim = main-gpu
         for subdir in hydraulic_scen.iterdir():
             if subdir.is_dir() and subdir.name.startswith("sim_"):
-                self.sims[subdir.name] = subdir
+                self.sims[subdir.name] = subdir 
             else:
                 logging.info('No folder sim_ found / selected. Please try again.')
         self.datadir_simulations = hydraulic_scen
         self.file_paths = {Path(sim).name: Path(sim) for sim in sorted(self.sims.keys())}
         self._check_listbox.Set(sorted(sim for sim in self.sims.keys()))
-
+        
         logging.info(f"GPU simulations loaded in the checkbox.\n\nPlease select the ones you want to interpolate and use the button 'Reading and interpolating free surface'.")
-
         message = "GPU simulations loaded in the checkbox\n\nPlease select the ones you want to interpolate and use the button 'Reading and interpolating free surface'."
-
+            
         found_bath = search_for_modif_bath_and_copy(Path(main_gpu), Path(hydraulic_scen.parent), self._manager.IN_CH_SA_SC)
         if found_bath :
             message+= "\nIn addition, modification files for bathymetry (bath_) have been found in the gpu simulations, a copy has been made for a change in the vulnerability and DEM (see vuln_ and MNTmodifs_ in CHANGE_VULNE). Please edit them."
             logging.info(f"Modification files for bathymetry (bath_) have been found in the gpu simulations, a copy has been made for a change in the vulnerability and DEM (see vuln_ and MNTmodifs_ in CHANGE_VULNE). Please edit them.")
-
         self.gpu_bathy = hydraulic_scen.parent / "__bathymetry.tif"
         self._but_extrinterp.Enable(True)
         self._but_DEM.Enable(True)
-        with wx.MessageDialog(self,
-                                message,
-                                "Information",
+        with wx.MessageDialog(self, 
+                                message, 
+                                "Information", 
                                 style=wx.OK | wx.ICON_INFORMATION) as dlg:
             dlg.ShowModal()
-
+                 
     def OnDEM(self,e):
         """Import and create the inputs for the interpolation routine holes.exe (name including 'MNT_...' and 'MNT_..._with_mask'.
         See function MTN_And_mask_creation_all"""
@@ -847,71 +1017,80 @@ class AcceptabilityGui(wx.Frame):
             else :
                 logging.info("No update of DEM_FILES.")
                 return
-
-
-        #DEM and masked DEM creation
+        
         with wx.FileDialog(self, "Please select the DEM file in .tif format (without modifications).", wildcard="TIFF files (*.tif)|*.tif",
                         style=wx.FD_OPEN | wx.FD_FILE_MUST_EXIST) as dlg:
-            if dlg.ShowModal() == wx.ID_OK:
-                path_DEM_base = dlg.GetPath()
-                logging.info("DEM file selected.")
-
-
-        dialog = wx.MessageDialog(None, f"Please modify the 'MNTmodifs_' files in INPUT\CHANGE_VULNE\... as in the hydraulic scenario you want to study.", "Confirmation", wx.YES_NO | wx.ICON_QUESTION)
-        dialog.SetYesNoLabels("Done, continue", "Not done, stop")
-        response = dialog.ShowModal()
-
-        if response == wx.ID_NO:
-            logging.info("No modifications, process stopped.")
-        else :
-            if os.path.exists(self._manager.IN_CH_SA_SC):
-                existence=False
-                existence = self._manager.create_vrtIfExists(Path(path_DEM_base), self._manager.IN_CH_SA_SC, self._manager.IN_CH_SA_SC_MNT_VRT, name="MNTmodifs_")
-                if existence == True :
-                    logging.info(f"Scenarios have been applied to DEM see {self._manager.IN_CH_SA_SC_MNT_tif}.")
-                    self._manager.translate_vrt2tif(self._manager.IN_CH_SA_SC_MNT_VRT, self._manager.IN_CH_SA_SC_MNT_tif)
-                    WA_mask = WolfArray(self._manager.IN_CH_SA_SC_MNT_tif.with_suffix('.tif'))
-                    WA_mask.write_all(Path(self._manager.IN_SA_DEM / "MNT_loaded.bin"))
-                else :
-                    logging.error(f"No MNTmodifs_ files in {self._manager.IN_CH_SA_SC}.")
-            else:
-                logging.error(f"Path {self._manager.IN_CH_SA_SC} does not exist.")
-
-            #self._manager.IN_CH_SA_SC_MNT_tif   ou fn_mnt_cropped : ground + riverbed
-            fn_wherebuildings_buffer = self._manager.IN_CH_SA_SC_MNT_tif.parent / "buffer_wherebuilding.tif"
-            fn_mask = self._manager.IN_SA_DEM / "MNT_computed_with_mask.tif"
-            MTN_And_mask_creation_all(self.gpu_bathy, self._manager.IN_CH_SA_SC_MNT_tif.with_suffix('.tif'), fn_wherebuildings_buffer, fn_mask)
-            if fn_wherebuildings_buffer.exists():
-                fn_wherebuildings_buffer.unlink()
-            if fn_mask.exists():
-                fn_mask.unlink()
-            dlg = wx.MessageDialog(self,
-                       "DEM files created in INPUT\WATER_DEPTH\...\DEM_FILES.",
-                       "Success.",
-                       wx.OK | wx.ICON_INFORMATION)
-            dlg.ShowModal()
-            dlg.Destroy()
-            return
-
-
+            result = dlg.ShowModal()
+            if result != wx.ID_OK:
+                return
 
+            path_DEM_base = dlg.GetPath()
+            logging.info("DEM file selected.")
+                
+        #DEM and masked DEM creation
+        path = self._manager.IN_CH_SA_SC
+        names_inCHVUL_MNTmodifs = [f for f in os.listdir(path) if os.path.isfile(os.path.join(path, f)) and f.startswith("MNTmodifs_")]
+        #path_MNT_computed is the path to the DEM with the MNTmodifs if exist, or the given true DEM if not
+        path_MNT_computed = Path(path_DEM_base)
+        if len(names_inCHVUL_MNTmodifs) !=0:
+            path_MNT_computed = Path(self._manager.IN_CH_SA_SC_MNT_tif.with_suffix('.tif'))
+            dialog = wx.MessageDialog(None, f"Please modify the 'MNTmodifs_' files in INPUT\CHANGE_VULNE\... as in the hydraulic scenario you want to study. They are: {names_inCHVUL_MNTmodifs}", "Confirmation", wx.YES_NO | wx.ICON_QUESTION)
+            dialog.SetYesNoLabels("Done, continue", "Not done, stop")
+            response = dialog.ShowModal()
+            
+            if response == wx.ID_NO:
+                logging.info("No modifications done in MNTmodifs_ files, process stopped.")
+                return
+                
+        #else :
+        if os.path.exists(self._manager.IN_CH_SA_SC):
+            existence=False
+            existence = self._manager.create_vrtIfExists(Path(path_DEM_base), self._manager.IN_CH_SA_SC, self._manager.IN_CH_SA_SC_MNT_VRT, name="MNTmodifs_")
+            if existence :
+                self._manager.translate_vrt2tif(self._manager.IN_CH_SA_SC_MNT_VRT, self._manager.IN_CH_SA_SC_MNT_tif)
+                logging.info(f"Scenarios have been applied to DEM see {self._manager.IN_CH_SA_SC_MNT_tif}.tif.")
+                WA_mask = WolfArray(self._manager.IN_CH_SA_SC_MNT_tif.with_suffix('.tif'))
+                WA_mask.write_all(Path(self._manager.IN_SA_DEM / "MNT_loaded.bin"))
+            else :
+                logging.info(f"No MNTmodifs_ files in {self._manager.IN_CH_SA_SC}. The given file {path_DEM_base} has not been modified")
+                WA_mask = WolfArray(path_DEM_base)
+                WA_mask.write_all(Path(self._manager.IN_SA_DEM / "MNT_loaded.bin"))
+        else:
+            logging.error(f"Path {self._manager.IN_CH_SA_SC} does not exist.")
+
+        #self._manager.IN_CH_SA_SC_MNT_tif   ou fn_mnt_cropped : ground + riverbed
+        fn_wherebuildings_buffer = self._manager.IN_CH_SA_SC / "buffer_wherebuilding.tif"
+        fn_mask = self._manager.IN_SA_DEM / "MNT_computed_with_mask.tif"
+        MTN_And_mask_creation_all(self.gpu_bathy, path_MNT_computed, fn_wherebuildings_buffer, fn_mask)
+        if fn_wherebuildings_buffer.exists():
+            fn_wherebuildings_buffer.unlink()
+        if fn_mask.exists():
+            fn_mask.unlink()
+        dlg = wx.MessageDialog(self,
+                    "DEM files created in INPUT\WATER_DEPTH\...\DEM_FILES.",
+                    "Success.",
+                    wx.OK | wx.ICON_INFORMATION)
+        dlg.ShowModal()
+        dlg.Destroy()
+        return
+                  
     def OnInterpolation(self,e):
-        """Interpolates the last extracted time steps present in LAST_STEP_EXTRACTED using the fast marching
+        """Interpolates the last extracted time steps present in LAST_STEP_EXTRACTED using the fast marching 
         interpolation routine holes.exe, by creating a batch file
         while performing multiple checks on the required input files."""
         if not hasattr(self, 'file_paths'):
-            with wx.MessageDialog(self,
-                                f"Please, first load gpu simulations via the previous button.",
-                                "Attention",
+            with wx.MessageDialog(self, 
+                                f"Please, first load gpu simulations via the previous button.", 
+                                "Attention", 
                                 style=wx.OK | wx.ICON_ERROR) as dlg:
                 dlg.ShowModal()
             return
-
+        
         checked_indices = self._check_listbox.GetCheckedItems()
         checked_items = [self._check_listbox.GetString(index) for index in checked_indices]
         selected_paths = [self.file_paths[item] for item in checked_items]
         path_simulations = self.datadir_simulations
-
+        
         path_LastSteps = Path(self._manager.IN_SA_EXTRACTED)
         fn_write = None
         dx,dy,nbx,nby,X,Y = False, False, False, False, False, False
@@ -931,8 +1110,8 @@ class AcceptabilityGui(wx.Frame):
             else:
                 logging.info('No folder found / selected. Please try again...')
         else:
-            logging.error('No simulation selected! Please select some in the checkbox.')
-
+            logging.error('No simulation selected! Please select some in the checkbox.')        
+        
         C = None
         D = None
         for file in os.listdir(Path(self._manager.IN_SA_DEM)):
@@ -941,44 +1120,44 @@ class AcceptabilityGui(wx.Frame):
                 if "mask" not in file:
                     D = file_path
                 else:
-                    C = file_path
+                    C = file_path      
         if D == None:
             logging.info("DEM (.bin) not found in DEM_FILES. The file must begins by 'MNT_' and CANNOT include the word 'mask'")
-            with wx.MessageDialog(self,
-                        f"DEM (.bin) not found in DEM_FILES. The file must begins by 'MNT_' and CANNOT include the word 'mask'",
-                        "Missing file",
+            with wx.MessageDialog(self, 
+                        f"DEM (.bin) not found in DEM_FILES. The file must begins by 'MNT_' and CANNOT include the word 'mask'", 
+                        "Missing file", 
                         style=wx.OK | wx.ICON_INFORMATION) as dlg:
                 dlg.ShowModal()
             return
-
+            
         if C == None:
             logging.info("DEM mask (.bin) not found in DEM_FILES. The file must begins by 'MNT_' and MUST include the word 'mask'")
-            with wx.MessageDialog(self,
-                        f"DEM mask (.bin) not found in DEM_FILES. The file must begins by 'MNT_' and MUST include the word 'mask'",
-                        "Missing file",
+            with wx.MessageDialog(self, 
+                        f"DEM mask (.bin) not found in DEM_FILES. The file must begins by 'MNT_' and MUST include the word 'mask'", 
+                        "Missing file", 
                         style=wx.OK | wx.ICON_INFORMATION) as dlg:
                 dlg.ShowModal()
             return
-
+        
         if not get_header_comparison([fn_write.with_suffix(".bin"), C, D]):
             logging.info("Files in DEM_FILES do not have the same properties as the simulations files. Please, fix them.")
-            with wx.MessageDialog(self,
-                        f"Files in DEM_FILES do not have the same properties as the simulations files. Please, fix them.",
-                        "Error in DEM_FILES files",
+            with wx.MessageDialog(self, 
+                        f"Files in DEM_FILES do not have the same properties as the simulations files. Please, fix them.", 
+                        "Error in DEM_FILES files", 
                         style=wx.OK | wx.ICON_INFORMATION) as dlg:
                 dlg.ShowModal()
             return
-
+        
         checked_names = self._check_listbox.GetCheckedStrings()
         if not checked_names:
             logging.info("No items selected. Adding all paths.")
-            checked_paths = list(self.file_paths.values())
+            checked_paths = list(self.file_paths.values())  
             message_info = "No simulations were checked in the box; so the computations will consider all of them. The interpolation of the given free surface will begin when you press OK, please wait."
         else:
             logging.info("Adding only the selected simulations.")
             checked_paths = [self.file_paths[name] for name in checked_names]
-            message_info = "The interpolation of the given free surface will begin (for the selected simulation(s)) when you press OK, please wait."
-
+            message_info = "The interpolation of the given free surface will begin (for the selected simulation(s)), please wait."
+        
         if len(self.file_paths) == 0 :
             with wx.MessageDialog(self, f"No files in EXTRACTED_LAST_STEP_WD. Please provide some or use the 'Load gpu simulation' button.",
                         "OK", wx.OK | wx.ICON_INFORMATION) as dlg:
@@ -986,15 +1165,15 @@ class AcceptabilityGui(wx.Frame):
         else :
             path_Interp =  Path(self._manager.IN_SA_INTERP)
             path_bat_file = os.path.join(self._manager.IN_SCEN_DIR, "process_files.bat")
-
+            
             if os.path.exists(path_bat_file):
                 logging.info(f"The file {path_bat_file} already exists and will be replaced.")
                 os.remove(path_bat_file)
-            path_code = os.path.join(self._manager.IN_WATER_DEPTH, "holes.exe")
-
+            path_code = os.path.join(self._manager.IN_WATER_DEPTH, "holes.exe") 
+            
             A=[]
             for path in checked_paths:
-                parts = path.name.split("sim_")
+                parts = path.name.split("sim_") 
                 A.extend([os.path.join(path_LastSteps, g) for g in os.listdir(path_LastSteps) if g.endswith(f"{parts[1]}.bin")])
             B = [os.path.join(path_Interp, os.path.splitext(os.path.basename(f))[0]) for f in A]
             if not A or not B or not C or not D:
@@ -1007,20 +1186,18 @@ class AcceptabilityGui(wx.Frame):
                     line = f'"{path_code}" filling in="{a}" out="{b}" mask="{C}" dem="{D} avoid_last=1"\n'
                     bat_file.write(line)
             logging.info(message_info)
-            with wx.MessageDialog(self, message_info,
-                        "Redirecting", wx.OK | wx.ICON_INFORMATION) as dlg:
-                dlg.ShowModal()
+            
             empty_folder(self._manager.IN_SA_INTERP)
             path_bat_file = os.path.join(self._manager.IN_SCEN_DIR, "process_files.bat")
             subprocess.run([path_bat_file], check=True)
-
+            
             renamed_files = []
             path_fichier=self._manager.IN_SA_INTERP
             for file in path_fichier.glob("*.tif"):
-                if "_h" in file.name:
+                if "_h" in file.name:  
                     new_name = file.stem.split("_h")[0].replace(".bin", "") + ".tif"
                     file.rename(file.with_name(new_name))
-                    renamed_files.append(new_name)
+                    renamed_files.append(new_name) 
             #deleting the other
             for file in path_fichier.glob("*.tif"):
                 if "_combl" in file.name or file.name not in renamed_files:
@@ -1030,229 +1207,43 @@ class AcceptabilityGui(wx.Frame):
                         "Redirecting", wx.OK | wx.ICON_INFORMATION) as dlg:
                 dlg.ShowModal()
         update_info_header(self.input_dx,self.input_nbxy,self.input_O,self._manager.IN_SA_INTERP)
-
-
-
-    def OnSAcreation(self,e):
-        """Creates the shapefile for the study area based on the extent of the provided simulations. A pre-existing shapefile is required;
-        the menu will display existing ones and the one to be replaced. A placeholder shapefile must be placed if this is the first run."""
-        update_info_header(self.input_dx,self.input_nbxy,self.input_O,self._manager.IN_SA_INTERP)
-        logging.info("The study area shapefile will be generated in the INPUT STUDY_AREA, based on the simulations present INTERP_WD, whose properties are displayed on the left.")
-        with wx.MessageDialog(self, f"The study area shapefile will be generated in the INPUT STUDY_AREA, based on the simulations present INTERP_WD, whose properties are displayed on the left.",
-                    "SA creation", wx.OK | wx.ICON_INFORMATION) as dlg:
-            dlg.ShowModal()
-        path_fichier=self._manager.IN_SA_INTERP
-        tif_files = [f for f in os.listdir(path_fichier) if f.lower().endswith('.tif')]
-        tif_list_fn = [os.path.join(path_fichier, tif_file) for tif_file in tif_files]
-        if tif_files:
-            if get_header_comparison(tif_list_fn) :
-                    display_info_header(self.input_dx, self.input_nbxy, self.input_O, tif_list_fn[0])
-            else:
-                logging.error("The interpolated files have different headers. Please fix it.")
-
-            #dlg = wx.TextEntryDialog(None, "What is the name of the study area (please, use underscore '_' for space if required, for example Bassin_Vesdre):", "Input", "")
-            #if dlg.ShowModal() == wx.ID_OK:
-            #    name_shp = dlg.GetValue()
-            #dlg.Destroy()
-
-            shp_files = [f for f in os.listdir(Path(self._manager.IN_STUDY_AREA)) if f.endswith('.shp')]
-            if shp_files:
-                dlg = wx.MultiChoiceDialog(None, "Which Study Area shapefile to replace?", "Choose Shapefile", shp_files)
-                if dlg.ShowModal() == wx.ID_OK:
-                    selections = dlg.GetSelections()
-                    if selections:
-                        name_shp = shp_files[selections[0]]
-                        name_shp = Path(self._manager.IN_STUDY_AREA) / name_shp
-                        create_shapefile_from_prop_tif(tif_list_fn[0], name_shp)
-                        logging.info("Study area file created.")
-                        with wx.MessageDialog(self, f"Study area file created.",
-                            "Information", wx.OK | wx.ICON_INFORMATION) as dlg:
-                            dlg.ShowModal()
-
-            else:
-                logging.info("No study area files to be replaced.")
-                with wx.MessageDialog(self, f"There is no study area shapefile to replace. It must exist at least one, that will be replaced at this stage.",
-                            "Information", wx.OK | wx.ICON_INFORMATION) as dlg:
-                    dlg.ShowModal()
-        else :
-            logging.info("No interpolated files.")
-            with wx.MessageDialog(self, f"There are no files in INTERP_WD, please generate them via the previous buttons line.",
-                        "Attention", wx.OK | wx.ICON_ERROR) as dlg:
-                dlg.ShowModal()
-
-    def OnMainDir(self, e):
-        """Selects the main directory to be read."""
-        vanish_info_header(self.input_dx,self.input_nbxy,self.input_O)
-        with wx.DirDialog(self, "Choose the main directory containing the data (folders INPUT, TEMP and OUTPUT):",
-                          style=wx.DD_DEFAULT_STYLE
-                          ) as dlg:
-
-            if dlg.ShowModal() == wx.ID_OK:
-                self._manager = Accept_Manager(dlg.GetPath())
-
-                self._listbox_studyarea.Clear()
-                self._listbox_studyarea.InsertItems(self._manager.get_list_studyareas(), 0)
-
-                self._listbox_scenario.Clear()
-
-                ret = self._manager.check_files()
-
-                if ret == "":
-                    logging.info("All the files are present")
-                    self._but_acceptability.Enable(True)
-                    self._but_vulnerability.Enable(True)
-                    self._but_creation.Enable(True)
-                    self._but_checkfiles.Enable(True)
-                    self._but_loadgpu.Enable(True)
-                    self._but_toggle_scen.Enable(True)
-                    self._but_toggle_resamp.Enable(True)
-                    self._but_upriverbed.Enable(True)
-                    self._but_checkscenario.Enable(True)
-                    self._but_sacreation.Enable(True)
-                    self._but_checksim.Enable(True)
-
-
-                else:
-                    logging.error(f"Missing files: {ret}")
-                    with wx.MessageDialog(self, f"Missing files: \n{ret}", "Error", wx.OK | wx.ICON_ERROR) as dlg:
-                        dlg.ShowModal()
-
-            else:
-                return
-
-    def OnStudyArea(self, e):
-        """ Change the study area """
-        if self._manager is None:
-            return
-        vanish_info_header(self.input_dx,self.input_nbxy,self.input_O)
-        study_area:str = self._manager.get_list_studyareas(with_suffix=True)[e.GetSelection()]
-        self._manager.change_studyarea(study_area)
-
-        self._listbox_scenario.Clear()
-        sc = self._manager.get_list_scenarios()
-        self._listbox_scenario.InsertItems(sc, 0)
-
-        if self.mapviewer is not None:
-            tmp_path = self._manager.IN_STUDY_AREA / study_area
-
-            from ..PyDraw import draw_type
-            if not tmp_path.stem in self.mapviewer.get_list_keys(drawing_type=draw_type.VECTORS):
-                self.mapviewer.add_object('vector', filename=str(tmp_path), id=tmp_path.stem)
-                self.mapviewer.Refresh()
-
-    def OnScenario(self, e):
-        """ Change the scenario """
-        if self._manager is None:
-            return
-
-        scenario = self._manager.get_list_scenarios()[e.GetSelection()]
-        self._manager.change_scenario(scenario)
-
-        self._listbox_returnperiods.Clear()
-        rt = self._manager.get_return_periods()
-        self._listbox_sims.Clear()
-        if len(rt) != 0 :
-            self._listbox_returnperiods.InsertItems([str(crt) for crt in rt],0)
-            self._listbox_sims.Clear()
-            sims = [str(self._manager.get_filepath_for_return_period(currt).name) for currt in rt]
-            self._listbox_sims.InsertItems(sims, 0)
-            ponds = self._manager.get_ponderations()
-            if isinstance(ponds, pd.DataFrame):
-                self._axes.clear()
-                ponds.plot(ax=self._axes, kind='bar', color='gray', edgecolor='black')
-                self._axes.set_ylabel("Weighting coefficients [-]")
-                self._axes.set_xlabel("Return period [years]")
-                self._axes.grid(axis='y', linestyle='--', alpha=0.7)
-                self._canvas.draw()
-        else:
-            self._axes.clear()
-            self._axes.set_ylabel("Weighting coefficients [-]")
-            self._axes.set_xlabel("Return period [years]")
-            self._axes.grid(axis='y', linestyle='--', alpha=0.7)
-            self._canvas.draw()
-
-        update_info_header(self.input_dx,self.input_nbxy,self.input_O,self._manager.IN_SA_INTERP)
-
-
-    def OnCreation(self, e):
-        """ Create the database """
-        if self._manager is None:
-            return
-
-        dx,_,_,_,_,_ = update_info_header(self.input_dx,self.input_nbxy,self.input_O,self._manager.IN_SA_INTERP)
-        resolution = dx
-        if resolution == '':
-            wx.MessageBox(
-                        f"There are no files in INTERP_WD lease, use first the buttons at the second line.",
-                        "Attention",
-                        wx.OK | wx.ICON_ERROR
-                        )
-        else :
-            steps = list(self._steps_db.GetCheckedStrings())
-            steps = [int(cur.split('-')[1]) for cur in steps]
-
-            if len(steps) != 0:
-
-                wx.MessageBox(
-                        f"The database will now be created, with a resolution of {dx}. This process may take some time, and the window may temporarily stop responding.",
-                        "Information",
-                        wx.OK | wx.ICON_INFORMATION
-                        )
-                Base_data_creation(self._manager.main_dir, number_procs=self._nb_process.GetValue(), resolution=dx, steps=steps)
-
-                wx.MessageBox(
-                            "The database is created with the selected steps.",
-                            "Information",
-                            wx.OK | wx.ICON_INFORMATION
-                            )
-            else :
-                wx.MessageBox(
-                            f"No steps selected. The code for the DataBase creation will consider all steps by default, , with a resolution of {dx}. This process may take some time, and the window may temporarily stop responding.",
-                            "Information",
-                            wx.OK | wx.ICON_INFORMATION
-                            )
-                Base_data_creation(self._manager.main_dir, number_procs=self._nb_process.GetValue(), resolution=dx)
-                wx.MessageBox(
-                            "The database is created for every steps.",
-                            "Information",
-                            wx.OK | wx.ICON_INFORMATION
-                            )
+        
     def OnToggle(self,e):
         """Creates a toggle button to be activated if the scenarios vuln_ have to be taken into account."""
         self.toggle_state = False
         if self._but_toggle_scen.GetValue():
             logging.info("Activating the scenario button.")
-            self._but_toggle_scen.SetBackgroundColour(wx.Colour(175, 175, 175))
+            self._but_toggle_scen.SetBackgroundColour(wx.Colour(175, 175, 175))  
             self._but_toggle_scen_state = True
             tif_files = [file for file in Path(self._manager.IN_CH_SA_SC).glob("*.tif") if file.name.startswith("vuln_")]
             if not tif_files:
                 wx.MessageBox(
-                    "The scenario button cannot be activated because there is no change in vulnerability 'vuln_' in CHANGE_VULNE. Please reload the simulations containing 'bath_' files via 'Load and extract gpu simulations' and edit it, or directly introduce your 'vuln_' files.",
+                    "The scenario button cannot be activated because there is no change in vulnerability 'vuln_' in CHANGE_VULNE. Please reload the simulations containing 'bath_' files via 'Load new hydraulic scenario' and edit it, or directly introduce your 'vuln_' files.",
                     "Information",
                     wx.OK | wx.ICON_INFORMATION
                     )
                 logging.info("Desactivating the scenario button.")
-                self._but_toggle_scen.SetValue(False)
-                self._but_toggle_scen.SetBackgroundColour(wx.NullColour)
+                self._but_toggle_scen.SetValue(False)  
+                self._but_toggle_scen.SetBackgroundColour(wx.NullColour) 
                 self._but_toggle_scen_state = False
             else :
                 self.toggle_state = True
         else:
-            self._but_toggle_scen.SetBackgroundColour(wx.NullColour)
+            self._but_toggle_scen.SetBackgroundColour(wx.NullColour)  
             self.toggle_state = False
             logging.info("Desactivating the scenario button.")
-
+    
     def OnToggleResampling(self,e):
         """Creates a toggle button for the acceptability resampling to be activated."""
         self.toggle_resamp_state = False
         toggle = self._but_toggle_resamp
-        if toggle.GetValue():
-            self._but_toggle_resamp.SetBackgroundColour(wx.Colour(175, 175, 175))
+        if toggle.GetValue(): 
+            self._but_toggle_resamp.SetBackgroundColour(wx.Colour(175, 175, 175))  
             self.toggle_resamp_state = True
             logging.info("Resampling activated")
             current_res = self._but_resampling.GetValue()
             resolution = self.input_dx.GetLabel()
-            if resolution != '':
+            if resolution != '':                
                 values = resolution.strip("()").split(",")
                 dx = float(values[0])
                 #selection of size
@@ -1261,49 +1252,48 @@ class AcceptabilityGui(wx.Frame):
                                 "The resampling size cannot be inferior to the resolution. Please select another resampling size.",
                                 "Attention",
                                 wx.OK | wx.ICON_ERROR
-                                )
+                                ) 
                     self.toggle_resamp_state = False
-                    self._but_toggle_resamp.SetValue(False)
-                    self._but_toggle_resamp.SetBackgroundColour(wx.NullColour)
+                    self._but_toggle_resamp.SetValue(False)  
+                    self._but_toggle_resamp.SetBackgroundColour(wx.NullColour) 
                     logging.info("Resampling disactivated because of a bad resampling size.")
                 else :
                     logging.info(f"Allowed resampling value : {current_res}[m].")
             else:
                 self.toggle_resamp_state = False
-                self._but_toggle_resamp.SetValue(False)
-                self._but_toggle_resamp.SetBackgroundColour(wx.NullColour)
+                self._but_toggle_resamp.SetValue(False)  
+                self._but_toggle_resamp.SetBackgroundColour(wx.NullColour) 
                 logging.info("No simulations in INTERP_WD.")
 
-
+                
         else:
             self.toggle_resamp_state = False
-            self._but_toggle_resamp.SetValue(False)
-            self._but_toggle_resamp.SetBackgroundColour(wx.NullColour)
+            self._but_toggle_resamp.SetValue(False)  
+            self._but_toggle_resamp.SetBackgroundColour(wx.NullColour) 
             logging.info("Resampling disactivated")
-
+                
     def OnCheckScenario(self,e):
         """Checks if scenarios exist in CHANGE_VULNE."""
-        tif_files = list(Path(self._manager.IN_CH_SA_SC).glob("vuln_*.tif"))
+        tif_files = self._manager.get_modifiedrasters()
         logging.info("checking the scenarios for vulnerability and acceptability.")
         if not tif_files:
             wx.MessageBox(
-                        "No files 'vuln_' found in CHANGE_VULNE.",
+                        "No files 'vuln_' or 'MNTmodifs_' found in CHANGE_VULNE.",
                         "Information",
                         wx.OK | wx.ICON_INFORMATION
                         )
-        else :
+        else : 
             wx.MessageBox(
-                f"There exist vuln_ file(s) in CHANGE_VULNE: {', '.join([tif_file.name for tif_file in tif_files])}",
-                "Information", wx.OK | wx.ICON_INFORMATION)
-
+                f"There exist vuln_ file(s) in CHANGE_VULNE:\n {', '.join([tif_file for tif_file in tif_files])}", 
+                "Information", wx.OK | wx.ICON_INFORMATION)  
+            
     def OnVulnerability(self, e):
         """ Run the vulnerability """
-
         if self._manager is None:
             return
         path = [self._manager.OUT_VULN]
         steps = list(self._steps_vulnerability.GetCheckedStrings())
-        steps = [int(cur.split('-')[1]) for cur in steps]
+        steps = [int(cur.split('-')[1]) for cur in steps]       
         resolution,_,_,_,_,_ =update_info_header(self.input_dx,self.input_nbxy,self.input_O,self._manager.IN_SA_INTERP)
         if resolution == '':
             wx.MessageBox(
@@ -1312,7 +1302,7 @@ class AcceptabilityGui(wx.Frame):
                         wx.OK | wx.ICON_ERROR
                         )
         else :
-            message_supp = "."
+            message_supp = "."        
             if len(steps) == 0:
                 steps = [1,10,11,2,3]
                 if self.toggle_state == True :
@@ -1324,13 +1314,13 @@ class AcceptabilityGui(wx.Frame):
                         steps=[4]
                     else :
                         logging.info("Attention - The manager computes also Vulnerability_baseline, as Vulnerability_scenario needs it as input.")
-                    path = [self._manager.OUT_VULN_Stif]
+                    path = [self._manager.OUT_VULN_Stif]                    
                     dialog = wx.MessageDialog(None, f"Please modify the 'vuln_' files in INPUT\CHANGE_VULNE\... as desired. Default value set to one. ", "Confirmation", wx.YES_NO | wx.ICON_QUESTION)
                     dialog.SetYesNoLabels("Done, continue", "Not done, stop")
                     response = dialog.ShowModal()
                     if response == wx.ID_NO:
                         return
-
+                    
                 logging.info("No steps selected. By default every steps will be performed" + message_supp)
                 Vulnerability(str(self._manager.main_dir),
                             scenario=str(self._manager.scenario),
@@ -1341,7 +1331,7 @@ class AcceptabilityGui(wx.Frame):
                             "Vulnerability computed with every steps" + message_supp,
                             "Information",
                             wx.OK | wx.ICON_INFORMATION
-                            )
+                            )         
             else :
                 if self.toggle_state == True :
                     steps.append(4)
@@ -1352,14 +1342,14 @@ class AcceptabilityGui(wx.Frame):
                         steps=[4]
                     else :
                         logging.info("Attention - The manager computes also Vulnerability_baseline, as Vulnerability_scenario needs it as input.")
-
-                    path = [self._manager.OUT_VULN_Stif]
+                    
+                    path = [self._manager.OUT_VULN_Stif] 
                     dialog = wx.MessageDialog(None, f"Please modify the 'vuln_' files in INPUT\CHANGE_VULNE\... as desired. Default value set to one. ", "Confirmation", wx.YES_NO | wx.ICON_QUESTION)
                     dialog.SetYesNoLabels("Done, continue", "Not done, stop")
                     response = dialog.ShowModal()
                     if response == wx.ID_NO:
                         return
-
+                    
                 Vulnerability(self._manager.main_dir,
                             scenario=self._manager.scenario,
                             Study_area=self._manager.Study_area,
@@ -1369,21 +1359,21 @@ class AcceptabilityGui(wx.Frame):
                             "Vulnerability computed with the selected steps" + message_supp,
                             "Information",
                             wx.OK | wx.ICON_INFORMATION
-                            )
+                            )  
         mapviewer_display(path)
-
+             
     def OnAcceptability(self, e):
         """ Run the acceptability """
         if self._manager is None:
             return
-
-        river_trace = self._manager.wich_river_trace()
+        
+        river_trace = self._manager.wich_river_trace()  
         if self.toggle_state == True and not os.path.isfile(str(self._manager.OUT_VULN_Stif)) and not os.path.isfile(str(river_trace)) :
-            wx.MessageBox("Necessary files are missing, please ensure the DataBase or Vulnerability steps were performed. ","Error",  wx.OK | wx.ICON_ERROR )
+            wx.MessageBox("Necessary files are missing, please ensure the DataBase or Vulnerability or Updating riverbed steps were performed. ","Error",  wx.OK | wx.ICON_ERROR )  
             return
-
+        
         if self.toggle_state == False and not os.path.isfile(str(self._manager.OUT_VULN)) and not os.path.isfile(str(river_trace)) :
-            wx.MessageBox("Necessary files are missing, please ensure the DataBase or Vulnerability steps were performed. ","Error",  wx.OK | wx.ICON_ERROR )
+            wx.MessageBox("Necessary files are missing, please ensure the DataBase or Vulnerability or Updating riverbed steps were performed. ","Error",  wx.OK | wx.ICON_ERROR )  
             return
 
         steps = list(self._steps_acceptability.GetCheckedStrings())
@@ -1401,19 +1391,19 @@ class AcceptabilityGui(wx.Frame):
                     steps = [x for x in steps if x != 4]
                     logging.info('Acceptability_baseline not computed because it already exists.')
                     message_supp = " FOR scenario(s) vuln_ taken into account"
-
+                    
                 if river_trace == self._manager.OUT_MASKED_RIVER : message_supp=message_supp +" WITH the _baseline riverbed trace."
                 if river_trace == self._manager.OUT_MASKED_RIVER_S :message_supp+= " WITH the _scenarios riverbed trace."
             if self.toggle_resamp_state == True :
                 steps.append(6)
-                resampling = self._but_resampling.GetValue()
+                resampling = self._but_resampling.GetValue()                
                 resolution = self.input_dx.GetLabel()
-                if resolution != '':
+                if resolution != '':                
                     values = resolution.strip("()").split(",")
                     resolution = float(values[0])
-
+                
                 message_supp+= f" It has been created for the resolution {resolution}m and the resampling size {resampling}m."
-
+                
             logging.info("No steps selected. By default every steps will be performed.")
             Acceptability(self._manager.main_dir,
                         scenario=self._manager.scenario,
@@ -1434,18 +1424,19 @@ class AcceptabilityGui(wx.Frame):
                     logging.info('Acceptability_baseline not computed because it already exists.')
                     message_supp = "FOR scenario(s) (vuln_taken into account)"
                 path = [self._manager.OUT_ACCEPT_Stif]
-                river_trace = self._manager.wich_river_trace()
+                river_trace = self._manager.wich_river_trace() 
                 if river_trace == self._manager.OUT_MASKED_RIVER : message_supp =message_supp + " WITH the _baseline riverbed trace."
                 if river_trace == self._manager.OUT_MASKED_RIVER_S : message_supp =message_supp + " WITH the _scenarios riverbed trace."
             if self.toggle_resamp_state == True :
                 resampling = self._but_resampling.GetValue()
                 steps.append(6)
-
+            
             Acceptability(self._manager.main_dir,
                         scenario=self._manager.scenario,
                         Study_area=self._manager.Study_area,
                         resample_size=resampling,
                         steps=steps)
+            
             wx.MessageBox(
                         "Acceptability computed with the selected steps" + message_supp,
                         "Information",