wolfhece 2.2.23__py3-none-any.whl → 2.2.24__py3-none-any.whl

wolfhece/Coordinates_operations.py

@@ -1,4 +1,5 @@
 from pyproj import Transformer
+from pyproj.transformer import TransformerGroup
 from concurrent.futures import ProcessPoolExecutor
 import numpy as np
 from osgeo import gdal
@@ -19,7 +20,8 @@ def transform_chunk_coordinates(inputEPSG:str, outputEPSG:str, chunk:np.ndarray)
     :type chunk: np.ndarray
     """
     COO_TRANSFORMER = Transformer.from_crs(inputEPSG, outputEPSG, always_xy=True)
-    return COO_TRANSFORMER.transform(chunk[:, 0], chunk[:, 1])
+    ret = COO_TRANSFORMER.transform(chunk[:, 0], chunk[:, 1])
+    return ret
 
 def transform_coordinates(points:np.ndarray, inputEPSG:str="EPSG:3812", outputEPSG:str="EPSG:31370", chunk_size:int=1000):
     """

wolfhece/PyDraw.py

@@ -4914,7 +4914,8 @@ class WolfMapViewer(wx.Frame):
                        dpi:int= 300,
                        add_title:bool = False,
                        figsizes= [10.,10.],
-                       arrayid_as_title:bool = False):
+                       arrayid_as_title:bool = False,
+                       resid_as_title:bool = False):
         """
         Sauvegarde de la fenêtre d'affichage dans un fichier
 
@@ -4970,6 +4971,8 @@ class WolfMapViewer(wx.Frame):
                 pot_title = self.viewer_name
                 if arrayid_as_title:
                     pot_title = self.active_array.idx
+                if resid_as_title:
+                    pot_title = self.active_res2d.idx
 
                 self.display_canvasogl(fig=fig,
                                        ax=ax,
@@ -9919,16 +9922,21 @@ class WolfMapViewer(wx.Frame):
 
         # Get all checked arrays
         checked_arrays = self.get_list_keys(drawing_type= draw_type.ARRAYS, checked_state= True)
+        checked_results = self.get_list_keys(drawing_type= draw_type.RES2D, checked_state= True)
+
         old_active = self.active_array
+        old_res2d = self.active_res2d
 
-        if len(checked_arrays) == 0:
+        if len(checked_arrays) + len(checked_results) == 0:
             logging.warning(_('No arrays checked for export'))
-            return
+            return []
 
         def uncheck_all():
             # uncheck arrays
             for curarray in checked_arrays:
                 self.uncheck_id(curarray, unload= False, forceresetOGL= False)
+            for curres in checked_results:
+                self.uncheck_id(curres, unload= False, forceresetOGL= False)
 
         fn = str(fn)
         ret = []
@@ -9938,10 +9946,21 @@ class WolfMapViewer(wx.Frame):
             self.active_array = self.get_obj_from_id(curel, drawtype= draw_type.ARRAYS)
             ret.append((self.save_canvasogl(fn + '_' + str(idx) + '.png', mpl, ds, add_title= add_title, arrayid_as_title=True), curel))
 
+        for idx, curel in enumerate(checked_results):
+            uncheck_all()
+            self.check_id(curel)
+            self.active_res2d = self.get_obj_from_id(curel, drawtype= draw_type.RES2D)
+            ret.append((self.save_canvasogl(fn + '_' + str(idx + len(checked_arrays)) + '.png', mpl, ds, add_title= add_title, resid_as_title=True), curel))
+
         self.active_array = old_active
+        self.active_res2d = old_res2d
+
         for curarray in checked_arrays:
             self.check_id(curarray)
 
+        for curres in checked_results:
+            self.check_id(curres)
+
         self.Refresh()
 
         return ret
@@ -11757,6 +11776,97 @@ class WolfMapViewer(wx.Frame):
             else:
                 logging.warning(_('Reload not yet implemented for this type of object'))
 
+        elif _('Rasterize active zone') in text:
+
+            if self.active_array is None and self.active_res2d is None:
+                logging.warning(_('No active array selected'))
+                return
+
+            if self.active_array is not None and self.active_res2d is not None:
+                # Show a dialog to choose between array or res2d
+                dlg = wx.SingleChoiceDialog(None, _('Choose the type of rasterization'), _('Rasterization Type'), ['Array', 'Res2D'], style=wx.CHOICEDLG_STYLE)
+                ret = dlg.ShowModal()
+                if ret != wx.ID_OK:
+                    dlg.Destroy()
+                    return
+                choice = dlg.GetSelection()
+                dlg.Destroy()
+                if choice == 0:
+                    based_array = self.active_array
+                else:
+                    if self.active_res2d.nb_blocks == 1:
+                        based_array = self.active_res2d.get_header_block(1)
+                    elif self.active_res2d.nb_blocks > 1:
+                        logging.error(_('Rasterization not implemented for multi-blocks res2d -- Convert to mono-blocks first'))
+                        return
+
+            elif self.active_array is not None:
+                based_array = self.active_array
+            elif self.active_res2d is not None:
+                if self.active_res2d.nb_blocks == 1:
+                    based_array = self.active_res2d.get_header_block(1)
+                elif self.active_res2d.nb_blocks > 1:
+                    logging.error(_('Rasterization not implemented for multi-blocks res2d -- Convert to mono-blocks first'))
+                    return
+
+            if isinstance(self.selected_object, Zones):
+                if self.selected_object.active_zone is None:
+                    logging.warning(_('No active zone selected'))
+                    return
+                if self.selected_object.active_zone.parent is None:
+                    logging.warning(_('No parent object for the active zone'))
+                else:
+                    new_zone = based_array.rasterize_zone_along_grid(self.selected_object.active_zone, outformat= zone)
+                    if new_zone is not None:
+                        new_zone.myname = self.selected_object.active_zone.myname + '_rasterized'
+                        self.selected_object.active_zone.parent.add_zone(new_zone, forceparent=True)
+                        self.selected_object.active_zone.parent.fill_structure()
+                        self.selected_object.active_zone.reset_listogl()
+
+        elif _('Rasterize active vector') in text:
+
+            if self.active_array is None and self.active_res2d is None:
+                logging.warning(_('No active array selected'))
+                return
+
+            if self.active_array is not None and self.active_res2d is not None:
+                # Show a dialog to choose between array or res2d
+                dlg = wx.SingleChoiceDialog(None, _('Choose the type of rasterization'), _('Rasterization Type'), ['Array', 'Res2D'], style=wx.CHOICEDLG_STYLE)
+                ret = dlg.ShowModal()
+                if ret != wx.ID_OK:
+                    dlg.Destroy()
+                    return
+                choice = dlg.GetSelection()
+                dlg.Destroy()
+                if choice == 0:
+                    based_array = self.active_array
+                else:
+                    if self.active_res2d.nb_blocks == 1:
+                        based_array = self.active_res2d.get_header_block(1)
+                    elif self.active_res2d.nb_blocks > 1:
+                        logging.error(_('Rasterization not implemented for multi-blocks res2d -- Convert to mono-blocks first'))
+                        return
+
+            elif self.active_array is not None:
+                based_array = self.active_array
+            elif self.active_res2d is not None:
+                if self.active_res2d.nb_blocks == 1:
+                    based_array = self.active_res2d.get_header_block(1)
+                elif self.active_res2d.nb_blocks > 1:
+                    logging.error(_('Rasterization not implemented for multi-blocks res2d -- Convert to mono-blocks first'))
+                    return
+
+            if isinstance(self.selected_object, Zones):
+                if self.selected_object.active_vector is None:
+                    logging.warning(_('No active vector selected'))
+                    return
+
+                vec_raster = based_array.rasterize_vector_along_grid(self.selected_object.active_vector)
+                if vec_raster is not None:
+                    vec_raster.myname = self.selected_object.active_vector.myname + '_rasterized'
+                    self.selected_object.active_vector.parentzone.add_vector(vec_raster, forceparent=True, update_struct=True)
+                    self.selected_object.active_vector.parentzone.reset_listogl()
+
     def OnClose(self, event):
         """ Close the application """
 
@@ -14546,6 +14656,9 @@ class WolfMapViewer(wx.Frame):
             tracks.append(_('Load flight'))
             tracks.append(_('Save flight'))
 
+            tracks.append(_('Rasterize active zone'))
+            tracks.append(_('Rasterize active vector'))
+
             # Récupération des items du menu contextuel
             menuitems = self.popupmenu.GetMenuItems()
             text = [cur.GetItemLabelText() for cur in menuitems]
@@ -14583,6 +14696,10 @@ class WolfMapViewer(wx.Frame):
                 self.popupmenu.Append(wx.ID_ANY, _('Convert to multi-blocks (result)'), _('Convert to multi-blocks'))
                 self.popupmenu.Append(wx.ID_ANY, _('Extract current step as IC (result)'), _('Extract current step as IC'))
 
+            if isinstance(self.selected_object, Zones):
+                self.popupmenu.Append(wx.ID_ANY, _('Rasterize active zone'), _('Rasterize active zone'))
+                self.popupmenu.Append(wx.ID_ANY, _('Rasterize active vector'), _('Rasterize active vector'))
+
             if isinstance(self.selected_object, Zones | Bridge | Weir):
                 self.popupmenu.Append(wx.ID_ANY, _('Export to Shape file'), _('Export to Shape file'))
                 self.popupmenu.Append(wx.ID_ANY, _('Export active zone to Shape file'), _('Export active zone to Shape file'))

wolfhece/Results2DGPU.py

@@ -14,7 +14,7 @@ from os import path
 from pathlib import Path
 from scipy.sparse import csr_array
 from multiprocessing import Pool
-from typing import Union
+from typing import Union, Literal
 from tqdm import tqdm
 import logging
 
@@ -26,41 +26,38 @@ from .CpGrid import CpGrid
 from .PyPalette import wolfpalette
 
 try:
-    from wolfgpu.results_store import ResultsStore, ResultType
+    from wolfgpu.results_store import ResultsStore, ResultType, PerformancePolicy
 except ImportError:
     logging.debug(_("Unable to import wolfgpu.results_store.ResultsStore. Please install wolfgpu package or add a symlink to the wolfgpu package in the wolfhece directory"))
 
-def _load_res(x) -> tuple[csr_array, csr_array, csr_array]:
+def _load_res(x) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
     store:ResultsStore
     i:int
 
-    store, i = x
-    _, _, _, _, wd_np, qx_np, qy_np = store.get_result(i+1)
+    store, i, mode = x
 
-    if isinstance(wd_np, csr_array) and isinstance(qx_np, csr_array) and isinstance(qy_np, csr_array):
-        return wd_np, qx_np, qy_np
-    else:
-        return csr_array(wd_np), csr_array(qx_np), csr_array(qy_np)
+    _, _, _, _, wd_np, qx_np, qy_np = store.get_result(i+1, untile= mode == 'UNTILED')
+    return wd_np, qx_np, qy_np
 
-def _load_res_h(x) -> tuple[csr_array, csr_array, csr_array]:
+
+def _load_res_h(x) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
     store:ResultsStore
     i:int
 
-    store, i = x
-    wd_np = store.get_named_result('h',i+1)
+    store, i, mode = x
 
-    if isinstance(wd_np, csr_array):
-        return wd_np
-    else:
-        return csr_array(wd_np)
+    wd_np = store.get_named_result('h', i+1, untile= mode == 'UNTILED')
+    return wd_np
 
 class Cache_Results2DGPU():
     """
     Gestion en mémoire de plusieurs résultats GPU
