wolfhece 2.1.100__py3-none-any.whl → 2.1.102__py3-none-any.whl

wolfhece/mesh2d/wolf2dprev.py

@@ -8100,9 +8100,12 @@ class prev_infiltration():
 
         sequence, nb_zones = self._infiltrations_chronology.shape
         for zone in range(1,nb_zones):
-            ax.plot(self._infiltrations_chronology[:, 0], self._infiltrations_chronology[:, zone], label=f'Infil {zone}')
+            ax.plot(self._infiltrations_chronology[:, 0], self._infiltrations_chronology[:, zone], label=f'Zone {zone}')
 
+        ax.set_xlabel(_('Time [s]'))
+        ax.set_ylabel(_('Infiltration [$m^3/s$]'))
         ax.legend()
+        fig.tight_layout()
 
         if show:
             fig.show()

wolfhece/scenario/check_scenario.py

@@ -123,6 +123,17 @@ def import_files(module_files:Union[list[Path],list[str]]) -> list[types.ModuleT
         sys.path.pop(0)
         os.chdir(olddir)
 
+        # Test if some routines are missing
+        # if "impose_bc" in py_file.name:
+        #     to_test = ['impose_bc']
+
+        # elif "update_void" in py_file.name:
+        #     to_test = ['update_topobathy', 'update_manning', 'update_infiltration', 'update_roof']
+
+        # for routine in to_test:
+        #     if not hasattr(module, routine):
+        #         logging.warning(f'Le module {module} ne contient pas la routine {routine}.')
+
         modules.append(module)
 
     return modules

wolfhece/scenario/config_manager.py

@@ -30,7 +30,7 @@ import types
 
 from ..PyTranslate import _
 from ..wolfresults_2D import Wolfresults_2D
-from ..wolf_array import WolfArray, header_wolf, WOLF_ARRAY_FULL_INTEGER
+from ..wolf_array import WolfArray, header_wolf, WOLF_ARRAY_FULL_INTEGER, WOLF_ARRAY_FULL_SINGLE
 from .check_scenario import check_file_update, check_file_bc, import_files
 from .update_void import create_new_file as update_void
 from .imposebc_void import create_new_file as bc_void
@@ -56,7 +56,7 @@ except:
 # mann_*.tif
 # infil_*.tif
 
-ACCEPTED_PREFIX = ['bath_', 'mann_', 'infil_']
+ACCEPTED_PREFIX = ['bath_', 'mann_', 'infil_', 'roof_']
 
 def delete_folder(pth:Path):
     for sub in pth.iterdir():
@@ -202,14 +202,15 @@ class Config_Manager_2D_GPU:
     Gestionnaire de configurations 2D - code GPU
     """
 
-    def __init__(self, workingdir:str = '', mapviewer:WolfMapViewer = None) -> None:
+    def __init__(self, workingdir:str = '', mapviewer:WolfMapViewer = None, python_venv:Path = None) -> None:
         """
         Recherche de toutes les modélisation dans un répertoire et ses sous-répertoires
         """
         self.wx_exists = wx.App.Get() is not None
 
-        self.workingdir = ''
-        self.wolfcli    = ''
+        self.workingdir:Path = None
+        self.wolfgpu:Path = None
+        self._py_env:Path = python_venv
 
         if workingdir == '':
             if self.wx_exists:
@@ -228,6 +229,7 @@ class Config_Manager_2D_GPU:
             logging.error(_('Directory does not exist !'))
             return
 
+        self.find_wolfgpu()
         self.workingdir = Path(workingdir)
         self.mapviewer  = mapviewer
 
@@ -239,6 +241,33 @@ class Config_Manager_2D_GPU:
 
         self.load_data()
 
+    def find_wolfgpu(self):
+        """ Find the wolfgpu Path from wolfgpu package"""
+
+        import importlib.util
+        import sys
+
+        if self._py_env is None:
+            self._py_env = Path(sys.executable).parent
+
+        # Find wolfgpu.exe in script directory
+        candidate = self._py_env / 'wolfgpu.exe'
+
+        if candidate.exists():
+            self.wolfgpu = candidate
+            return
+
+        candidate = self._py_env / 'Scripts' / 'wolfgpu.exe'
+
+        if candidate.exists():
+            self.wolfgpu = candidate
+            return
+        else:
+            logging.error(_('WOLFGPU not found !'))
+            self.wolfgpu = None
+            self._py_env = None
+
+
     def _test_ui(self):
         """ Test if the UI is available """
 
@@ -442,7 +471,7 @@ class Config_Manager_2D_GPU:
 
         logging.info(_('Number of tif files : {}'.format(len(list_tif))))
 
-        standard_files = ['bathymetry.tif', 'manning.tif', 'infiltration.tif', 'h.tif', 'qx.tif', 'qy.tif']
+        standard_files = ['bathymetry.tif', 'manning.tif', 'infiltration.tif', 'h.tif', 'qx.tif', 'qy.tif', 'roof.tif']
 
         log = ''
         for curtif in list_tif:
@@ -473,6 +502,12 @@ class Config_Manager_2D_GPU:
                         loclog += _('Did you mean "infil_" ?') + '\n'
                         break
 
+                tests = ['rof_', 'rooof_', 'rofo_', 'oof_', 'roff_']
+                for test in tests:
+                    if curtif.name.lower().startswith(test):
+                        loclog += _('Did you mean "roof_" ?') + '\n'
+                        break
+
                 logging.warning(loclog)
 
                 log += loclog
@@ -583,7 +618,9 @@ class Config_Manager_2D_GPU:
         self._test_is_results(curdict)
 
     def _recursive_find_files(self, wd:Path, curdict:dict, erase_cache:bool = True):
-        """ Recherche récursive des fichiers de simulation/scenario dans les répertoires dont la structure a été traduite en dictionnaire """
+        """ Recherche récursive des fichiers de simulation/scenario dans les
+        répertoires dont la structure a été traduite en dictionnaire """
+
         if len(curdict.keys())>0:
             for k in curdict.keys():
                 self._recursive_find_files(k, curdict[k])
@@ -734,15 +771,19 @@ class Config_Manager_2D_GPU:
 
         return curdict
 
-    def _select_tif_partname(self, curdict:dict, tifstr:Literal['bath_', 'mann_', 'infil_']):
+    def _select_tif_partname(self, curdict:dict, tifstr:Literal['bath_', 'mann_', 'infil_', 'roof_']):
         """ Select tif files with a 'str' as name's prefix """
 
+        assert tifstr in ACCEPTED_PREFIX, _('Bad prefix !')
+
         if tifstr == 'bath_':
             forced_add = ['bathymetry.tif']
         elif tifstr == 'mann_':
             forced_add = ['manning.tif']
         elif tifstr == 'infil_':
             forced_add = ['infiltration.tif']
+        elif tifstr == 'roof_':
+            forced_add = ['roof.tif']
 
         tif_list = [curtif for curtif in curdict[GPU_2D_file_extensions.TIF.value] \
                     if curtif.name.lower().startswith(tifstr) or \
@@ -764,13 +805,15 @@ class Config_Manager_2D_GPU:
         all_tif_bath = [self._select_tif_partname(curdict, 'bath_') for curdict in curdicts]
         all_tif_mann = [self._select_tif_partname(curdict, 'mann_') for curdict in curdicts]
         all_tif_infil = [self._select_tif_partname(curdict, 'infil_') for curdict in curdicts]
+        all_tif_roof = [self._select_tif_partname(curdict, 'roof_') for curdict in curdicts]
 
         # flatten list of lists
         all_tif_bath = [curel for curlist in all_tif_bath if len(curlist)>0 for curel in curlist]
         all_tif_mann = [curel for curlist in all_tif_mann if len(curlist)>0 for curel in curlist]
         all_tif_infil = [curel for curlist in all_tif_infil if len(curlist)>0 for curel in curlist]
+        all_tif_roof = [curel for curlist in all_tif_roof if len(curlist)>0 for curel in curlist]
 
-        for cur_lst in [all_tif_bath, all_tif_mann, all_tif_infil]:
+        for cur_lst in [all_tif_bath, all_tif_mann, all_tif_infil, all_tif_roof]:
             for cur_tif in cur_lst:
                 curarray:WolfArray = WolfArray(cur_tif)
                 if curarray.nullvalue != 99999.:
@@ -795,21 +838,31 @@ class Config_Manager_2D_GPU:
         all_tif_bath = [self._select_tif_partname(curdict, 'bath_') for curdict in curdicts]
         all_tif_mann = [self._select_tif_partname(curdict, 'mann_') for curdict in curdicts]
         all_tif_infil = [self._select_tif_partname(curdict, 'infil_') for curdict in curdicts]
+        all_tif_roof = [self._select_tif_partname(curdict, 'roof_') for curdict in curdicts]
 
         # flatten list of lists
         all_tif_bath = [curel for curlist in all_tif_bath if len(curlist)>0 for curel in curlist]
         all_tif_mann = [curel for curlist in all_tif_mann if len(curlist)>0 for curel in curlist]
         all_tif_infil = [curel for curlist in all_tif_infil if len(curlist)>0 for curel in curlist]
+        all_tif_roof = [curel for curlist in all_tif_roof if len(curlist)>0 for curel in curlist]
 
         # création du fichier vrt
         create_vrt_from_files_first_based(all_tif_bath, from_path / '__bath_assembly.vrt')
         create_vrt_from_files_first_based(all_tif_mann, from_path / '__mann_assembly.vrt')
+
         if len(all_tif_infil)>0:
             create_vrt_from_files_first_based(all_tif_infil, from_path / '__infil_assembly.vrt')
+        else:
+            logging.info(_('No infiltration files found ! -> no __infil_assembly.vrt file created !'))
+
+        if len(all_tif_roof)>0:
+            create_vrt_from_files_first_based(all_tif_roof, from_path / '__roof_assembly.vrt')
+        else:
+            logging.info(_('No roof files found ! -> no __roof_assembly.vrt file created !'))
 
     def create_vec(self,
                    from_path:Path,
-                   which:Literal['bath_', 'mann_', 'infil_'] = 'bath_') -> Zones:
+                   which:Literal['bath_', 'mann_', 'infil_', 'roof_'] = 'bath_') -> Zones:
         """ Create a vec file from a path """
 
         assert which in ACCEPTED_PREFIX, _('Bad prefix !')
@@ -868,17 +921,18 @@ class Config_Manager_2D_GPU:
 
     def translate_vrt2tif(self, from_path:Path):
         """ Translate vrt to tif """
-        vrtin = ['__bath_assembly.vrt', '__mann_assembly.vrt', '__infil_assembly.vrt']
-        fout  = ['__bathymetry.tif'   , '__manning.tif', '__infiltration.tif']
+
+        vrtin = ['__bath_assembly.vrt', '__mann_assembly.vrt', '__infil_assembly.vrt', '__roof_assembly.vrt']
+        fout  = ['__bathymetry.tif'   , '__manning.tif', '__infiltration.tif', '__roof.tif']
 
         for curin, curout in zip(vrtin, fout):
             if (from_path / curin).exists():
                 translate_vrt2tif(from_path / curin, from_path / curout)
 
-    def apply_scripts_bath_mann_inf(self, from_path:Path):
+    def apply_scripts_bath_mann_inf_roof(self, from_path:Path):
         """ Apply all scripts """
 
-        filenames = ['__bathymetry.tif', '__manning.tif', '__infiltration.tif']
+        filenames = ['__bathymetry.tif', '__manning.tif', '__infiltration.tif', '__roof.tif']
 
         # check if present on disk
         if not all([(from_path / curfile).exists() for curfile in filenames]):
@@ -891,12 +945,13 @@ class Config_Manager_2D_GPU:
 
         arrays = [WolfArray(from_path / curfile) for curfile in filenames]
 
-        self._apply_scripts_update_topo_maning_inf(from_path, arrays[0], arrays[1], arrays[2])
+        self._apply_scripts_update_topo_maning_inf_roof(from_path, arrays[0], arrays[1], arrays[2], arrays[3])
 
         # write the files
         arrays[0].write_all(from_path / '__bathymetry_after_scripts.tif')
         arrays[1].write_all(from_path / '__manning_after_scripts.tif')
         arrays[2].write_all(from_path / '__infiltration_after_scripts.tif')
+        arrays[3].write_all(from_path / '__roof_after_scripts.tif')
 
     def _import_scripts(self, from_path:Path, which) -> list[types.ModuleType]:
         """ List all modules in structure and import them.
@@ -938,29 +993,59 @@ class Config_Manager_2D_GPU:
 
         return imported_mod
 
-    def _import_scripts_topo_manning(self, from_path:Path) -> list[types.ModuleType]:
+    def _import_scripts_topo_manning_inf_roof(self, from_path:Path) -> list[types.ModuleType]:
         """ import all topo and manning scripts from a path """
 
         return self._import_scripts(from_path, WOLF_UPDATE)
 
-    def _apply_scripts_update_topo_maning_inf(self,
+    def _apply_scripts_update_topo_maning_inf_roof(self,
                                               modules:list[types.ModuleType] | Path | str,
                                               array_bat:WolfArray,
                                               array_mann:WolfArray,
-                                              array_inf:WolfArray):
+                                              array_inf:WolfArray,
+                                              array_roof:WolfArray):
         """ Apply all scripts from a list of modules """
 
         if isinstance(modules, str):
             modules = Path(modules)
 
         if isinstance(modules, Path):
-            modules = self._import_scripts_topo_manning(modules)
+            modules = self._import_scripts_topo_manning_inf_roof(modules)
 
         for curmod in modules:
             instmod = curmod.Update_Sim_Scenario()
-            instmod.update_topobathy(array_bat)
-            instmod.update_manning(array_mann)
-            instmod.update_infiltration(array_inf)
+            try:
+                if not hasattr(instmod, "update_topobathy"):
+                    logging.info(_('No update_topobathy method found in the script {}!').format(curmod))
+                else:
+                    instmod.update_topobathy(array_bat)
+            except Exception as e:
+                logging.error(_('An error occured during bathymetry script - {}!').format(e))
+
+            try:
+                if not hasattr(instmod, "update_manning"):
+                    logging.info(_('No update_manning method found in the script {}!').format(curmod))
+                else:
+                    instmod.update_manning(array_mann)
+            except Exception as e:
+                logging.error(_('An error occured during manning script - {}!').format(e))
+
+            try:
+                if not hasattr(instmod, "update_infiltration"):
+                    logging.info(_('No update_infiltration method found in the script {}!').format(curmod))
+                else:
+                    instmod.update_infiltration(array_inf)
+            except Exception as e:
+                logging.error(_('An error occured during infiltration script - {}!').format(e))
+
+            try:
+                if not hasattr(instmod, "update_roof"):
+                    logging.info(_('No update_roof method found in the script {}!').format(curmod))
+                else:
+                    instmod.update_roof(array_roof)
+            except Exception as e:
+                logging.error(_('An error occured during roof script - {}!').format(e))
+
 
     def _import_scripts_bc(self, from_path:Path) -> list[types.ModuleType]:
         """ Import all BC's scripts from a path """
@@ -977,7 +1062,10 @@ class Config_Manager_2D_GPU:
             modules = self._import_scripts_bc(modules)
 
         for curmod in modules:
-            curmod.Impose_BC_Scenario().impose_bc(sim)
+            try:
+                curmod.Impose_BC_Scenario().impose_bc(sim)
+            except Exception as e:
+                logging.error(_('An error occured during BC script - {}!').format(e))
 
 
     def load_hydrograph(self, path:Path, toplot=True) -> tuple[Hydrograph_scenario, plt.Figure, plt.Axes]:
@@ -1059,11 +1147,30 @@ class Config_Manager_2D_GPU:
         else:
             logging.error(_("No 'bathymetry.tif' file found in the root directory !"))
 
+    def create_void_roof(self):
+        """ create void roof file """
+
+        if (self.workingdir / 'bathymetry.tif').exists():
+            locheader = self.get_header()
+            roof = WolfArray(srcheader=locheader, whichtype= WOLF_ARRAY_FULL_SINGLE)
+            roof.array.data[:,:] = 99999.
+            roof.nullvalue = 99999.
+            roof.write_all(str(self.workingdir / 'roof.tif'))
+
+            if (self.workingdir / 'roof.tif').exists():
+                logging.info(_('roof.tif created and set to 99999. ! -- Please edit it !'))
+            else:
+                logging.error(_("roof.tif not created ! --  Does 'bathymetry.tif' or any '.tif' file exist in the root directory ?"))
+        else:
+            logging.error(_("No 'bathymetry.tif' file found in the root directory !"))
+
+
     def create_simulation(self,
                           dir:Path,
                           idx_hydros:list[int] = [-1],
                           delete_existing:bool = False,
-                          preserve_ic:bool=False) -> list[Path]:
+                          preserve_ic:bool=False,
+                          callback = None) -> list[Path]:
         """ Create a simulation from different hydrographs """
 
         if isinstance(dir, str):
