wolfhece 2.0.55__py3-none-any.whl → 2.1.1__py3-none-any.whl

wolfhece/wolf_vrt.py

@@ -9,7 +9,15 @@ from .PyVertexvectors import Zones
 def create_vrt(wdir:str, fout:str='out.vrt', format:str='tif'):
     """
     Agglomération de tous les fichiers .tif dans un layer virtuel .vrt
+
+    :param wdir: working directory
+    :type wdir: str
+    :param fout: output file
+    :type fout: str
+    :param format: format of the files to process
+    :type format: str
     """
+
     curdir = os.getcwd()
     os.chdir(wdir)
 
@@ -24,7 +32,14 @@ def create_vrt(wdir:str, fout:str='out.vrt', format:str='tif'):
 def _get_relative_path(path:Path, base:Path):
     """
     Get relative path from base to path
+
+    :param path: path to get relative path
+    :type path: Path
+    :param base: base path
+    :type base: Path
+
     """
+
     if base in path.parents:
         return path.relative_to(base)
     elif path.parent in base.parents:
@@ -36,7 +51,13 @@ def _get_relative_path(path:Path, base:Path):
 def create_vrt_from_files(files:list[Path]=[], fout:Path='assembly.vrt'):
     """
     Agglomération de tous les fichiers énumérés dans files dans un layer virtuel .vrt
+
+    :param files: list of files to process
+    :type files: list[Path]
+    :param fout: output file
+    :type fout: Path
     """
+
     if isinstance(fout, str):
         fout = Path(fout)
 
@@ -60,6 +81,7 @@ def create_vrt_from_files_first_based(files:list[Path]=[], fout:Path='assembly.v
 
     Restreint l'emprise et force la résolution sur le premier fichier listé
     """
+
     if isinstance(fout, str):
         fout = Path(fout)
 
@@ -108,9 +130,8 @@ def translate_vrt2tif(fn:str, fout:str=None):
     """
     Translate vrt file to tif file
 
-    Args:
-        fn (str): '.vrt' file to translate
-        fout (str, optional): '.tif' file out. Defaults to None --> fn+'.tif'
+    :param fn: (str) '.vrt' file to translate
+    :param fout: (str, optional) '.tif' file out. Defaults to None --> fn+'.tif'
     """
     if isinstance(fn,Path):
         fn = str(fn)
@@ -139,10 +160,12 @@ def crop_vrt(fn:str, crop:list, fout:str=None):
     """
     Crop vrt file
 
-    Args:
-        fn (str): '.vrt' file to crop
-        crop (list): Bounds [[xmin, xmax], [ymin,ymax]] aka [[xLL, xUR], [yLL,yUR]]
-        fout (str, optional): '.tif' file out. Defaults to None --> fn+'_crop.tif'
+    :param fn: (str) '.vrt' file to crop
+    :type fn: str
+    :param crop: (list) Bounds [[xmin, xmax], [ymin,ymax]] aka [[xLL, xUR], [yLL,yUR]]
+    :type crop: list
+    :param fout: (str, optional) '.tif' file out. Defaults to None --> fn+'_crop.tif'
+    :type fout: str
     """
     if os.path.exists(fn):
 
@@ -173,7 +196,7 @@ def create_contours(files:list[Path]=[],
                    create_intern:bool = True,
                    force_mask_border:bool = True) -> Zones:
     """
-    Create contour from files
+    Create contour/footprint from files
 
     :param files: list of files to process
     :type files: list[Path]

wolfhece/wolfresults_2D.py

@@ -27,7 +27,7 @@ from .PyTranslate import _
 from .gpuview import GRID_N, Rectangle, VectorField
 from .pyshields import get_d_cr, get_d_cr_susp, izbach_d_cr, get_Shields_2D_Manning
 from .pyviews import WolfViews
-from .mesh2d.wolf2dprev import prev_parameters_simul, bloc_file
+from .mesh2d.wolf2dprev import prev_parameters_simul, blocks_file
 from .GraphNotebook import PlotPanel
 from .CpGrid import CpGrid
 
@@ -63,7 +63,7 @@ except Exception as ex:
 
     raise Exception(msg)
 
-from .wolf_array import WolfArray, getkeyblock, header_wolf, WolfArrayMB, WolfArrayMNAP, header_wolf, SelectionData
+from .wolf_array import WolfArray, getkeyblock, header_wolf, WolfArrayMB, WolfArrayMNAP, header_wolf, SelectionData, SelectionDataMB
 from .mesh2d import wolf2dprev
 from .PyVertexvectors import vector, zone, Zones
 
@@ -74,6 +74,7 @@ def outside_domain(val):
 
 def q_splitting(q_left, q_right):
     """ Splitting of the normal flow between two nodes """
+
     prod_q = q_left * q_right
     sum_q = q_left + q_right
     if prod_q > 0.:
@@ -98,6 +99,7 @@ def q_splitting(q_left, q_right):
 
 def u_splitting(q_left, q_right, h_left, h_right):
     """ Splitting of the normal flow velocity between two nodes """
+
     prod_q = q_left * q_right
     sum_q = q_left + q_right
     if prod_q > 0.:
@@ -1432,6 +1434,14 @@ class OneWolfResult:
         self._sedimentdensity = 2.65
         self._force_update_shields = True # Force la MAJ du Shields si le diametre ou la densité change
 
+        self.mngselection = SelectionData(self.current)
+
+    @property
+    def SelectionData(self) -> SelectionDataMB:
+        """ Return the data of the selection """
+
+        return self.mngselection
+
     @property
     def sediment_diameter(self):
         """ Diamètre des particules de sédiment [m] """
@@ -1962,7 +1972,7 @@ class Wolfresults_2D(Element_To_Draw):
     head_blocks:dict[str, header_wolf]
 
     myparam:prev_parameters_simul
-    myblocfile:bloc_file
+    myblocfile:blocks_file
     mymnap:WolfArrayMNAP
 
     def __init__(self,
@@ -2154,9 +2164,94 @@ class Wolfresults_2D(Element_To_Draw):
         self.properties:Props_Res_2D = None
         self.set_properties()
 
-        self.mngselection = SelectionData(self)
-        self.mngselection.dx, self.mngselection.dy = self[0].dx, self[0].dy
+        self.mngselection = SelectionDataMB(self)
         self.myops = None
+        self._active_blocks = 0
+
+    @property
+    def SelectionData(self) -> SelectionDataMB:
+        """ Return the data of the selection """
+
+        return self.mngselection
+
+    @property
+    def common_mask_MB(self) -> list[np.ndarray]:
+        """ Common mask for multiblock arrays """
+
+        if self.mymnap is not None:
+            return [cur.array.mask for cur in self.mymnap.myblocks.values()]
+        else:
+            return None
+
+    @property
+    def active_blocks(self) -> list["WolfArray"]:
+        """ Return the active blocks """
+
+        if self.nb_blocks>0 and self._active_blocks is not None:
+
+            if isinstance(self._active_blocks, list):
+                return [self.myblocks[cur] for cur in self._active_blocks]
+            elif self._active_blocks == 0:
+                return [k for k in self.myblocks.values()]
+            elif self._active_blocks in self.myblocks:
+                return [self.myblocks[self._active_blocks]]
+            else:
+                return None
+
+        else:
+            return [self]
+
+    @active_blocks.setter
+    def active_blocks(self, value:Union[str, int, list[int]]):
+        """
+        Set the active blocks
+
+        :param value: name of the block or index 1-based or list of index 1-based
+
+        """
+
+        if isinstance(value, str):
+            if value in self.myblocks:
+                self._active_blocks = value
+                logging.info(_(f'Block found - {value}'))
+            else:
+                self._active_blocks = None
+                logging.info(_('Block not found'))
+
+        elif isinstance(value, int):
+
+            if value == 0:
+                self._active_blocks = 0
+                logging.info(_('All blocks selected'))
+            else:
+                value = getkeyblock(value, addone=False)
+
+                if value in self.myblocks:
+                    self._active_blocks = value
+                    logging.info(_(f'Block found - {value}'))
+                else:
+                    self._active_blocks = None
+                    logging.info(_('Block not found'))
+
+        elif isinstance(value, list):
+
+            if 0 in value:
+                self._active_blocks = 0
+                logging.info(_('All blocks selected'))
+            else:
+                value = [getkeyblock(cur, addone=False) for cur in value]
+                value = [cur for cur in value if cur in self.myblocks]
+
+                if len(value)>0:
+                    self._active_blocks = value
+                    logging.info(_('List of blocks selected'))
+                else:
+                    self._active_blocks = None
+                    logging.info(_('No block found'))
+
+        else:
+            logging.error(_('Unknown type for active_blocks'))
+
 
     def default16(self):
         """ Mise à jour de la palette par défaut """
@@ -2326,6 +2421,7 @@ class Wolfresults_2D(Element_To_Draw):
         if _key in self.myblocks.keys():
             return self.myblocks[_key].current
         else:
+            logging.error(_('Block not found in Wolfresults_2D'))
             return None
 
     """ Iterator """
@@ -2338,15 +2434,22 @@ class Wolfresults_2D(Element_To_Draw):
         return self[self._iter]
     """ End Iterator """
 
-    def as_WolfArray(self, copyarray:bool=True) -> Union[WolfArray, WolfArrayMB]:
-        """Récupération d'une matrice MB ou Mono sur base du résultat courant"""
+    def as_WolfArray(self, copyarray:bool=True, force_mb = False) -> Union[WolfArray, WolfArrayMB]:
+        """
+        Récupération d'une matrice MB ou Mono sur base du résultat courant
+
+        :param copyarray : si True alors on copie les données
+        :param force_mb : if True then return a WolfArrayMB even if there is only one block
 
-        if self.nb_blocks>1:
+        """
+
+        if self.nb_blocks>1 or force_mb:
 
             retarray = WolfArrayMB()
             retarray.set_header(self.get_header())
             for i in range(self.nb_blocks):
                 retarray.add_block(self[i], copyarray=copyarray)
+
         else:
             if copyarray :
                 retarray = WolfArray(mold=self[0])
@@ -2393,82 +2496,6 @@ class Wolfresults_2D(Element_To_Draw):
         if self.get_currentview() == views_2D.SHIELDS_NUMBER and force:
             self.set_currentview()
 
-    # def _gpu_loader(self, fname:str):
-
-    #     # 2D GPU
-    #     nb_blocks = 1
-    #     self.myblocks = {}
-    #     curblock = OneWolfResult(0, parent=self)
-    #     self.myblocks[getkeyblock(0)] = curblock
-
-    #     if exists(join(dirname(fname), 'simul.top')):
-    #         curblock.top = WolfArray(join(dirname(fname), 'simul.top'), nullvalue=99999.)
-    #         curblock.waterdepth = WolfArray(join(dirname(fname), 'simul.hbin'))
-    #         curblock.qx = WolfArray(join(dirname(fname), 'simul.qxbin'))
-    #         curblock.qy = WolfArray(join(dirname(fname), 'simul.qybin'))
-    #         curblock.rough_n = WolfArray(join(dirname(fname), 'simul.frot'))
-    #     elif exists(join(dirname(fname), 'bathymetry.npy')):
-    #         curblock.top = WolfArray(join(dirname(fname), 'bathymetry.npy'), nullvalue=99999.)
-    #         curblock.waterdepth = WolfArray(join(dirname(fname), 'h.npy'))
-    #         curblock.qx = WolfArray(join(dirname(fname), 'qx.npy'))
-    #         curblock.qy = WolfArray(join(dirname(fname), 'qy.npy'))
-    #         curblock.rough_n = WolfArray(join(dirname(fname), 'manning.npy'))
-
-    #         if exists(join(dirname(fname), 'parameters.json')):
-    #             import json
-    #             with open(join(dirname(fname), 'parameters.json'), 'r') as fp:
-
-    #                 params = json.load(fp)
-
-    #                 try:
-    #                     curblock.top.dx = params["parameters"]["dx"]
-    #                     curblock.top.dy = params["parameters"]["dy"]
-    #                 except:
-    #                     logging.error(_('No spatial resolution (dx,dy) in parameters.json -- Results will not be shown in viewer'))
-
-    #                 try:
-    #                     curblock.top.origx = params["parameters"]["base_coord_x"]
-    #                     curblock.top.origy = params["parameters"]["base_coord_y"]
-    #                 except:
-    #                     logging.error(_('No spatial position (base_coord_x,base_coord_y) in parameters.json -- Results will not be spatially based'))
-
-    #     self.loaded_rough = True
-
-    #     to_check =[curblock.waterdepth, curblock.qx, curblock.qy, curblock.rough_n]
-    #     check = False
-    #     for curarray in to_check:
-    #         check |= curarray.dx != curblock.top.dx
-    #         check |= curarray.dy != curblock.top.dy
-    #         check |= curarray.origx != curblock.top.origx
-    #         check |= curarray.origy != curblock.top.origy
-    #         check |= curarray.translx != curblock.top.translx
-    #         check |= curarray.transly != curblock.top.transly
-
-    #     if check:
-    #         if exists(join(dirname(fname), 'simul.top')):
-    #             logging.error(_("Inconsistent header file in .top, .qxbin, .qybin or .frot files"))
-    #             logging.error(_("Forcing information into memory from the .top file -- May corrupt spatial positionning -- Please check your data !"))
-
-    #         for curarray in to_check:
-    #             curarray.dx    = curblock.top.dx
-    #             curarray.dy    = curblock.top.dy
-    #             curarray.origx = curblock.top.origx
-    #             curarray.origy = curblock.top.origy
-    #             curarray.translx = curblock.top.translx
-    #             curarray.transly = curblock.top.transly
-
-    #     if exists(join(dirname(fname), 'simul.trl')):
-    #         with open(join(dirname(fname), 'simul.trl')) as f:
-    #             trl=f.read().splitlines()
-    #             self.translx=float(trl[1])
-    #             self.transly=float(trl[2])
-
-    #     curblock.set_current(views_2D.WATERDEPTH)
-
-    #     self.myparam = None
-    #     self.mymnap = None
-    #     self.myblocfile = None
-
     def load_default_colormap(self, which:str):
         """
         Lecture d'une palette disponible dans le répertoire "models"
@@ -2493,7 +2520,8 @@ class Wolfresults_2D(Element_To_Draw):
         """
         Récupération des temps réels et des pas de calcul de chaque résultat sur disque
 
-        :param nb : nombre de résultats à lire
+        :param nb : nombre de résultats à lire - si None alors on lit tous les résultats
+        :return : tuple (liste des temps, liste des pas de calcul)
         """
         if nb is None:
             if self._nb_results is None:
@@ -2577,8 +2605,8 @@ class Wolfresults_2D(Element_To_Draw):
         self.myparam = prev_parameters_simul(self)
         self.myparam.read_file(self.filename)
 
-        self.myblocfile = bloc_file(self)
-        self.myblocfile.read_file()
+        self.myblocfile = blocks_file(self)
+        # self.myblocfile.read_file()
 
         self.mymnap = WolfArrayMNAP(self.filename)
 
@@ -2690,6 +2718,9 @@ class Wolfresults_2D(Element_To_Draw):
     def read_topography(self):
         """Lecture de la topographie de modélisation"""
         if exists(self.filename.strip() + '.topini'):
+
+            all_masks = self.common_mask_MB
+
             with open(self.filename.strip() + '.topini','rb') as f:
                 for i in range(self.nb_blocks):
                     nbx=self.myblocks[getkeyblock(i)].top.nbx
@@ -2697,9 +2728,14 @@ class Wolfresults_2D(Element_To_Draw):
                     nbbytes=nbx*nby*4
                     self.myblocks[getkeyblock(i)].top.array = ma.masked_equal(np.frombuffer(f.read(nbbytes),dtype=np.float32),0.)
                     self.myblocks[getkeyblock(i)].top.array = self.myblocks[getkeyblock(i)].top.array.reshape(nbx,nby,order='F')
+                    self.myblocks[getkeyblock(i)].top.array.mask[:,:] = all_masks[i][:,:]
+
 
     def read_ini_mb(self):
         """Lecture des conditions initiales"""
+
+        # all_masks = self.common_mask_MB()
+
         if exists(self.filename.strip() + '.hbinb'):
             with open(self.filename.strip() + '.hbinb','rb') as f:
                 for i in range(self.nb_blocks):
@@ -2708,6 +2744,7 @@ class Wolfresults_2D(Element_To_Draw):
                     nbbytes=nbx*nby*4
                     self.myblocks[getkeyblock(i)].waterdepth.array = ma.masked_equal(np.frombuffer(f.read(nbbytes),dtype=np.float32),0.)
                     self.myblocks[getkeyblock(i)].waterdepth.array = self.myblocks[getkeyblock(i)].waterdepth.array.reshape(nbx,nby,order='F')
+                    # self.myblocks[getkeyblock(i)].waterdepth.array.mask = all_masks[i].copy()
 
         if exists(self.filename.strip() + '.qxbinb'):
             with open(self.filename.strip() + '.qxbinb','rb') as f:
@@ -2717,6 +2754,7 @@ class Wolfresults_2D(Element_To_Draw):
                     nbbytes=nbx*nby*4
                     self.myblocks[getkeyblock(i)].qx.array = ma.masked_equal(np.frombuffer(f.read(nbbytes),dtype=np.float32),0.)
                     self.myblocks[getkeyblock(i)].qx.array = self.myblocks[getkeyblock(i)].qx.array.reshape(nbx,nby,order='F')
+                    # self.myblocks[getkeyblock(i)].qx.array.mask = all_masks[i].copy()
 
         if exists(self.filename.strip() + '.qybinb'):
             with open(self.filename.strip() + '.qybinb','rb') as f:
@@ -2726,6 +2764,7 @@ class Wolfresults_2D(Element_To_Draw):
                     nbbytes=nbx*nby*4
                     self.myblocks[getkeyblock(i)].qy.array = ma.masked_equal(np.frombuffer(f.read(nbbytes),dtype=np.float32),0.)
                     self.myblocks[getkeyblock(i)].qy.array = self.myblocks[getkeyblock(i)].qy.array.reshape(nbx,nby,order='F')
+                    # self.myblocks[getkeyblock(i)].qy.array.mask = all_masks[i].copy()
 
     def read_roughness_param(self):
         """Lecture du frottement de modélisation"""
@@ -2812,7 +2851,7 @@ class Wolfresults_2D(Element_To_Draw):
         """
         Lecture d'un pas de sauvegarde
 
-        which: result number to read; 0-based; -1 == last one
+        :param which: result number to read; 0-based; -1 == last one
         """
 
         which = self._sanitize_result_step(which)
@@ -2835,11 +2874,13 @@ class Wolfresults_2D(Element_To_Draw):
         """
         Lecture du pas suivant
         """
+
         self.current_result += 1
         self._update_result_view()
 
     def _sanitize_result_step(self, which_step:int=-1):
         """ Sanitize result step index -- 0-based """
+
         nb = self.get_nbresults()
         while which_step<0:
             which_step += nb
@@ -2864,10 +2905,106 @@ class Wolfresults_2D(Element_To_Draw):
 
         self.loaded=True
 
+    def set_hqxqy_as_initial_conditions(self, idx:int = None, as_multiblocks:bool = True):
+        """
+        Set the result as IC
+
+        :param idx : 0-based index
+        """
+
+        if idx is not None:
+            if idx>=0 and idx<self.get_nbresults():
+                self.read_oneresult(idx)
+            elif idx ==-1:
+                self.read_oneresult(-1) # last one
+            else:
+                logging.error(_('Bad index for initial conditions'))
+                return
+
+        self.set_currentview(views_2D.WATERDEPTH)
+
+        hini = self.as_WolfArray()
+
+        self.set_currentview(views_2D.QX)
+
+        qxini = self.as_WolfArray()
+
+        self.set_currentview(views_2D.QY)
+
+        qyini = self.as_WolfArray()
+
+        if (hini is not None) and (qxini is not None) and (qyini is not None):
+
+            if as_multiblocks:
+                hini.write_all(self.filename.strip() + '.hbinb')
+                qxini.write_all(self.filename.strip() + '.qxbinb')
+                qyini.write_all(self.filename.strip() + '.qybinb')
+
+                logging.info(_('Initial conditions saved as MB binary files'))
+
+            else:
+
+                hini = hini.as_WolfArray()
+                qxini = qxini.as_WolfArray()
+                qyini = qyini.as_WolfArray()
+
+                hini.write_all(self.filename.strip() + '.hbin')
+                qxini.write_all(self.filename.strip() + '.qxbin')
+                qyini.write_all(self.filename.strip() + '.qybin')
+
+                logging.info(_('Initial conditions saved as binary files'))
+        else:
+            logging.error(_('No initial conditions saved'))
+
+    def set_keps_as_initial_conditions(self, idx:int = None, as_multiblocks:bool = True):
+        """
+        Set the turbulent result as IC
+
+        :param idx : 0-based index
+        """
+
+        if idx is not None:
+            if idx>=0 and idx<self.get_nbresults():
+                self.read_oneresult(idx)
+            elif idx ==-1:
+                self.read_oneresult(-1) # last one
+            else:
+                logging.error(_('Bad index for initial conditions'))
+                return
+
+        self.set_currentview(views_2D.KINETIC_ENERGY)
+
+        kini = self.as_WolfArray()
+
+        self.set_currentview(views_2D.EPSILON)
+
+        epsini = self.as_WolfArray()
+
+        if (kini is not None) and (epsini is not None):
+
+            if as_multiblocks:
+                kini.write_all(self.filename.strip() + '.kbinb')
+                epsini.write_all(self.filename.strip() + '.epsbinb')
+
+                logging.info(_('Initial conditions saved as MB binary files'))
+
+            else:
+
+                kini = kini.as_WolfArray()
+                epsini = epsini.as_WolfArray()
+
+                kini.write_all(self.filename.strip() + '.kbin')
+                epsini.write_all(self.filename.strip() + '.epsbin')
+
+                logging.info(_('Initial conditions saved as binary files'))
+        else:
+            logging.error(_('No initial conditions saved'))
+
     def read_previous(self):
         """
         Lecture du pas suivant
         """
+
         # if self.current_result > 0:
         self.current_result -= 1
         self._update_result_view()
@@ -2889,6 +3026,7 @@ class Wolfresults_2D(Element_To_Draw):
 
         block : numéro du bloc; 1-based;
         """
+
         if isinstance(block,str):
             return self.myblocks[block].qx
         else:
@@ -2900,6 +3038,7 @@ class Wolfresults_2D(Element_To_Draw):
 
         block : numéro du bloc; 1-based;
         """
+
         if isinstance(block,str):
             return self.myblocks[block].qy
         else:
@@ -2916,6 +3055,7 @@ class Wolfresults_2D(Element_To_Draw):
             Les indices sont passés comme WOLF --> en numérotation Fortran (démarrage à 1 et non à 0)
         ***
         """
+
         h=-1
         qx=-1
         qy=-1
@@ -2974,11 +3114,10 @@ class Wolfresults_2D(Element_To_Draw):
 
         return self.head_blocks[getkeyblock(which_block,False)]
 
-    def get_xy_infootprint_vect(self, myvect: vector, which_block=1) -> np.ndarray:
+    def get_xy_infootprint_vect(self, myvect: vector, which_block=1) -> tuple[np.ndarray,np.ndarray]:
 
         """
-        Returns:
-            numpy array content les coordonnées xy des mailles dans l'empreinte du vecteur
+        :return numpy array content les coordonnées (x,y) des mailles dans l'empreinte du vecteur
         """
 
         myptsij = self.get_ij_infootprint_vect(myvect, which_block)

{wolfhece-2.0.55.dist-info → wolfhece-2.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wolfhece
-Version: 2.0.55
+Version: 2.1.1
 Author-email: Pierre Archambeau <pierre.archambeau@uliege.be>
 License: AGPL-v3 License
 Project-URL: Homepage, https://uee.uliege.be/hece
@@ -8,8 +8,9 @@ Project-URL: Issues, https://uee.uliege.be/hece
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Operating System :: Microsoft :: Windows :: Windows 10
 Classifier: Operating System :: Microsoft :: Windows :: Windows 11
+Classifier: Operating System :: POSIX :: Linux
 Classifier: Topic :: Scientific/Engineering :: Physics
-Requires-Python: <3.11,>=3.9
+Requires-Python: <3.11,>=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: wxpython
 Requires-Dist: numpy