-    Stockage CSR afin d'économiser la mémoire (Scipy CSR)
+    Stockage CSR afin d'économiser la mémoire (Scipy CSR) ou Numpy array dense
     """
 
-    def __init__(self, fname:str, start_idx:int, end_idx:int = -1, only_h=False) -> None:
+    def __init__(self, fname:str, start_idx:int, end_idx:int = -1,
+                 only_h=False, every:int= 1,
+                 mode:Literal['TILED', 'UNTILED'] = 'TILED', memory_max_size:int = 12 * 1024 * 1024 * 1024) -> None:
         """
         Chargement de résultats sur base du répertoire de sauvegarde de la simulation GPU
 
@@ -72,74 +69,198 @@ class Cache_Results2DGPU():
         :param start_idx: index de départ (0-based)
         :param end_idx: index de fin (0-based)
         :param only_h: lecture de la hauteur d'eau seulement
+        :param every: lecture de chaque ième résultat (1 = tous les résultats, 2 = un sur deux, etc.)
+        :param mode: 'TILED' pour les résultats en tuiles, 'UNTILED' pour les résultats non-tuilés
+        :param memory_max_size: taille mémoire maximale en octets pour le cache (par défaut 12 Go)
+
         """
 
-        self._results:Union[dict[str,tuple[csr_array, csr_array, csr_array]], dict[str,csr_array]] # typage
+        self._mode = mode
+        self._results:Union[dict[str,tuple[np.ndarray, np.ndarray, np.ndarray]], dict[str,np.ndarray]] # typage
 
         # ResultsStore unique
         self._result_store = ResultsStore(Path(fname), mode='r')
         self._only_h = only_h
+        self.memory_max_size = memory_max_size
+
+        mem_one_res = self._estimate_memory_size_one_result()
+        logging.info(_("Estimated memory size for one result: {:.2f} MB").format(mem_one_res))
+        self._maximum_n_results = int(self.memory_max_size // mem_one_res) if self.memory_max_size is not None else 10_000
 
         if end_idx == -1:
             end_idx = self._result_store.nb_results
 
         if end_idx>start_idx:
+
             self.start_idx = int(max(start_idx,0))
             self.end_idx   = int(min(end_idx, self._result_store.nb_results))
+            self._every = int(max(every, 1))
+
+            if (self.end_idx - self.start_idx) // self._every > self._maximum_n_results:
+                logging.warning(_("Too many results to cache in memory. "
+                                  "Only the first {} results will be cached.").format(self._maximum_n_results))
+                self.end_idx = int(min(int(self.start_idx + self._maximum_n_results * self._every), self._result_store.nb_results))
+
+            self._range_to_process = list(range(self.start_idx, self.end_idx, self._every))
+            if self.end_idx-1 not in self._range_to_process:
+                self._range_to_process.append(self.end_idx-1)
 
             # Lecture en multiprocess des résultats
             if only_h:
                 with Pool() as pool:
-                    _results = pool.map(_load_res_h, [(self._result_store,i) for i in range(self.start_idx, self.end_idx)])
+                    _results = pool.map(_load_res_h, [(self._result_store, i, mode) for i in self._range_to_process])
                     self._results = {i+1:res for i,res in enumerate(_results)}
             else:
                 with Pool() as pool:
-                    _results = pool.map(_load_res, [(self._result_store,i) for i in range(self.start_idx, self.end_idx)])
+                    _results = pool.map(_load_res, [(self._result_store, i, mode) for i in self._range_to_process])
                     self._results = {i+1:res for i,res in enumerate(_results)}
 
+    def _estimate_memory_size_one_result(self):
+        """ Read one result to estimate memory size """
+        res = self._result_store.get_result(1, untile=False)
+        if self._only_h:
+            return res[4].nbytes / 1024 / 1024
+        else:
+            return (res[4].nbytes + res[5].nbytes + res[6].nbytes) / 1024 / 1024
+
+    @property
+    def memory_size(self) -> int:
+        """
+        Estimation de la taille mémoire des résultats en cache
+
+        :return: taille mémoire en Mega-octets
+        """
+        if self._only_h:
+            return sum(res.nbytes for res in self._results.values()) / 1024 / 1024  # Convert to MB
+        else:
+            return sum(res[0].nbytes + res[1].nbytes + res[2].nbytes for res in self._results.values()) / 1024 / 1024  # Convert to MB
+
     @property
     def only_h(self):
         return self._only_h
 
-    def __getitem__(self,i:int):
+    @property
+    def _tile_packer(self):
+        """
+        Retourne le tile packer de la simulation
+        """
+        if self._result_store is not None:
+            return self._result_store.tile_packer()
+        else:
+            return None
+
+    def __getitem__(self, i:int):
         """Surcharge de l'opérateur []"""
         return self._results[i]
 
+    @property
+    def list_cached(self) -> list[int]:
+        """
+        Retourne la liste des indices des résultats en cache
+
+        :return: liste des indices (1-based)
+        """
+        return list(set(self._results.keys()))
+
+    def check_if_cached(self, idx:int) -> bool:
+        """
+        Vérifie si le résultat idx est dans le cache
+
+        :param idx: index du résultat (1-based)
+        :return: True si le résultat est dans le cache, False sinon
+        """
+
+        if idx not in self._results:
+            logging.info(_("Index {} not in cache").format(idx))
+            logging.info(_('We cache it now !'))
+
+            if self.only_h:
+                self._results[idx] = _load_res_h((self._result_store, idx-1, self._mode))
+            else:
+                self._results[idx] = _load_res((self._result_store, idx-1, self._mode))
+
+        return True
+
     def get_h(self, idx:int, dense:bool=True) -> Union[np.ndarray, csr_array]:
         """
         Retourne la matrice de hauteur d'eau de la position idx (0-based)
             - en CSR (Scipy CSR)
             - en dense (Numpy array)
+
+        :param idx: index du résultat (1-based)
+        :param dense: si True, retourne un Numpy array dense, sinon retourne un Scipy CSR array
         """
-        if not self.only_h:
-            return self._results[idx][0].toarray() if dense else self._results[idx][0]
+
+        self.check_if_cached(idx)
+
+        if self.only_h:
+            if self._tile_packer is None:
+                untiled = self._results[idx]
+            else:
+                untiled = self._tile_packer.unpack_array(self._results[idx])
+            if dense:
+                return untiled
+            else:
+                return csr_array(untiled)
         else:
-            return self._results[idx].toarray() if dense else self._results[idx]
+            if self._tile_packer is None:
+                untiled = self._results[idx][0]
+            else:
+                untiled = self._tile_packer.unpack_array(self._results[idx][0])
+            if dense:
+                return untiled
+            else:
+                return csr_array(untiled)
 
     def get_qx(self,idx:int, dense:bool=True) -> Union[np.ndarray, csr_array]:
         """
         Retourne la matrice de débit X d'eau de la position idx (0-based)
             - en CSR (Scipy CSR)
             - en dense (Numpy array)
+
+        :param idx: index du résultat (1-based)
+        :param dense: si True, retourne un Numpy array dense, sinon retourne un Scipy CSR array
         """
 
-        if not self.only_h:
-            return self._results[idx][1].toarray() if dense else self._results[idx][1]
-        else:
+        if self.only_h:
             return None
+        else:
+            self.check_if_cached(idx)
+
+            if self._tile_packer is None:
+                untiled = self._results[idx][1]
+            else:
+                untiled = self._tile_packer.unpack_array(self._results[idx][1])
+
+            if dense:
+                return untiled
+            else:
+                return csr_array(untiled)
 
     def get_qy(self,idx:int, dense:bool=True) -> Union[np.ndarray, csr_array]:
         """
         Retourne la matrice de débit Y d'eau de la position idx (0-based)
             - en CSR (Scipy CSR)
             - en dense (Numpy array)
+
+        :param idx: index du résultat (1-based)
+        :param dense: si True, retourne un Numpy array dense, sinon retourne un Scipy CSR array
         """
 
-        if not self.only_h:
-            return self._results[idx][2].toarray() if dense else self._results[idx][2]
-        else:
+        if self.only_h:
             return None
+        else:
+            self.check_if_cached(idx)
 
+            if self._tile_packer is None:
+                untiled = self._results[idx][2]
+            else:
+                untiled = self._tile_packer.unpack_array(self._results[idx][2])
+
+            if dense:
+                return untiled
+            else:
+                return csr_array(untiled)
 
 class wolfres2DGPU(Wolfresults_2D):
     """
@@ -427,7 +548,7 @@ class wolfres2DGPU(Wolfresults_2D):
 
         # stored result files are 1-based -> which+1
         if self._cache is not None:
-            if (which >= self._cache.start_idx and which < self._cache.end_idx) and (not self._cache.only_h):
+            if not self._cache.only_h:
                 wd_np = self._cache.get_h(which+1, True)
                 qx_np = self._cache.get_qx(which+1, True)
                 qy_np = self._cache.get_qy(which+1, True)
@@ -472,9 +593,9 @@ class wolfres2DGPU(Wolfresults_2D):
         curblock.qx.array.mask[ij] = False
         curblock.qy.array.mask[ij] = False
 
-        curblock.waterdepth.count()
-        curblock.qx.count()
-        curblock.qy.count()
+        curblock.waterdepth.nbnotnull = len(ij[0])
+        curblock.qx.nbnotnull = curblock.waterdepth.nbnotnull
+        curblock.qy.nbnotnull = curblock.waterdepth.nbnotnull
 
         # curblock.waterdepth.set_nullvalue_in_mask()
         # curblock.qx.set_nullvalue_in_mask()
@@ -497,10 +618,7 @@ class wolfres2DGPU(Wolfresults_2D):
 
         # stored result files are 1-based -> which+1
         if self._cache is not None:
-            if (which >= self._cache.start_idx and which < self._cache.end_idx):
-                wd_np = self._cache.get_h(which+1, True)
-            else:
-                _, _, _, _, wd_np, qx_np, qy_np = self._result_store.get_result(which+1)
+            wd_np = self._cache.get_h(which+1, True)
         else:
             __, __, __, __, wd_np, qx_np, qy_np = self._result_store.get_result(which+1)
 

wolfhece/apps/check_install.py

@@ -8,6 +8,99 @@ Copyright (c) 2024 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.
 """
+def test_conversion_LBT72_LBT08():
+
+    from pyproj.transformer import TransformerGroup
+
+    # Créer le groupe de transformateurs
+    tg = TransformerGroup(31370, 3812)
+
+    # Choisir le premier transformateur (ou un autre selon ton besoin)
+    transformer = tg.transformers[0]
+
+    print(transformer.description)
+    if '(3)' in transformer.description:
+        # This is the Belgian Lambert 72 + BD72 to ETRS89 (3) + Belgian Lambert 2008
+        return True
+    elif '(2)' in transformer.description:
+        # This is the Belgian Lambert 72 + BD72 to ETRS89 (2) + Belgian Lambert 2008
+        return False
+    elif '(1)' in transformer.description:
+        # This is the Belgian Lambert 72 + BD72 to ETRS89 (1) + Belgian Lambert 2008
+        return False
+    else:
+        # This is not the expected transformer
+        return False
+
+def test_conversion_LBT08_LBT72():
+
+    from pyproj.transformer import TransformerGroup
+
+    # Créer le groupe de transformateurs
+    tg = TransformerGroup(3812, 31370)
+
+    # Choisir le premier transformateur (ou un autre selon ton besoin)
+    transformer = tg.transformers[0]
+
+    print(transformer.description)
+    if '(3)' in transformer.description:
+        # This is the Belgian Lambert 72 + BD72 to ETRS89 (3) + Belgian Lambert 2008
+        return True
+    elif '(2)' in transformer.description:
+        # This is the Belgian Lambert 72 + BD72 to ETRS89 (2) + Belgian Lambert 2008
+        return False
+    elif '(1)' in transformer.description:
+        # This is the Belgian Lambert 72 + BD72 to ETRS89 (1) + Belgian Lambert 2008
+        return False
+    else:
+        # This is not the expected transformer
+        return False
+
+def test_transform_coordinates():
+    from pyproj.transformer import TransformerGroup
+    from pyproj import Transformer
+    import numpy as np
+    from wolfhece.Coordinates_operations import transform_coordinates
+    tg = TransformerGroup(31370, 3812)
+
+    ret = True
+
+    ret = ret and len(tg.transformers) > 0
+    ret = ret and len(tg.transformers) == 3
+    ret = ret and '(3)' in tg.transformers[0].description
+    ret = ret and '(2)' in tg.transformers[1].description
+    ret = ret and '(1)' in tg.transformers[2].description
+
+    tg_inv = TransformerGroup(3812, 31370)
+    ret = ret and len(tg_inv.transformers) > 0
+    ret = ret and len(tg_inv.transformers) == 3
+    ret = ret and '(3)' in tg_inv.transformers[0].description
+    ret = ret and '(2)' in tg_inv.transformers[1].description
+    ret = ret and '(1)' in tg_inv.transformers[2].description
+
+    tr = Transformer.from_crs(31370, 3812)
+
+    points = np.array([[100000, 200000], [110000, 210000], [120000, 220000]])
+
+    transformed_points_3 = tg.transformers[0].transform(points[:, 0], points[:, 1])
+    transformed_points_2 = tg.transformers[1].transform(points[:, 0], points[:, 1])
+    transformed_points_1 = tg.transformers[2].transform(points[:, 0], points[:, 1])
+    transformed_points = tr.transform(points[:, 0], points[:, 1])
+    transform_wolf = transform_coordinates(points, inputEPSG='EPSG:31370', outputEPSG='EPSG:3812')
+
+    # Convert to numpy arrays
+    transformed_points_3 = np.array(transformed_points_3).T
+    transformed_points_2 = np.array(transformed_points_2).T
+    transformed_points_1 = np.array(transformed_points_1).T
+    transformed_points = np.array(transformed_points).T
+
+    # Assert that the transformed points are equal
+    ret = ret and np.all(transformed_points_3 == transform_wolf)
+    ret = ret and np.all(transformed_points_3 == transformed_points)
+    ret = ret and not np.all(transformed_points_2 == transformed_points)
+    ret = ret and not np.all(transformed_points_1 == transformed_points)
+
+    return ret
 
 def main():
     # Check if installation is complete
@@ -32,17 +125,57 @@ def main():
         ret += 'Error during osgeo import - GDAL/OGR not/bad installed\n Please (re)install GDAL (64 bits version) from https://github.com/cgohlke/geospatial-wheels/releases\n\n'
         ret += 'Error : ' + str(e) + '\n\n'
 
+    if 'pyproj' in packages:
+        ret += 'PyProj seems installed\n\n'
+        try:
+            conv = test_conversion_LBT72_LBT08()
+
+            if conv:
+                ret += 'NTv2 conversion from Lambert 72 to Lambert 2008 seems available\n\n'
+            else:
+                ret += 'NTv2 conversion from Lambert 72 to Lambert 2008 seems NOT available\n\n'
+                ret += 'Please check if the PROJ data files are installed correctly - See OSGOE4W instructions\n\n'
+        except ImportError as e:
+            ret += 'PyProj not installed properly\n Please install PyProj from "pip install pyproj"\n\n'
+            ret += 'Error : ' + str(e) + '\n\n'
+
+        try:
+            conv = test_conversion_LBT08_LBT72()
+
+            if conv:
+                ret += 'NTv2 conversion from Lambert 2008 to Lambert 72 seems available\n\n'
+            else:
+                ret += 'NTv2 conversion from Lambert 2008 to Lambert 72 seems NOT available\n\n'
+                ret += 'Please check if the PROJ data files are installed correctly - See OSGOE4W instructions\n\n'
+        except ImportError as e:
+            ret += 'PyProj not installed properly\n Please install PyProj from "pip install pyproj"\n\n'
+            ret += 'Error : ' + str(e) + '\n\n'
+
+        try:
+            conv = test_transform_coordinates()
+            if conv:
+                ret += 'Transform coordinates function seems working fine\n\n'
+            else:
+                ret += 'Transform coordinates function seems NOT available\n\n'
+                ret += 'Please check if the PROJ data files are installed correctly - See OSGOE4W instructions\n\n'
+        except ImportError as e:
+            ret += 'PyProj not installed properly\n Please install PyProj from "pip install pyproj"\n\n'
+            ret += 'Error : ' + str(e) + '\n\n'
+
+    else:
+        ret += 'PyProj not installed\n Please install PyProj from "pip install pyproj"\n\n'
+
     if 'wolfgpu' in packages:
         ret += 'WolfGPU seems installed\n\n'
     else:
         ret += 'WolfGPU not installed\n Please install WolfGPU if needed\n\n'
 
-    try:
-        from wolf_libs import wolfpy
-        ret += 'Wolfpy accessible\n\n'
-    except ImportError as e:
-        ret += 'Wolfpy not accessible\n\n'
-        ret += 'Error : ' + str(e) + '\n\n'
+    # try:
+    #     from wolf_libs import wolfpy
+    #     ret += 'Wolfpy accessible\n\n'
+    # except ImportError as e:
+    #     ret += 'Wolfpy not accessible\n\n'
+    #     ret += 'Error : ' + str(e) + '\n\n'
 
     try:
         from ..PyGui import MapManager

wolfhece/apps/version.py

@@ -5,7 +5,7 @@ class WolfVersion():
 
         self.major = 2
         self.minor = 2
-        self.patch = 23
+        self.patch = 24
 
     def __str__(self):
 

wolfhece/irm_qdf.py

@@ -746,4 +746,70 @@ class QDF_Belgium():
                     return None
             else:
                 logging.error(f"Name {key} not found in the data")
-                return None
+                return None
+
+
+class Climate_IRM():
+
+    def __init__(self, store_path= 'irm', ins:Literal['2018', '2019', '2025', 2018, 2019, 2025] = 2018) -> None:
+        self.store_path = Path(store_path)
+        self.localities = Localities(ins)
+
+        self._climate_data = {}
+
+    def __getitem__(self, key):
+        return self._climate_data[key]
+
+    @classmethod
+    def importfromwebsite(cls, store_path= 'irm', verbose:bool= False, waitingtime:float= .01, ins:Literal['2018', '2019', '2025', 2018, 2019, 2025] = 2018, ins_code: int = None):
+        """ Import Excel files for one or all municipalities from the IRM website
+
+        :param store_path: Where to store the downloaded data. Directory will be created if it doesn't exists.
+        :param verbose: If `True`, will print some progress information.
+                        If `False`, will do nothing.
+                        If a callable, then will call it with a float in [0, 1].
+                        0 means nothing downloaded, 1 means everything downloaded.
+
+        :param waitingtime: How long to wait (in seconds) betwenn the download
+                            of each station (will make sure we don't overwhelm IRM's website).
+
+        :param ins: The year of the INS codes to use.
+        :param code: Restricts the data download to a specific NIS code. `None` means full download.
+        """
+        import requests
+
+        myloc = Localities(ins)
+
+        if ins_code is not None:
+            codes_to_load = [ins_code]
+        else:
+            if not path.exists(store_path):
+                mkdir(store_path)
+            codes_to_load = myloc.inscode2name
+
+        for key,myins in enumerate(codes_to_load):
+            #chaîne URL du fichier Excel
+            url="https://www.meteo.be//resources//climatology//climateCity//pdf//climate_INS"+str(myins)+"_9120_fr.pdf"
+            #Obtention du fichiers depuis le site web de l'IRM
+            response=requests.get(url)
+
+            if str(response.content).find("Page not found")==-1 :
+
+                # Make sure we create the store path only if we have
+                # something to put inside.
+                if ins_code is not None and not path.exists(store_path):
+                    mkdir(store_path)
+
+                file=open(path.join(store_path,str(myins)+".pdf"), 'wb')
+                file.write(response.content)
+                file.close()
+                if verbose:
+                    if callable(verbose):
+                        verbose(key/len(codes_to_load))
+                    else:
+                        print(myins)
+            else:
+                #logging.error(response.content)
+                logging.error(f"Failed to load IRM data: {url} --> {response}")
+
+            sleep(waitingtime)

wolfhece/mesh2d/wolf2dprev.py

@@ -11484,7 +11484,8 @@ class prev_sim2D():
         if len(lst) == 0:
             logging.warning('No potential BC found -- Test can not be performed -- I continue anyway')
         else:
-            if i not in lst[0] or j not in lst[1]:
+            candidate_cells = list(zip(lst[0], lst[1]))
+            if (i, j) not in candidate_cells:
                 logging.error(f'Invalid indices ({i},{j}) - BC not added')
                 return
 
@@ -11506,7 +11507,8 @@ class prev_sim2D():
         if len(lst) == 0:
             logging.warning('No potential BC found -- Test can not be performed -- I continue anyway')
         else:
-            if i not in lst[0] or j not in lst[1]:
+            candidate_cells = list(zip(lst[0], lst[1]))
+            if (i, j) not in candidate_cells:
                 logging.error(f'Invalid indices ({i},{j}) - BC not added')
                 return
 

wolfhece/wolf_array.py

@@ -1384,6 +1384,34 @@ class header_wolf():
 
             return newvector
 
+    def rasterize_zone_along_grid(self, zone2raster:zone, outformat:Union[np.ndarray, vector]=zone) -> Union[np.ndarray,zone]:
+        """ Rasterize a zone according to the grid
+
+        :param zone2raster: zone to rasterize
+        :param outformat: output format (np.ndarray or zone)
+        """
+
+        assert outformat in [np.ndarray, zone], _('outformat must be np.ndarray or zone')
+
+        if outformat is zone:
+            out_vec = vector
+        else:
+            out_vec = np.ndarray
+        new_vecs = []
+        for vec in zone2raster.myvectors:
+            new_vecs.append(self.rasterize_vector_along_grid(vec, outformat=out_vec))
+
+        if outformat is np.ndarray:
+            return np.vstack(new_vecs)
+        elif outformat is zone:
+            # create new zone
+            newzone = zone()
+            for vec, oldvec in zip(new_vecs, zone2raster.myvectors):
+                vec.myname = oldvec.myname  # keep the original name
+                newzone.add_vector(vec, forceparent=True)
+            return newzone
+
+
     def rasterize_vector(self, vector2raster:vector, outformat:Union[np.ndarray, vector]=vector) -> Union[np.ndarray,vector]:
         """ DEPRECATED since 2.2.8 -- use rasterize_vector_along_grid instead.
 

wolfhece/wolfresults_2D.py

@@ -4155,6 +4155,10 @@ class Wolfresults_2D(Element_To_Draw):
         :param to_rasterize : pour rasteriser le vecteur selon la grille de calcul
         """
 