@@ -1159,17 +1266,32 @@ class Config_Manager_2D_GPU:
             infiltration = WolfArray(srcheader=bat.get_header(), whichtype= WOLF_ARRAY_FULL_INTEGER)
             infiltration.array.data[:,:] = 0
 
+        # check for roof
+        if exists(dir / '__roof.tif'):
+            roof = WolfArray(str(dir / '__roof.tif'))
+            if roof.wolftype != WOLF_ARRAY_FULL_SINGLE:
+                logging.error(_('Roof .tif must be a full single array ! -- The array will be ignored !'))
+                roof = WolfArray(srcheader=bat.get_header(), whichtype= WOLF_ARRAY_FULL_SINGLE)
+                roof.array.data[:,:] = 99999.
+        else:
+            roof = WolfArray(srcheader=bat.get_header(), whichtype= WOLF_ARRAY_FULL_SINGLE)
+            roof.array.data[:,:] = 99999.
+
         # applying Python scrpitps on ARRAYS
-        self._apply_scripts_update_topo_maning_inf(dir, bat, man, infiltration)
+        self._apply_scripts_update_topo_maning_inf_roof(dir, bat, man, infiltration, roof)
 
         # save arrays on disk
         bat.write_all(str(dir / '__bathymetry_after_scripts.tif'))
         man.write_all(str(dir / '__manning_after_scripts.tif'))
         infiltration.write_all(str(dir / '__infiltration_after_scripts.tif'))
+        roof.write_all(str(dir / '__roof_after_scripts.tif'))
 
         # create simulation
         allsims = []
-        for curdir, curhydro, curic in zip(used_dirs, used_hydros, used_ic):
+        for id_sim, (curdir, curhydro, curic) in enumerate(zip(used_dirs, used_hydros, used_ic)):
+
+            if callback is not None:
+                callback(id_sim)
 
             # instanciation de la simulation
             cursim = SimpleSimulation(self._header.nbx, self._header.nby)
@@ -1231,6 +1353,13 @@ class Config_Manager_2D_GPU:
 
             cursim.infiltration_zones = np.asarray(infiltration.array.data, dtype=np.int32)
 
+            if roof.nbnotnull == 0:
+                cursim.bridge_roof = None
+                logging.info(_("No cells defined as roof ! -- Roof will be ignored !"))
+            else:
+                cursim.bridge_roof = roof.array.data
+                logging.info(_("You have {} cells defined as roof").format(roof.nbnotnull))
+
             # add hydrograph
             for idx, curline in curhydro.data.iterrows():
                 cursim.add_infiltration(float(idx), [float(cur) for cur in curline.values])
@@ -1263,25 +1392,35 @@ class Config_Manager_2D_GPU:
             logging.info(cursim.check_errors())
             logging.info(_('Simulation {} created !'.format(curdir)))
 
-
             with open(curdir / 'quickrun.bat', 'w', encoding='utf-8') as f:
+                f.write("@echo off\n")
+                f.write("\n")
                 f.write(str(curdir.drive) + '\n')
                 f.write('cd {}\n'.format(str(curdir.parent)))
-                f.write('wolfgpu -quickrun ' + str(curdir.name) + '\n')
-
-                # f.write("from pathlib import Path\n")
-                # f.write("from wolfgpu.simple_simulation import SimpleSimulation\n")
-                # f.write("from wolfgpu.SimulationRunner import SimulationRunner\n")
-                # f.write("from wolfgpu.glsimulation import ResultsStore\n\n")
-                # f.write("def main():\n")
-                # f.write("\tsim = SimpleSimulation.load(Path(__file__).parent)\n")
-                # f.write("\tresult_store:ResultsStore = SimulationRunner.quick_run(sim, Path(__file__).parent)")
-                # f.write("\n\nif __name__ == '__main__':\n")
-                # f.write("\tmain()\n")
+                f.write("\n")
+                f.write("WOLFGPU_PARAMS=-quickrun " + str(curdir.name) + "\n")
+                f.write("\n")
+                f.write("where wolfgpu.exe\n")
+                f.write("IF %ERRORLEVEL%==0 (\n")
+                f.write("wolfgpu %WOLFGPU_PARAMS%\n")
+                f.write("goto :end\n")
+                f.write(")\n")
+                f.write("\n")
+                f.write("echo -------------------------------\n")
+                f.write("echo ERROR !!!\n")
+                f.write("echo -------------------------------\n")
+                f.write("echo I can't find wolfgpu.exe.\n")
+                f.write("echo It is normally installed in the 'Scripts' subdirectory of your python\n")
+                f.write("echo directory (or environment).\n")
+                f.write("echo This 'Scripts' subdirectory must be available on the PATH environment variable.\n")
+                f.write("echo I am now going to try to run wolfgpu as a regular python module\n")
+                f.write("echo -------------------------------\n")
+                f.write("pause\n")
+                f.write("python -m wolfgpu.cli %WOLFGPU_PARAMS%\n")
+                f.write(":end\n")
 
             allsims.append(curdir / 'quickrun.bat')
 
-
         logging.info(_('Simulation creation finished !'))
         logging.warning(_('Do not forget to update/set the boundary conditions if not set by scripts !'))
 
@@ -1303,10 +1442,24 @@ class Config_Manager_2D_GPU:
         with open(path, 'w', encoding='utf-8') as f:
             f.write(batch)
 
+        if self.wolfgpu is None:
+            logging.warning('****************************************************')
+            logging.warning(_('Wolfgpu.exe not found !'))
+            logging.warning(_('It is normally installed in the "Scripts" subdirectory of your python directory (or environment).'))
+            logging.warning(_('This "Scripts" subdirectory must be available on the PATH environment variable.'))
+            logging.warning('****************************************************')
+        else:
+            logging.info('****************************************************')
+            logging.info(_('Wolfgpu.exe found in {}!').format(self.wolfgpu))
+            logging.info(_('You can now run the simulations !'))
+            logging.info(_('Do not forget to activate your Python virtual environment if you are using one !'))
+            logging.info('****************************************************')
+
         return batch
 
     def run_batch(self, batch:Path):
         """ run a batch file in a subprocess """
+
         if not batch.exists():
             logging.error(_('Batch file {} does not exist !'.format(batch)))
             return
@@ -1452,29 +1605,33 @@ class UI_Manager_2D_GPU():
         self._create_void_infil.Bind(wx.EVT_BUTTON,self.oncreate_void_infil)
         self._create_void_infil.SetToolTip(_('Create a void infiltration zones file based on bathymetry.tif'))
 
+        self._create_void_roof = wx.Button(self._frame,label = _('Create .tif bridge/culvert roof elevation'))
+        self._create_void_roof.Bind(wx.EVT_BUTTON,self.oncreate_void_roof)
+        self._create_void_roof.SetToolTip(_('Create a void roof file based on bathymetry.tif'))
+
         self._create_void_scripts = wx.Button(self._frame,label = _('Create void scripts'))
         self._create_void_scripts.Bind(wx.EVT_BUTTON,self.oncreate_void_scripts)
         self._create_void_scripts.SetToolTip(_('Create void script files for topography, manning and infiltration'))
 
         self._create_vrt = wx.Button(self._frame,label = _('Assembly .vrt to current level'))
         self._create_vrt.Bind(wx.EVT_BUTTON,self.oncreatevrt)
-        self._create_vrt.SetToolTip(_('Create a .vrt file from all bathymetry and manning .tif files\nBe sure that all files are right named !\n\n - bathymetry must contain "bath"\n - manning must contain "mann"\n - infiltration must contain "infil"'))
+        self._create_vrt.SetToolTip(_('Create a .vrt file from all bathymetry, manning, infiltration and roof .tif files\nBe sure that all files are right named !\n\n - bathymetry must contain "bath"\n - manning must contain "mann"\n - infiltration must contain "infil"\n - roof must contain "roof"'))
 
         self._translate_vrt = wx.Button(self._frame,label = _('Translate .vrt to .tif'))
         self._translate_vrt.Bind(wx.EVT_BUTTON,self.ontranslatevrt2tif)
-        self._translate_vrt.SetToolTip(_('Translate .vrt files to .tif files\n\n - __bath_assembly.vrt -> __bathymetry.tif\n - __mann_assembly.vrt -> __manning.tif\n - __infil_assembly.vrt -> __infiltration.tif'))
+        self._translate_vrt.SetToolTip(_('Translate .vrt files to .tif files\n\n - __bath_assembly.vrt -> __bathymetry.tif\n - __mann_assembly.vrt -> __manning.tif\n - __infil_assembly.vrt -> __infiltration.tif\n - __roof_assembly.vrt -> __roof.tif'))
 
-        self._apply_scripts = wx.Button(self._frame,label = _('Apply scripts on bathymetry, manning and infiltration'))
+        self._apply_scripts = wx.Button(self._frame,label = _('Apply scripts on bathymetry, manning, infiltration and roof elevation'))
         self._apply_scripts.Bind(wx.EVT_BUTTON,self.onapply_scripts)
