wolfhece 2.2.20__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

@@ -2287,6 +2287,7 @@ class WolfMapViewer(wx.Frame):
         self.analyzeplot = wx.Menu()
         self.analyzeexport = wx.Menu()
         self.analyzeinpaint = wx.Menu()
+        self.analyzesimsheet = wx.Menu()
 
         plotvect = self.analyzeplot.Append(wx.ID_ANY, _("Plot active vector..."),
                                            _("Plot the active vector and linked arrays"))
@@ -2299,6 +2300,17 @@ class WolfMapViewer(wx.Frame):
         self.analyzemenu.Append(wx.ID_ANY,_('Export...'), self.analyzeexport)
         self.analyzemenu.Append(wx.ID_ANY,_('Inpaint...'), self.analyzeinpaint)
 
+        self.analyzemenu.AppendSeparator()
+
+        self.analyzemenu.Append(wx.ID_ANY,_('Report...'), self.analyzesimsheet)
+
+        self.analyzesimsheet.Append(wx.ID_ANY, _("Active simulation..."), _("Generate a summary PDF report for the active simulation"))
+        self.analyzesimsheet.Append(wx.ID_ANY, _("All checked simulations..."), _("Generate a summary PDF report for all checked simulations"))
+        self.analyzesimsheet.Append(wx.ID_ANY, _("All simulations in directory..."), _("Generate a summary PDF report for all simulations in the current directory"))
+        self.analyzesimsheet.AppendSeparator()
+        self.analyzesimsheet.Append(wx.ID_ANY, _("Compare checked simulations..."), _("Generate a summary PDF report for all the loaded simulations"))
+        self.analyzesimsheet.Append(wx.ID_ANY, _("Compare all simulations in a directory..."), _("Generate a summary PDF report for all the simulations in a directory"))
+
 
         self.analyzeinpaint.Append(wx.ID_ANY, _("Inpaint active array..."), _("Inpaint active array"))
         self.analyzeinpaint.Append(wx.ID_ANY, _("Inpaint waterlevel..."), _("Inpaint a waterlevel result array based on sepcified dem and dtm data"))
@@ -4902,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
 
@@ -4958,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,
@@ -8301,6 +8316,121 @@ class WolfMapViewer(wx.Frame):
         elif itemlabel == _("Load and apply mask (nap)..."):
             self.loadnap_and_apply()
 