+        if self.nb_blocks > 1:
+            logging.error(_('This method is not implemented for multi-block results - Need to be implemented !'))
+            return []
+
         myhead = self.get_header_block(1)
         if to_rasterize:
             myvect = myhead.rasterize_vector_along_grid(myvect)
@@ -6129,4 +6133,123 @@ class Wolfresults_2D(Element_To_Draw):
             qx_avg.array.mask[:,:] = h_avg.array.mask[:,:]
             qy_avg.array.mask[:,:] = h_avg.array.mask[:,:]
 
-        return h_avg, qx_avg, qy_avg
+        return h_avg, qx_avg, qy_avg
+
+    def danger_map_velocity_with_directions(self, start:int=0, end:int=-1, every:int=1, callback=None) -> Union[tuple[WolfArray, WolfArray, WolfArray, WolfArray], tuple[WolfArrayMB, WolfArrayMB, WolfArrayMB, WolfArrayMB]]:
+        """
+        Create Danger Map of velocity magnitudes and also retain their directions
+
+        :param start: start time step - 0-based
+        :param end: end time step - 0-based
+        :param every: step interval
+        :param callback: optional callback to update progress
+
+        :return : tuple of WolfArray or WolfArrayMB - H, U_norm, U_x, U_y
+        """
+
+        # Number of  time steps
+        number_of_time_steps = self.get_nbresults()
+        if end ==-1:
+            end = number_of_time_steps
+
+        # Init Danger Maps basde on results type
+        #    If only one block --> WolfArray
+        #    If only multiple blocks --> WolfArrayMB
+        danger_map_matrix_h   = self.as_WolfArray(copyarray=True)
+        danger_map_matrix_v   = self.as_WolfArray(copyarray=True)
+        danger_map_matrix_vx  = self.as_WolfArray(copyarray=True)
+        danger_map_matrix_vy  = self.as_WolfArray(copyarray=True)
+
+        danger_init = [danger_map_matrix_h, danger_map_matrix_v, danger_map_matrix_vx, danger_map_matrix_vy]
+
+        for curdanger in danger_init:
+            curdanger.nullvalue = 0.
+            curdanger.reset()
+            curdanger.mask_reset()
+
+        to_compute = np.arange(start, end, every)
+        #add the end
+        if end not in to_compute:
+            to_compute = np.append(to_compute, end)
+        for time_step in tqdm(to_compute):
+
+            if callback is not None:
+                callback(time_step, "Step {} / {}".format(time_step+1, end))
+
+            self.read_oneresult(time_step+1)
+
+            if self.nb_blocks>1:
+                for curblock in self.myblocks.keys():
+
+                    # Get WolfArray
+                    wd = self.get_h_for_block(curblock)
+                    qx = self.get_qx_for_block(curblock)
+                    qy = self.get_qy_for_block(curblock)
+
+                    ij = np.where(~wd.array.mask)
+
+                    v   = np.zeros_like(wd.array)
+                    vy  = np.zeros_like(wd.array)
+                    vx  = np.zeros_like(wd.array)
+
+                    v[ij]   = ((qx.array[ij]**2.+qy.array[ij]**2.)**.5)/wd.array[ij]
+                    vy[ij]   = qy.array[ij]/wd.array[ij]
+                    vx[ij]   = qx.array[ij]/wd.array[ij]
+
+                    # Comparison
+                    ij = np.where((danger_map_matrix_h.array < wd.array.data) & (~wd.array.mask))
+                    danger_map_matrix_h.array.data[ij] = wd.array[ij]
+                    danger_map_matrix_h.array.mask[ij] = False
+
+                    # Comparison
+                    ij = np.where((danger_map_matrix_v.array < v) & (~wd.array.mask))
+                    danger_map_matrix_v.array.data[ij] = v[ij]
+                    danger_map_matrix_vx.array.data[ij] = vx[ij]
+                    danger_map_matrix_vy.array.data[ij] = vy[ij]
+                    danger_map_matrix_v.array.mask[ij] = False
+                    danger_map_matrix_vx.array.mask[ij] = False
+                    danger_map_matrix_vy.array.mask[ij] = False
+
+            else:
+                curblock = getkeyblock(0)
+                wd = self.get_h_for_block(curblock)
+                qx = self.get_qx_for_block(curblock)
+                qy = self.get_qy_for_block(curblock)
+
+                ij = np.where(~wd.array.mask)
+
+                v   = np.zeros_like(wd.array)
+                vy  = np.zeros_like(wd.array)
+                vx  = np.zeros_like(wd.array)
+
+                v[ij] = ((qx.array[ij]**2.+qy.array[ij]**2.)**.5)/wd.array[ij]
+                vy[ij] = qy.array[ij]/wd.array[ij]
+                vx[ij] = qx.array[ij]/wd.array[ij]
+
+                # Comparison
+                ij = np.where((danger_map_matrix_h.array < wd.array.data) & (~wd.array.mask))
+                danger_map_matrix_h.array.data[ij] = wd.array[ij]
+                danger_map_matrix_h.array.mask[ij] = False
+
+                # Comparison
+                ij = np.where((danger_map_matrix_v.array < v) & (~wd.array.mask))
+                danger_map_matrix_v.array.data[ij] = v[ij]
+                danger_map_matrix_vx.array.data[ij] = vx[ij]
+                danger_map_matrix_vy.array.data[ij] = vy[ij]
+                danger_map_matrix_v.array.mask[ij] = False
+                danger_map_matrix_vx.array.mask[ij] = False
+                danger_map_matrix_vy.array.mask[ij] = False
+
+        danger_map_matrix_h.mask_lower(self.epsilon)
+
+        if self.nb_blocks>1:
+            for i in range(self.nb_blocks):
+                danger_map_matrix_v[i].array.mask[:,:]   = danger_map_matrix_h[i].array.mask[:,:]
+                danger_map_matrix_vx[i].array.mask[:,:] = danger_map_matrix_h[i].array.mask[:,:]
+                danger_map_matrix_vy[i].array.mask[:,:] = danger_map_matrix_h[i].array.mask[:,:]
+        else:
+            danger_map_matrix_v.array.mask[:,:]   = danger_map_matrix_h.array.mask[:,:]
+            danger_map_matrix_vx.array.mask[:,:] = danger_map_matrix_h.array.mask[:,:]
+            danger_map_matrix_vy.array.mask[:,:] = danger_map_matrix_h.array.mask[:,:]
+
+        return (danger_map_matrix_h, danger_map_matrix_v, danger_map_matrix_vx, danger_map_matrix_vy)