-        self._apply_scripts.SetToolTip(_('Apply scripts on bathymetry, manning and infiltration\n\n - bathymetry.tif\n - manning.tif\n - infiltration.tif\n\nThe scripts must be in the structure starting with parent directory and descending\n\n - bathymetry.py\n - manning.py\n - infiltration.py'))
+        self._apply_scripts.SetToolTip(_('Apply scripts on bathymetry, manning and infiltration\n\n - bathymetry.tif\n - manning.tif\n - infiltration.tif\n - roof.tif\n\nThe scripts must be in the structure starting with parent directory and descending.'))
 
         self._create_vec = wx.Button(self._frame,label = _('Search spatial coverage from current level'))
         self._create_vec.Bind(wx.EVT_BUTTON,self.oncreatevec)
-        self._create_vec.SetToolTip(_('Create a .vecz file (with contour and global bounds) from all bathymetry and manning .tif files\nBe sure that all files are right named !\n\n - bathymetry must contain "bath"\n - manning must contain "mann"\n - infiltration must contain "infil"'))
+        self._create_vec.SetToolTip(_('Create a .vecz file (with contour and global bounds) from all bathymetry and manning .tif files\nBe sure that all files are right named !\n\n - bathymetry must contain "bath"\n - manning must contain "mann"\n - infiltration must contain "infil"\n - roof must contain "roof"'))
 
         self._check_prefix = wx.Button(self._frame,label = _('Check prefix (tif files)'))
         self._check_prefix.Bind(wx.EVT_BUTTON,self.oncheck_prefix)
-        self._check_prefix.SetToolTip(_('Check prefix of .tif files\n\n - bath_*.tif\n - mann_*.tif\n - infil_*.tif\n\nThe prefix must be "bath_", "mann_" and "infil_"'))
+        self._check_prefix.SetToolTip(_('Check prefix of .tif files\n\n - bath_*.tif\n - mann_*.tif\n - infil_*.tif\n - roof_*.tif\n\nThe prefix must be "bath_", "mann_", "infil_" and "roof_"'))
 
         self._checkconsistency = wx.Button(self._frame,label = _('Check consistency'))
         self._checkconsistency.Bind(wx.EVT_BUTTON,self.oncheck_consistency)
@@ -1524,6 +1681,7 @@ class UI_Manager_2D_GPU():
         # buttons -> sizer
         sizer_buttons.Add(self._reload,1,wx.EXPAND)
         sizer_buttons.Add(self._create_void_infil,1,wx.EXPAND)
+        sizer_buttons.Add(self._create_void_roof,1,wx.EXPAND)
         sizer_buttons.Add(self._create_void_scripts,1,wx.EXPAND)
         sizer_buttons.Add(self._check_prefix,1,wx.EXPAND)
         sizer_buttons.Add(self._create_vrt,1,wx.EXPAND)
@@ -1592,6 +1750,12 @@ class UI_Manager_2D_GPU():
         self._parent.create_void_infil()
         self.reload()
 
+    def oncreate_void_roof(self, e:wx.MouseEvent):
+        """ Création d'un fichier de toit de pont vide """
+
+        self._parent.create_void_roof()
+        self.reload()
+
     def oncreate_void_scripts(self,e:wx.MouseEvent):
         """ Création d'un script vide """
 
@@ -1648,9 +1812,17 @@ class UI_Manager_2D_GPU():
     def oncreatevrt(self,e:wx.MouseEvent):
         """ Création d'un fichier vrt """
 
+        if self._selected_item is None:
+            logging.error(_('Please select a scenario to analyze by activating an elemnt in the tree list !'))
+            return
+
         logging.info(_('Creating vrt ...'))
         mydata = self._treelist.GetItemData(self._selected_item)
 
+        if not 'path' in mydata:
+            logging.error(_('Please select a scenario to analyze !'))
+            return
+
         # création du fichier vrt
         self._parent.create_vrt(mydata['path'])
         logging.info(_('... done !'))
@@ -1660,6 +1832,10 @@ class UI_Manager_2D_GPU():
     def oncreatevec(self,e:wx.MouseEvent):
         """ Création d'un fichier vec """
 
+        if self._selected_item is None:
+            logging.error(_('Please select a scenario to analyze by activating an elemnt in the tree list !'))
+            return
+
         logging.info(_('Creating vecz ...'))
         mydata = self._treelist.GetItemData(self._selected_item)
 
@@ -1730,7 +1906,7 @@ class UI_Manager_2D_GPU():
             return
 
         # application des scripts