+        elif itemlabel == _("Active simulation..."):
+            if self.active_res2d is None:
+                logging.warning(_('No active simulation !'))
+                return
+
+            from .report.simplesimgpu import SimpleSimGPU_Report_wx
+
+            if isinstance(self.active_res2d, wolfres2DGPU):
+                newsheet = SimpleSimGPU_Report_wx(Path(self.active_res2d.filename).parent, size=(800, 600))
+                newsheet.Show()
+            else:
+                logging.warning(_('Active simulation is not a GPU simulation - Not yet implemented for CPU simulations !'))
+
+        elif itemlabel == _("All checked simulations..."):
+
+            sims = self.get_list_keys(draw_type.RES2D, checked_state=True)
+            if len(sims) == 0:
+                logging.warning(_('No checked simulation !'))
+                return
+
+            from .report.simplesimgpu import SimpleSimGPU_Report_wx
+
+            for curkey in sims:
+                curmodel = self.get_obj_from_id(curkey, draw_type.RES2D)
+                if isinstance(curmodel, wolfres2DGPU):
+                    newsheet = SimpleSimGPU_Report_wx(Path(curmodel.filename).parent, size=(800, 600))
+                    newsheet.Show()
+                else:
+                    logging.warning(_('Simulation {} is not a GPU simulation - Not yet implemented for CPU simulations !').format(curmodel.idx))
+
+        elif itemlabel == _("All simulations in directory..."):
+            dlg = wx.DirDialog(None, _('Choose the directory containing the simulations'), style=wx.DD_DEFAULT_STYLE)
+            ret = dlg.ShowModal()
+            if ret == wx.ID_CANCEL:
+                dlg.Destroy()
+                return
+            directory = Path(dlg.GetPath())
+            dlg.Destroy()
+            if not directory.exists():
+                logging.error(_('Directory {} does not exist !').format(directory))
+                wx.MessageBox(_('Directory {} does not exist !').format(directory), _('Error'), wx.OK | wx.ICON_ERROR)
+                return
+            if not directory.is_dir():
+                logging.error(_('Path {} is not a directory !').format(directory))
+                wx.MessageBox(_('Path {} is not a directory !').format(directory), _('Error'), wx.OK | wx.ICON_ERROR)
+                return
+            from .report.simplesimgpu import SimpleSimGPU_Reports_wx
+
+
+            # check if we want to show all wx reports
+            dlg = wx.MessageDialog(None, _('Do you want to show all reports ?'), _('Show all reports'), style=wx.YES_NO | wx.YES_DEFAULT)
+            ret = dlg.ShowModal()
+            dlg.Destroy()
+
+            newsheets = SimpleSimGPU_Reports_wx(directory, show = ret == wx.ID_YES, size=(800, 600))
+
+        elif itemlabel == _("Compare checked simulations..."):
+
+            sims = self.get_list_keys(draw_type.RES2D, checked_state=True)
+            if len(sims) == 0:
+                logging.warning(_('No checked simulation !'))
+                return
+
+            elif len(sims) == 1:
+                logging.warning(_('Only one checked simulation - Nothing to compare !'))
+                return
+
+            from .report.simplesimgpu import SimpleSimGPU_Report_Compare_wx
+
+            sims = [self.get_obj_from_id(curkey, draw_type.RES2D) for curkey in sims]
+            # conserve only GPU simulations
+            sims = [Path(curmodel.filename) for curmodel in sims if isinstance(curmodel, wolfres2DGPU)]
+
+            # take parent if "simul_gpu_results" in sims
+            sims = [sim.parent for sim in sims if 'simul_gpu_results' in str(sim)]
+
+            if len(sims) == 0:
+                logging.warning(_('No GPU simulation to compare !'))
+                return
+            elif len(sims) == 1:
+                logging.warning(_('Only one GPU simulation - Nothing to compare !'))
+                return
+            elif len(sims) > 1:
+                try:
+                    newsheet = SimpleSimGPU_Report_Compare_wx(sims, size=(800, 600))
+                    newsheet.Show()
+                except Exception as e:
+                    logging.error(_('Error in comparing simulations\n{}'.format(e)))
+
+        elif itemlabel == _("Compare all simulations in a directory..."):
+
+            dlg = wx.DirDialog(None, _('Choose the directory containing the simulations'), style=wx.DD_DEFAULT_STYLE)
+            ret = dlg.ShowModal()
+            if ret == wx.ID_CANCEL:
+                dlg.Destroy()
+                return
+
+            directory = Path(dlg.GetPath())
+            dlg.Destroy()
+
+            if not directory.exists():
+                logging.error(_('Directory {} does not exist !').format(directory))
+                wx.MessageBox(_('Directory {} does not exist !').format(directory), _('Error'), wx.OK | wx.ICON_ERROR)
+                return
+            if not directory.is_dir():
+                logging.error(_('Path {} is not a directory !').format(directory))
+                wx.MessageBox(_('Path {} is not a directory !').format(directory), _('Error'), wx.OK | wx.ICON_ERROR)
+                return
+            from .report.simplesimgpu import SimpleSimGPU_Report_Compare_wx
+            try:
+                newsheet = SimpleSimGPU_Report_Compare_wx(directory, size= (800,600))
+                newsheet.Show()
+            except Exception as e:
+                logging.error(_('Error in comparing simulations in directory\n{}'.format(e)))
+
         elif itemlabel == _("Inpaint active array..."):
 
             if self.active_array is None:
@@ -9792,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 = []
@@ -9811,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
@@ -11630,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 """
 
@@ -14419,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]
@@ -14456,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/__init__.py

@@ -1,4 +1,5 @@
 from . import _add_path
+from .libs import *
 from .PyTranslate import _
 
 try: