wolfhece 2.1.98__py3-none-any.whl → 2.1.99__py3-none-any.whl

wolfhece/scenario/config_manager.py

@@ -153,12 +153,20 @@ class InitialConditions_scenario():
 
         if (dir / IC_scenario.WATERDEPTH.value).exists():
             self.h = np.load(dir / IC_scenario.WATERDEPTH.value)
+        else:
+            logging.warning(_('No waterdepth file found !'))
         if (dir / IC_scenario.DISCHARGE_X.value).exists():
             self.qx = np.load(dir / IC_scenario.DISCHARGE_X.value)
+        else:
+            logging.warning(_('No discharge x file found !'))
         if (dir / IC_scenario.DISCHARGE_Y.value).exists():
             self.qy = np.load(dir / IC_scenario.DISCHARGE_Y.value)
+        else:
+            logging.warning(_('No discharge y file found !'))
         if (dir /IC_scenario.BATHYMETRY.value).exists():
             self.bathy = np.load(dir / IC_scenario.BATHYMETRY.value)
+        else:
+            logging.warning(_('No bathymetry file found !'))
 
     @property
     def z_elevation(self) -> np.ndarray:
@@ -231,6 +239,15 @@ class Config_Manager_2D_GPU:
 
         self.load_data()
 
+    def _test_ui(self):
+        """ Test if the UI is available """
+
+        if self._ui is not None:
+            if self._ui._frame.IsShown():
+                return True
+
+        return False
+
     def load_data(self):
         """ Chargement/Rechargement des données """
         self.configs = {}
@@ -418,7 +435,7 @@ class Config_Manager_2D_GPU:
         _flatten(self.configs, self._flat_configs)
 
 
-    def check_prefix(self, list_tif:list[Path]) -> bool:
+    def check_prefix(self, list_tif:list[Path]) -> str:
         """ Check if all files have the right prefix """
 
         logging.info(_('Checking if prefix of all files are right...\n'))
@@ -450,7 +467,7 @@ class Config_Manager_2D_GPU:
                         loclog += _('Did you mean "bath_" ?') + '\n'
                         break
 
-                tests = ['infil_', 'infl_', 'nfil_', 'ifil_', 'infiltration_']
+                tests = ['infil_', 'infl_', 'nfil_', 'ifil_', 'infiltration_', 'infli_']
                 for test in tests:
                     if curtif.name.lower().startswith(test):
                         loclog += _('Did you mean "infil_" ?') + '\n'
@@ -458,7 +475,9 @@ class Config_Manager_2D_GPU:
 
                 logging.warning(loclog)
 
-        return loclog
+                log += loclog
+
+        return log
 
     def check_consistency(self) -> str:
         """
@@ -505,7 +524,7 @@ class Config_Manager_2D_GPU:
     # Analyze files
     # -------------
 
-    def _find_files_subdirs(self, wd:Path, curdict:dict):
+    def _find_files_subdirs(self, wd:Path, curdict:dict, erase_cache:bool = True):
         """ Recherche des fichiers de simulation/scenario dans un répertoire """
 
         # create list for all extensions
@@ -517,6 +536,14 @@ class Config_Manager_2D_GPU:
         for curel in scandir(wd):
             if curel.is_file():
                 if not curel.name.startswith('__'):
+                    if curel.name.startswith('cache_'):
+                        if erase_cache:
+                            # Delete cache file if exists. Normally, it should not exist as it is created by WOLF as temporary file.
+                            # It will be recreated by WOLF if necessary and destroyed at the end of the process.
+                            # The presence of this file is a sign that the simulation creation process was not completed.
+                            Path(curel).unlink()
+                            continue
+
                     parts=splitext(curel)
 
                     if len(parts)==2:
@@ -555,14 +582,14 @@ class Config_Manager_2D_GPU:
         # test if it is a results directory
         self._test_is_results(curdict)
 
-    def _recursive_find_files(self, wd:Path, curdict:dict):
+    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 """
         if len(curdict.keys())>0:
             for k in curdict.keys():
                 self._recursive_find_files(k, curdict[k])
 
         if not '__' in wd.name:
-            self._find_files_subdirs(wd, curdict)
+            self._find_files_subdirs(wd, curdict, erase_cache)
 
     def _prefill_dict(self, curdict:dict):
         """ Création des listes pour toutes les extensions """
@@ -809,7 +836,7 @@ class Config_Manager_2D_GPU:
                     new_zones.add_zone(new_zone)
 
                     curarray = WolfArray(curtif)
-                    curarray.nullify_border(width=1)
+                    curarray.nullify_border(width=1) # Force a null value border --> necessary to avoid artefacts in the contour as no test is done on the border
                     sux, sux, curvect, interior = curarray.suxsuy_contour()
                     new_zone.add_vector(curvect, forceparent=True)
                     curvect.set_legend_to_centroid(curtif.name)
@@ -848,88 +875,108 @@ class Config_Manager_2D_GPU:
             if (from_path / curin).exists():
                 translate_vrt2tif(from_path / curin, from_path / curout)
 
-    def _import_scripts_topo_manning(self, from_path:Path) -> list[types.ModuleType]:
-        """ find all scripts from/up a path """
+    def apply_scripts_bath_mann_inf(self, from_path:Path):
+        """ Apply all scripts """
 
-        # tous les fichiers .py
-        # import des modules
-        imported_modules = import_files(from_path.glob('*.py'))
+        filenames = ['__bathymetry.tif', '__manning.tif', '__infiltration.tif']
 
-        return imported_modules
+        # check if present on disk
+        if not all([(from_path / curfile).exists() for curfile in filenames]):
+            logging.error(_('At least one of the files is missing !'))
+
+            for curfile in filenames:
+                if not (from_path / curfile).exists():
+                    logging.error(_(f'{curfile} is missing !'))
+            return
+
+        arrays = [WolfArray(from_path / curfile) for curfile in filenames]
+
+        self._apply_scripts_update_topo_maning_inf(from_path, arrays[0], arrays[1], arrays[2])
+
+        # 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')
+
+    def _import_scripts(self, from_path:Path, which) -> list[types.ModuleType]:
+        """ List all modules in structure and import them.
+
+        As multiple files with a same name can be found in the structure,
+        a copy of the file is made in the same folder with a unique name
+        and then imported.
+
+        So, if a file is required in the script, the relative import can be used.
+        If we cache the file in an other folder, the relative import will not work.
+
+        After the import, the copied files are deleted.
+        """
 
-    def _list_modules(self, from_path:Path):
-        """ List all modules in structure """
         import shutil
 
+        assert isinstance(from_path, Path), _('Bad type for from_path !')
+
         curtree = self.get_tree(from_path)
         curdicts = self.get_dicts(curtree)
 
         # tous les fichiers .py -> list of lists
-        all_py = [curpy for curdict in curdicts for curpy in curdict[GPU_2D_file_extensions.PY.value][WOLF_UPDATE]]
+        all_py = [curpy for curdict in curdicts for curpy in curdict[GPU_2D_file_extensions.PY.value][which]]
 
-        # make a copy in the cache folder
-        cache_dir = from_path / '.cache_tmi'
-        cache_dir.mkdir(exist_ok=True)
+        # make a copy in a cache file in the same folder but with a unique name
+        to_import = []
+        for idx, cur_py in enumerate(all_py):
+            cur_py:Path
+            cur_dir = cur_py.parent
+            cached_name = 'cache_py_' + cur_py.stem + str(idx) + '.py'
+            shutil.copy(cur_py, cur_dir / cached_name)
+            to_import.append(cur_dir / cached_name)
 
-        # delete all file in the cache folder
-        for curfile in cache_dir.glob('*.py'):
-            curfile.unlink()
+        imported_mod = import_files(to_import)
 