-        self._parent.apply_scripts_bath_mann_inf(mydata['path'])
+        self._parent.apply_scripts_bath_mann_inf_roof(mydata['path'])
 
         self.reload()
         logging.info(_('... done !'))
@@ -1741,7 +1917,7 @@ class UI_Manager_2D_GPU():
         logging.info(_('Checking prefix ...'))
         if self._selected_item is None or self._selected_item == self._treelist.GetRootItem():
             logging.info(_('No item selected ! -- using root item'))
-            with wx.MessageDialog(None, _('No item selected ! -- using root item'), _('Warning'), wx.OK | wx.CANCEL | wx.ICON_WARNING) as dlg:
+            with wx.MessageDialog(None, _('No item selected ! -- using root item ?'), _('Warning'), wx.OK | wx.CANCEL | wx.ICON_WARNING) as dlg:
                 ret = dlg.ShowModal()
                 if ret != wx.ID_OK:
                     return
@@ -1752,7 +1928,7 @@ class UI_Manager_2D_GPU():
         # création du fichier vrt
         log = self._parent.check_prefix(mydata['.tif']+mydata['.tiff'])
         if log =='':
-            self._txtctrl.WriteText(_("All is fine !"))
+            self._txtctrl.WriteText("\n".join([_("All is fine !")]))
         else:
             self._txtctrl.WriteText(log)
 
@@ -1763,9 +1939,33 @@ class UI_Manager_2D_GPU():
 
         log = self._parent.check_consistency()
         if log =='':
-            self._txtctrl.WriteText(_("All is fine !"))
+            self._txtctrl.WriteText("\n\n".join([_("All is fine !")]))
         else:
-            self._txtctrl.WriteText(log)
+            self._txtctrl.WriteText("\n\n".join([log]))
+
+        # Info on Python Environment and wolfgpu Path and version
+        # -------------------------------------------------------
+
+        import sys
+        # Python Environment
+        self._txtctrl.write(_('\nPython Environment\n'))
+        self._txtctrl.write('-------------------\n')
+        self._txtctrl.write('Python version : {}\n'.format(sys.version))
+        self._txtctrl.write('Python path : {}\n'.format(sys.executable))
+        self._txtctrl.write('Python version info : {}\n'.format(sys.version_info))
+
+        # Test if wolfgpu.exe exists in script directory
+        # wolfgpu Path and version
+        self._txtctrl.write('\nWolfgpu Path and version\n')
+        self._txtctrl.write('------------------------\n')
+
+        wolfgpu = self._parent.wolfgpu
+        if wolfgpu.exists():
+            self._txtctrl.write('Wolfgpu.exe found in : {}\n'.format(self._parent.wolfgpu.parent))
+        else:
+            self._txtctrl.write('Wolfgpu.exe not found !\n')
+            self._parent.wolfgpu = None
+
 
     def choice_hydrograph(self) -> list[int]:
 
@@ -1871,7 +2071,11 @@ class UI_Manager_2D_GPU():
             preserve_ic = ret == wx.ID_YES
             dlg.Destroy()
 
-        allsims = self._parent.create_simulation(Path(path), hydro, destroy_if_exists, preserve_ic)
+        pgbar = wx.ProgressDialog(_('Creating simulations ...'), _('Please wait ...'), maximum=len(hydro), parent=self._frame, style = wx.PD_APP_MODAL | wx.PD_AUTO_HIDE)
+
+        allsims = self._parent.create_simulation(Path(path), hydro, destroy_if_exists, preserve_ic, callback=pgbar.Update)
+
+        pgbar.Destroy()
 
         self.reload()
 
@@ -1975,7 +2179,7 @@ class UI_Manager_2D_GPU():
                 try:
                     if curwp.Shown:
                         cursim.from_wolfparam(curwp)
-                        cursim.save_json()
+                        cursim._save_json()
                 except Exception as e:
                     self._wp[cursim] = None
                     logging.debug(_('Error while saving parameters for simulation {}'.format(cursim.path.name)))
@@ -1989,7 +2193,7 @@ class UI_Manager_2D_GPU():
                 try:
                     if curwp.Shown:
                         cursim.from_wolfparam(curwp)
-                        cursim.save_json()
+                        cursim._save_json()
                 except Exception as e:
                     self._wp[cursim] = None
                     logging.debug(_('Error while saving parameters for simulation {}'.format(cursim.path.name)))