{wolfhece-2.2.23.dist-info → wolfhece-2.2.24.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wolfhece
-Version: 2.2.23
+Version: 2.2.24
 Author-email: Pierre Archambeau <pierre.archambeau@uliege.be>
 Project-URL: Homepage, https://uee.uliege.be/hece
 Project-URL: Issues, https://uee.uliege.be/hece

{wolfhece-2.2.23.dist-info → wolfhece-2.2.24.dist-info}/RECORD

@@ -1,4 +1,4 @@
-wolfhece/Coordinates_operations.py,sha256=YyWlAwKManb-ReQrmP37rEXxehunUCihmkeDYX6qTAQ,8037
+wolfhece/Coordinates_operations.py,sha256=KaIcP1b0IpKSLaynZgfvwkD6wsMKLmZo-kxeLfv9-8c,8101
 wolfhece/CpGrid.py,sha256=_piG1u-ua7NzWh_PHJYTmxuPJ43ZfeYKNEQgZIJwDJ8,10660
 wolfhece/GraphNotebook.py,sha256=2TR8qjEwpMtl34QWgYNVe_PgTnuwhUxT5f9Y2zrmN2U,28257
 wolfhece/GraphProfile.py,sha256=OCgJo0YFFBI6H1z-5egJsOOoWF_iziiza0-bbPejNMc,69656
@@ -8,7 +8,7 @@ wolfhece/Model1D.py,sha256=snEmu8Uj2YGcp1ybPnly-4A389XRnuOujGduqInNcgw,477001
 wolfhece/PandasGrid.py,sha256=YIleVkUkoP2MjtQBZ9Xgwk61zbgMj4Pmjj-clVTfPRs,2353
 wolfhece/PyConfig.py,sha256=Y0wtSIFpAMYa7IByh7hbW-WEOVjNsQEduq7vhIYdZQw,16716
 wolfhece/PyCrosssections.py,sha256=igU_ELrg5VrHU6RNbF5tHxPyVImpR3xdpfopJYc7haw,114711
-wolfhece/PyDraw.py,sha256=Okx2Uv4zOeCxtYYAGx6T7SGZh4taamdCMvZ6QqruLxE,655901
+wolfhece/PyDraw.py,sha256=3ZKNrXhdHYNjuFKV47l7vHFMcqWElQUxDuM8XX1R5zk,662179
 wolfhece/PyGui.py,sha256=DqMTDsC9GthnMdYOXvkMKfl5pNciExVzxG4ogptWf6g,146010
 wolfhece/PyGuiHydrology.py,sha256=sKafpOopBg50L5llZCI_fZtbebVTDtxvoRI6-osUwhg,14745
 wolfhece/PyHydrographs.py,sha256=1P5XAURNqCvtSsMQXhOn1ihjTpr725sRsZdlCEhhk6M,3730
@@ -23,7 +23,7 @@ wolfhece/RatingCurve.py,sha256=bUjIrQjvIjkD4V-z8bZmA6pe1ILtYNM0-3fT6YUY1RU,22498
 wolfhece/RatingCurveData.py,sha256=5UvnIm89BwqjnEbLCcY3CA8WoFd_xHJbooNy62fX5iY,57660
 wolfhece/RatingCurve_xml.py,sha256=cUjReVMHFKtakA2wVey5zz6lCgHlSr72y7ZfswZDvTM,33891
 wolfhece/ReadDataDCENN.py,sha256=vm-I4YMryvRldjXTvRYEUCxZsjb_tM7U9yj6OaPyD0k,1538
-wolfhece/Results2DGPU.py,sha256=kVEbP61PfcsMwyJT1pvXgUxpPfVVxlP_8saXWzsYAbg,27021
+wolfhece/Results2DGPU.py,sha256=GTu7PMuwfH-xH8J7sVr6zq2CTkGKF24fG1ujEW62PtM,31598
 wolfhece/__init__.py,sha256=Gd96hBcXEFUUssyRgJAGC1vCmNR30S66m_80KjcXzGA,946
 wolfhece/_add_path.py,sha256=mAyu85CQHk0KgUI6ZizweeQiw1Gdyea9OEjGLC6lLA4,916
 wolfhece/analyze_poly.py,sha256=jsCUsd0ZJtTwSk5hekcXj8i0tGhH-WCfNkrBtPRJpCc,12715
@@ -39,7 +39,7 @@ wolfhece/gpuview.py,sha256=Jql8pLZ0PpvZ_ScT-U4jsXANZ9j4-m_RWhsLA2HISuQ,24544
 wolfhece/images_tiles.py,sha256=w5BX6kRqA0wW9TWyKrJUIRl-XyqHclq_kp5ET2VA0Sg,3227
 wolfhece/import_ascfiles.py,sha256=6Zl8qBR9c6VtyziookQ8YE9KC0GtW_J9WFt5ubyGp-s,4465
 wolfhece/ins.py,sha256=uUeLMS1n3GPnfJhxl0Z2l-UXpmPUgthuwct282OOEzk,36184
-wolfhece/irm_qdf.py,sha256=DMdDEAYbgYxApObm6w-dZbBmA8ec6PghBLXR2lUEZLc,27457
+wolfhece/irm_qdf.py,sha256=MjDn6dCaJ6JgeH0RkMiHqWXLPeTZ_Fd7nH_7q5jvbQg,30269
 wolfhece/ismember.py,sha256=fkLvaH9fhx-p0QrlEzqa6ySO-ios3ysjAgXVXzLgSpY,2482
 wolfhece/lagrange_multiplier.py,sha256=0G-M7b2tGzLx9v0oNYYq4_tLAiHcs_39B4o4W3TUVWM,6567
 wolfhece/lifewatch.py,sha256=Q_Wy6VGkrD-xxY0fv3PKpT8U8oXxNMgiLlrAE3bMheo,16340
@@ -60,13 +60,13 @@ wolfhece/rain_SPWMI.py,sha256=qCfcmF7LajloOaCwnTrrSMzyME03YyilmRUOqrPrv3U,13846
 wolfhece/textpillow.py,sha256=map7HsGYML_o5NHRdFg2s_TVQed_lDnpYNDv27MM0Vw,14130
 wolfhece/tools2d_dll.py,sha256=TfvvmyZUqEZIH0uHwUCJf0bdmCks_AiidDt23Unsp5w,13550
 wolfhece/tools_mpl.py,sha256=gQ3Jg1iuZiecmMqa5Eli2ZLSkttu68VXL8YmMDBaEYU,564
-wolfhece/wolf_array.py,sha256=avAoanXV6vcbOH4j2RjZuRmjarvbLE6MlXtKqHCWirs,517578
+wolfhece/wolf_array.py,sha256=5TyRd6XEWDJHvXfPPgsFKbBFmZbQ-68wS57mHqymqrk,518644
 wolfhece/wolf_hist.py,sha256=fTEb60Q4TEwobdZsRU4CFXAId1eOKdWAqF8lnF1xEWc,3590
 wolfhece/wolf_texture.py,sha256=8BcVSezLEogTHYmtA4yfSPzaw6UpAeYYySVaAowIKtQ,20858
 wolfhece/wolf_tiles.py,sha256=v-HohqaWuMYdn75XLnA22dlloAG90iwnIqrgnB0ASQ4,10488
 wolfhece/wolf_vrt.py,sha256=wbxXVN7TL9zgdyF79S-4e3pje6wJEAgBEfF_Y8kkzxs,14271
 wolfhece/wolf_zi_db.py,sha256=baE0niMCzybWGSvPJc5FNxo9ZxsGfU4p-FmfiavFHAs,12967
-wolfhece/wolfresults_2D.py,sha256=iRTrukQntMfy2XUc2v4deNNJTZdboqEb_QvSjsu6bjM,240103
+wolfhece/wolfresults_2D.py,sha256=0c3akPDFETE0Uq0JiZ0FZEx6Rxiy9JB5s9P6sDei0E0,245735
 wolfhece/xyz_file.py,sha256=1pzLFmmdHca4yBVR9Jitic6N82rY28mRytGC1zMbY28,6615
 wolfhece/acceptability/Parallels.py,sha256=2wVkfJYor4yl7VYiAZiGGTFwtAab2z66ZfRtBliVweE,4088
 wolfhece/acceptability/__init__.py,sha256=hfgoPKLDpX7drN1Vpvux-_5Lfyc_7feT2C2zQr5v-Os,258
@@ -82,13 +82,13 @@ wolfhece/apps/WolfPython2.png,sha256=VMPV-M-3BCOg8zOJss8bXwPmzRYZy8Fo-XtnVYNgbaw
 wolfhece/apps/WolfPython3.png,sha256=3G84zx14HnlB9YXMY4VUAO7IB3eu7JFvi4Kpmc_4zBE,403298
 wolfhece/apps/__init__.py,sha256=OzzKItATWV0mDkz_LC2L3w5sgT2rt8ExXXCbR_FwvlY,24
 wolfhece/apps/acceptability.py,sha256=hMIxTRNQARTTWJJaakb6kEK9udNh-w64VDgxxezVk3k,790
-wolfhece/apps/check_install.py,sha256=-lDn9mVS9Pq9b2jWT0uo-hqM6_IXwr0UrW0rWIEMJ9E,3992
+wolfhece/apps/check_install.py,sha256=DmyFC5Thz29UFQlokD7dbhlWPDeWstiukcBPuXofnsk,9753
 wolfhece/apps/check_version.py,sha256=Zze7ltzcM2ZzIGMwkcASIjapCG8CEzzW9kwNscA3NhM,1768
 wolfhece/apps/curvedigitizer.py,sha256=lEJJwgAfulrrWQc-U6ij6sj59hWN3SZl4Yu1kQxVzzA,9106
 wolfhece/apps/hydrometry.py,sha256=lhhJsFeb4zGL4bNQTs0co85OQ_6ssL1Oy0OUJCzhfYE,656
 wolfhece/apps/isocurrent.py,sha256=dagmGR8ja9QQ1gwz_8fU-N052hIw-W0mWGVkzLu6C7I,4247
 wolfhece/apps/splashscreen.py,sha256=EdGDN9NhudIiP7c3gVqj7dp4MWFB8ySizM_tpMnsgpE,3091
-wolfhece/apps/version.py,sha256=geYky3SvOR_9WIk1PDzpLRmFH1-xzccADG2iDWg8JCc,388
+wolfhece/apps/version.py,sha256=3qfyNsaI-v1qzANbydpCOlZTJHZhiWyeJf0VzXFEr_Y,388
 wolfhece/apps/wolf.py,sha256=mRnjYsUu4KIsRuamdQWAINFMuwN4eJgMo9erG-hkZ70,729
 wolfhece/apps/wolf2D.py,sha256=4z_OPQ3IgaLtjexjMKX9ppvqEYyjFLt1hcfFABy3-jU,703
 wolfhece/apps/wolf_logo.bmp,sha256=ruJ4MA51CpGO_AYUp_dB4SWKHelvhOvd7Q8NrVOjDJk,3126
@@ -227,7 +227,7 @@ wolfhece/mesh2d/config_manager.py,sha256=DcdxCIIs_dyC6ayJOBULeY364LONogL9PBaqBtC
 wolfhece/mesh2d/cst_2D_boundary_conditions.py,sha256=r43pHHdCtmNp5R2zh1Ckb7EzwQDf6C4YMLwRFTl4KMc,5006
 wolfhece/mesh2d/gpu_2d.py,sha256=GGOAW3c3c2CKtDyxSJJdX_1A1QfMFC5CU4MjzhAbR5o,25551
 wolfhece/mesh2d/simple_2d.py,sha256=wqENJwpUPxKQcpGIcymQXUj2KgkGWCVH6cs4Os9h9Gs,112581
-wolfhece/mesh2d/wolf2dprev.py,sha256=N50tmed97OgNATEp9DPEXQlcbqy3fjWkvAvyhmTsWmI,493023
+wolfhece/mesh2d/wolf2dprev.py,sha256=oK9r94CYJaeOBSv4s4mkuhLA8rCsnrkjG2sGW_zR1x0,493127
 wolfhece/models/5_coul.pal,sha256=OI1UqcNIDBpJn2k_VDel__r-hKjjvdob0eqinGCI3QY,160
 wolfhece/models/6_coul.pal,sha256=z7NK2dg0tAQBUweRQV54dIwJbPM1U5y1AR2LLw19Idw,148
 wolfhece/models/7_coul.pal,sha256=XTnnUyCE8ONokScB2YzYDnSTft7E6sppmr7P-XwMsCE,205
@@ -300,8 +300,8 @@ wolfhece/ui/wolf_multiselection_collapsiblepane.py,sha256=8PlMYrb_8jI8h9F0_EagpM
 wolfhece/ui/wolf_times_selection_comparison_models.py,sha256=ORy7fz4dcp691qKzaOZHrRLZ0uXNhL-LIHxmpDGL6BI,5007
 wolfhece/wintab/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wolfhece/wintab/wintab.py,sha256=8A-JNONV6ujgsgG3lM5Uw-pVgglPATwKs86oBzzljoc,7179
-wolfhece-2.2.23.dist-info/METADATA,sha256=Rol51FGEuEGXU8Pxmu4d5jXHO5uH1jOg_WrBNa3jNzU,2729
-wolfhece-2.2.23.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-wolfhece-2.2.23.dist-info/entry_points.txt,sha256=Jr187pyvA3EeJiQLjZK9yo6mJX7IAn6ygZU9T8qF_gQ,658
-wolfhece-2.2.23.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
-wolfhece-2.2.23.dist-info/RECORD,,
+wolfhece-2.2.24.dist-info/METADATA,sha256=JLouSaSwr1t-Z7Z5N97nSIHCJjjhAyKHUlToNAHGAAA,2729
+wolfhece-2.2.24.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+wolfhece-2.2.24.dist-info/entry_points.txt,sha256=Jr187pyvA3EeJiQLjZK9yo6mJX7IAn6ygZU9T8qF_gQ,658
+wolfhece-2.2.24.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
+wolfhece-2.2.24.dist-info/RECORD,,