-        # make a copy of all files in the cache folder
-        for idx, cur_py in enumerate(all_py):
-            shutil.copy(cur_py, cache_dir / f'{idx}.py')
+        # #del all caches files
+        # for cur_py in to_import:
+        #     cur_py.unlink()
+
+        return imported_mod
+
+    def _import_scripts_topo_manning(self, from_path:Path) -> list[types.ModuleType]:
+        """ import all topo and manning scripts from a path """
 
-        return self._import_scripts_topo_manning(cache_dir)
+        return self._import_scripts(from_path, WOLF_UPDATE)
 
     def _apply_scripts_update_topo_maning_inf(self,
-                                              dir_modules:Path,
+                                              modules:list[types.ModuleType] | Path | str,
                                               array_bat:WolfArray,
                                               array_mann:WolfArray,
                                               array_inf:WolfArray):
         """ Apply all scripts from a list of modules """
 
-        all_py = self._list_modules(dir_modules)
+        if isinstance(modules, str):
+            modules = Path(modules)
+
+        if isinstance(modules, Path):
+            modules = self._import_scripts_topo_manning(modules)
 
-        for curmod in all_py:
+        for curmod in modules:
             instmod = curmod.Update_Sim_Scenario()
             instmod.update_topobathy(array_bat)
             instmod.update_manning(array_mann)
             instmod.update_infiltration(array_inf)
 
     def _import_scripts_bc(self, from_path:Path) -> list[types.ModuleType]:
-        """ find all scripts from/up a path """
-        import shutil
-
-        curtree = self.get_tree(from_path)
-        curdicts = self.get_dicts(curtree)
-
-        # tous les fichiers .py -> list of lists
-        all_py = [curpy for curdict in curdicts for curpy in curdict[GPU_2D_file_extensions.PY.value][WOLF_BC]]
+        """ Import all BC's scripts from a path """
 
-        cache_dir = from_path / '.cache_bc'
-        cache_dir.mkdir(exist_ok=True)
+        return self._import_scripts(from_path, WOLF_BC)
 
-        # delete all file in the cache folder
-        for curfile in cache_dir.glob('*.py'):
-            curfile.unlink()
-
-        # make a copy of all files in the cache folder
-        cache_py = []
-        for idx, cur_py in enumerate(all_py):
-            shutil.copy(cur_py, cache_dir / f'{idx}.py')
-            cache_py.append(cache_dir / f'{idx}.py')
-
-        # import des modules
-        imported_modules = import_files(cache_py)
-
-        return imported_modules
+    def _apply_scripts_bc(self, modules:list[types.ModuleType] | Path | str, sim:SimpleSimulation):
+        """ Apply all scripts from a list of modules """
 
+        if isinstance(modules, str):
+            modules = Path(modules)
 
-    def _apply_scripts_bc(self, modules:list[types.ModuleType], sim:SimpleSimulation):
-        """ Apply all scripts from a list of modules """
+        if isinstance(modules, Path):
+            modules = self._import_scripts_bc(modules)
 
         for curmod in modules:
-
             curmod.Impose_BC_Scenario().impose_bc(sim)
 
 
@@ -946,9 +993,11 @@ class Config_Manager_2D_GPU:
     def load_ic(self, path:Path) -> InitialConditions_scenario:
         """ Load initial conditions from a path """
 
+        path = Path(path)
+
         low_keys = [Path(curkey).name.lower() for curkey in self.configs.keys()]
         if INITIAL_CONDITIONS in low_keys:
-            return InitialConditions_scenario(self.workingdir / INITIAL_CONDITIONS / path)
+            return InitialConditions_scenario(self.workingdir / INITIAL_CONDITIONS / path.stem.replace('sim_', ''))
         else:
             return None
 
@@ -1111,7 +1160,6 @@ class Config_Manager_2D_GPU:
             infiltration.array.data[:,:] = 0
 
         # applying Python scrpitps on ARRAYS
-        # self._apply_scripts_update_topo_maning_inf(self._import_scripts_topo_manning(dir), bat, man, infiltration)
         self._apply_scripts_update_topo_maning_inf(dir, bat, man, infiltration)
 
         # save arrays on disk
@@ -1143,11 +1191,15 @@ class Config_Manager_2D_GPU:
             cursim.nap[cursim.bathymetry != 99999.] = 1
 
             if curic is None:
+                curic:InitialConditions_scenario
+                # No global initial conditions
                 if not preserve_ic:
+                    # reset initial conditions
                     cursim.h          = np.zeros((self._header.nbx, self._header.nby), dtype=np.float32)
                     cursim.qx         = np.zeros((self._header.nbx, self._header.nby), dtype=np.float32)
                     cursim.qy         = np.zeros((self._header.nbx, self._header.nby), dtype=np.float32)
                 else:
+                    # Using initial conditions from disk - sim directory
                     if (curdir / 'h.npy').exists():
                         cursim.h = np.load(curdir / 'h.npy')
                     else:
@@ -1161,19 +1213,21 @@ class Config_Manager_2D_GPU:
                     else:
                         cursim.qy = np.zeros((self._header.nbx, self._header.nby), dtype=np.float32)
             else:
-                if curic.h is not None:
-                    cursim.h = curic.h
-                else:
-                    cursim.h = np.zeros((self._header.nbx, self._header.nby), dtype=np.float32)
-                if curic.qx is not None:
-                    cursim.qx = curic.qx
-                else:
-                    cursim.qx = np.zeros((self._header.nbx, self._header.nby), dtype=np.float32)
+                if not preserve_ic:
+                    # Using global initial conditions if available
+                    if curic.h is not None:
+                        cursim.h = curic.h
+                    else:
+                        cursim.h = np.zeros((self._header.nbx, self._header.nby), dtype=np.float32)
+                    if curic.qx is not None:
+                        cursim.qx = curic.qx
+                    else:
+                        cursim.qx = np.zeros((self._header.nbx, self._header.nby), dtype=np.float32)
 
-                if curic.qy is not None:
-                    cursim.qy = curic.qy
-                else:
-                    cursim.qy = np.zeros((self._header.nbx, self._header.nby), dtype=np.float32)
+                    if curic.qy is not None:
+                        cursim.qy = curic.qy
+                    else:
+                        cursim.qy = np.zeros((self._header.nbx, self._header.nby), dtype=np.float32)
 
             cursim.infiltration_zones = np.asarray(infiltration.array.data, dtype=np.int32)
 
@@ -1199,7 +1253,7 @@ class Config_Manager_2D_GPU:
             cursim._param_report_period = SimulationDuration.from_seconds(3600)
 
             # applying Python scrpitps on SIMULATION --> Boundary conditions
-            self._apply_scripts_bc(self._import_scripts_bc(dir), cursim)
+            self._apply_scripts_bc(dir, cursim)
 
             # cursim.h[cursim.infiltration_zones > 0] = .5
 
@@ -1276,8 +1330,17 @@ class Config_Manager_2D_GPU:
         """ Transfer IC from one sim to another """
 
         ic1 = self.load_ic(dir1)
+
+        if ic1 is None:
+            logging.error(_('No IC found in {} !'.format(dir1)))
+            return
+
         ic2 = self.load_ic(dir2)
 
+        if ic2 is None:
+            logging.error(_('No IC found in {} !'.format(dir2)))
+            return
+
         ic2.qx = ic1.qx
         ic2.qy = ic1.qy
         ic2.set_h_from_z(ic1.z_elevation)
@@ -1401,6 +1464,10 @@ class UI_Manager_2D_GPU():
         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._apply_scripts = wx.Button(self._frame,label = _('Apply scripts on bathymetry, manning and infiltration'))
+        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._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"'))
@@ -1417,9 +1484,9 @@ class UI_Manager_2D_GPU():
         self._createsim.Bind(wx.EVT_BUTTON,self.oncreate_simulation)
         self._createsim.SetToolTip(_('Create simulation(s) from selected hydrographs'))
 
-        self._transfer_ic = wx.Button(self._frame,label = _('Transfer initial conditions'))
+        self._transfer_ic = wx.Button(self._frame,label = _('Transfer global initial conditions'))
         self._transfer_ic.Bind(wx.EVT_BUTTON,self.ontransfer_ic)
-        self._transfer_ic.SetToolTip(_('Transfer initial conditions from a simulation to another'))
+        self._transfer_ic.SetToolTip(_('Transfer global initial conditions from a simulation to another\n\nThe directory {} must exist !\n\nAnd subdirectories related to the discharges must also be present.\n\nIf not, firstly, extract global IC with ALT+DCLICK on simulations.'.format(INITIAL_CONDITIONS)))
 
         self._extract_tif = wx.Button(self._frame,label = _('Extract .tif files for all selected scenarios'))
         self._extract_tif.Bind(wx.EVT_BUTTON,self.onextract_tif)
@@ -1458,9 +1525,10 @@ class UI_Manager_2D_GPU():
         sizer_buttons.Add(self._reload,1,wx.EXPAND)
         sizer_buttons.Add(self._create_void_infil,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)
         sizer_buttons.Add(self._translate_vrt,1,wx.EXPAND)
-        sizer_buttons.Add(self._check_prefix,1,wx.EXPAND)
+        sizer_buttons.Add(self._apply_scripts,1,wx.EXPAND)
         sizer_buttons.Add(self._checkconsistency,1,wx.EXPAND)
         sizer_buttons.Add(self._create_vec,1,wx.EXPAND)
         sizer_buttons.Add(self.listsims,1,wx.EXPAND)
@@ -1508,16 +1576,21 @@ class UI_Manager_2D_GPU():
 
         self._parent.filter_independent = self.filter.GetValue()
 
+    def reload(self):
+        """ Reload the structure """
+
+        self._parent.load_data()
+
     def onupdate_structure(self,e:wx.MouseEvent):
         """ Mise à jour de la structure """
 
-        self._parent.load_data()
+        self.reload()
 
     def oncreate_void_infil(self, e:wx.MouseEvent):
         """ Création d'un fichier d'infiltration vide """
 
         self._parent.create_void_infil()
-        self._parent.load_data()
+        self.reload()
 
     def oncreate_void_scripts(self,e:wx.MouseEvent):
         """ Création d'un script vide """
@@ -1570,7 +1643,7 @@ class UI_Manager_2D_GPU():
 
         bc_void(file_bc)
 
-        self._parent.load_data()
+        self.reload()
 
     def oncreatevrt(self,e:wx.MouseEvent):
         """ Création d'un fichier vrt """
@@ -1582,6 +1655,8 @@ class UI_Manager_2D_GPU():
         self._parent.create_vrt(mydata['path'])
         logging.info(_('... done !'))
 
+        self.reload()
+
     def oncreatevec(self,e:wx.MouseEvent):
         """ Création d'un fichier vec """
 
@@ -1612,6 +1687,8 @@ class UI_Manager_2D_GPU():
 
         dlg.Destroy()
 
+        self.reload()
+
     def ontranslatevrt2tif(self,e:wx.MouseEvent):
         """ Traduction d'un fichier vrt en tif """
 
@@ -1626,10 +1703,38 @@ class UI_Manager_2D_GPU():
         else:
             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.translate_vrt2tif(mydata['path'])
         logging.info(_('... done !'))
 
+    def onapply_scripts(self,e:wx.MouseEvent):
+        """ Application des scripts sur les fichiers tif """
+
+        logging.info(_('Applying scripts ...'))
+        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:
+                ret = dlg.ShowModal()
+                if ret != wx.ID_OK:
+                    return
+            mydata = self._parent.configs
+        else:
+            mydata = self._treelist.GetItemData(self._selected_item)
+
+        if not 'path' in mydata:
+            logging.error(_('Please select a scenario to analyze !'))
+            return
+
+        # application des scripts
+        self._parent.apply_scripts_bath_mann_inf(mydata['path'])
+
+        self.reload()
+        logging.info(_('... done !'))
+
     def oncheck_prefix(self,e:wx.MouseEvent):
         """ Vérification des préfixes des fichiers tif """
 
@@ -1693,6 +1798,8 @@ class UI_Manager_2D_GPU():
         for cursim in sims:
             self._parent.extract_tif(cursim['path'], wdir)
 
+        self.reload()
+
         logging.info(_('... done !'))
 
     def ontransfer_ic(self, e:wx.MouseEvent):
@@ -1716,6 +1823,7 @@ class UI_Manager_2D_GPU():
 
         self._parent.transfer_ic(Path(wdir), Path(wdir2))
 
+        self.reload()
 
     def oncreate_simulation(self, e:wx.MouseEvent):
         """ Creation d'une simulation """
@@ -1765,7 +1873,7 @@ class UI_Manager_2D_GPU():
 
         allsims = self._parent.create_simulation(Path(path), hydro, destroy_if_exists, preserve_ic)
 
-        self._parent.load_data()
+        self.reload()
 
         if allsims is None:
             logging.error(_('No simulation created !'))
@@ -2042,7 +2150,7 @@ class UI_Manager_2D_GPU():
                     res_path = mydata['path'] / 'simul_gpu_results'
                     if res_path.exists():
                         sim = SimpleSimulation.load(mydata['path'])
-                        destpath = self._parent.workingdir / 'initial_conditions' / mydata['path'].name.replace('sim_', '')
+                        destpath = self._parent.workingdir / INITIAL_CONDITIONS / mydata['path'].name.replace('sim_', '')
                         sim.write_initial_condition_from_record(res_path, None, destpath)
 
                         if self._parent.filter_independent:
@@ -2173,7 +2281,7 @@ class UI_Manager_2D_GPU():
 
         waterdepth = icpath / 'h.npy'
         waterdepth = np.load(waterdepth)
-        np.save(icpath / '_h_backup.npy', waterdepth)
+        np.save(icpath / '_h_before_filtering.npy', waterdepth)
 
         # labellisation
         labeled_array = waterdepth.copy()
@@ -2197,14 +2305,14 @@ class UI_Manager_2D_GPU():
         qx = icpath / 'qx.npy'
         if qx.exists():
             qx = np.load(qx)
-            np.save(icpath / '_qx_backup.npy', qx)
+            np.save(icpath / '_qx_before_filtering.npy', qx)
             qx[newh==0.]=0.
             np.save(icpath / 'qx.npy', qx)
 
         qy = icpath / 'qy.npy'
         if qy.exists():
             qy = np.load(qy)
-            np.save(icpath / '_qy_backup.npy', qy)
+            np.save(icpath / '_qy_before_filtering.npy', qy)
             qy[newh==0.]=0.
             np.save(icpath / 'qy.npy', qy)
 

wolfhece/wolf_array.py

@@ -49,19 +49,19 @@ from copy import deepcopy
 from enum import Enum
 
 try:
-    from osgeo import gdal
+    from .PyTranslate import _
 except ImportError as e:
     print(e)
-    raise Exception(_('Error importing GDAL library'))
+    raise Exception(_('Error importing modules'))
 
 try:
-    from .Coordinates_operations import reproject_and_resample_raster
+    from osgeo import gdal
 except ImportError as e:
     print(e)
-    raise Exception(_('Error importing modules'))
+    raise Exception(_('Error importing GDAL library'))
 
 try:
-    from .PyTranslate import _
+    from .Coordinates_operations import reproject_and_resample_raster
 except ImportError as e:
     print(e)
     raise Exception(_('Error importing modules'))
@@ -7525,7 +7525,7 @@ class WolfArray(Element_To_Draw, header_wolf):
                 if update_min_max:
                     self.mypal.distribute_values(self.array.min(), self.array.max())
 
-    def write_all(self, newpath:str = None, EPSG:int = 31370):
+    def write_all(self, newpath:str | Path = None, EPSG:int = 31370):
         """
         Ecriture de tous les fichiers d'un Wolf array
 

wolfhece/wolfresults_2D.py

@@ -12,6 +12,7 @@ import sys
 import wx
 from os.path import dirname, exists, join, splitext
 from math import floor
+from pathlib import Path
 
 import numpy.ma as ma
 import numpy as np
@@ -51,7 +52,6 @@ except Exception as ex:
 
     from importlib.util import find_spec
     s = find_spec('wolfhece.libs.wolfpy')
-    from pathlib import Path
 
     # Not too sure about this find_spec. If the root
     # directory is not the good one, the import search may
@@ -747,7 +747,6 @@ class Props_Res_2D(wx.Frame):
         """ Load default palette """
 
         import glob
-        from pathlib import Path
 
         # list of all .pal file in model directory
 
@@ -2303,6 +2302,25 @@ class Wolfresults_2D(Element_To_Draw):
         self.myops = None
         self._active_blocks = 0
 
+    @property
+    def all_dt(self):
+        #FIXME : defined in GPU version --> to be implemented for CPU version
+        pass
+
+    @property
+    def all_mostly_dry_mesh(self):
+        #FIXME : defined in GPU version --> to be implemented for CPU version
+        pass
+
+    @property
+    def all_clock_time(self):
+        #FIXME : defined in GPU version --> to be implemented for CPU version
+        pass
+
+    @property
+    def all_wet_meshes(self):
+        #FIXME : defined in GPU version --> to be implemented for CPU version
+        pass
 
     def set_opacity(self, alpha:float):
         """ Set the transparency of the array """
@@ -4435,9 +4453,9 @@ class Wolfresults_2D(Element_To_Draw):
     def export_as(self,
                   outdir:str,
                   fields:list[views_2D],
-                  which:Literal['geotiff', 'shape'],
+                  which:Literal['geotiff', 'shape', 'numpy'],
                   multiband:bool=True):
-        """ Export as geotiff or shapefile """
+        """ Export as geotiff or shapefile or numpy """
 
         oldview = self.get_currentview()
         old_plotted = self.plotted
@@ -4470,6 +4488,19 @@ class Wolfresults_2D(Element_To_Draw):
                             [key.value for key,arr in arrays.items()],
                             shape_mask)
 
+        elif which=='numpy':
+            for curfield, curarray in arrays.items():
+                if curfield == views_2D.TOPOGRAPHY:
+                    curarray.write_all(Path(outdir) / 'bathymetry.npy')
+                elif curfield == views_2D.WATERDEPTH:
+                    curarray.write_all(Path(outdir) / 'h.npy')
+                elif curfield == views_2D.QX:
+                    curarray.write_all(Path(outdir) / 'qx.npy')
+                elif curfield == views_2D.QY:
+                    curarray.write_all(Path(outdir) / 'qy.npy')
+                else:
+                    curarray.write_all(Path(outdir) / (curfield.value + '.npy'))
+
         self.plotted = old_plotted
         self.set_currentview(oldview)
 

{wolfhece-2.1.98.dist-info → wolfhece-2.1.99.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wolfhece
-Version: 2.1.98
+Version: 2.1.99
 Author-email: Pierre Archambeau <pierre.archambeau@uliege.be>
 License: Copyright (c) 2024 University of Liege. All rights reserved.
 Project-URL: Homepage, https://uee.uliege.be/hece