wolfhece 2.0.52__py3-none-any.whl → 2.0.54__py3-none-any.whl

wolfhece/PyGui.py

@@ -615,7 +615,7 @@ class Wolf2DModel(GenMapManager):
             self.files_others={'Generic file':[
                 ('','First parametric file - historical'),
                 ('.par','Parametric file - multiblocks')],
-                            'Charachteristics':[
+                            'Characteristics':[
                 ('.fil','Infiltration hydrographs [m³/s]'),
                 ('.mnap','Resulting mesh [-]'),
                 ('.trl','Translation to real world [m]')
@@ -1147,7 +1147,7 @@ class Wolf2DModel(GenMapManager):
         self.myblocfile.write_file()
 
     def get_header_MB(self, abs=False):
-        """#> Renvoit un header avec les infos multi-blocs"""
+        """Renvoi d'un header avec les infos multi-blocs"""
         myheader:header_wolf
         myheader = self.mymnap.get_header(abs=abs)
         for curblock in self.mymnap.myblocks.values():
@@ -1298,7 +1298,7 @@ class Wolf2DModel(GenMapManager):
         ret=  _('Text files\n')
         ret+=  ('----------\n')
 
-        for key, val in self.files_others['Charachteristics']:
+        for key, val in self.files_others['Characteristics']:
             ret += f"{val} : {key}\n"
 
         ret +='\n\n'

wolfhece/PyParams.py

@@ -640,7 +640,7 @@ class Wolf_Param(wx.Frame):
                 if(genGroup != ""):
                     dict_param_def = self.myIncParam[genGroup][genParam]["Dict"][genParam]
                 else:
-                    dict_param_def = self.myIncParam[group][genParam]["Dict"]
+                    dict_param_def = self.myIncParam[group][genParam]["Dict"][genParam]
 
             elif(genGroup != ""):
                 dict_param_def = self.myIncGroup[genGroup]["Dict"][param_name]
@@ -1239,7 +1239,7 @@ class Wolf_Param(wx.Frame):
                 curdict["Saved"] = {}
 
             #pointage du param courant dans le dict de référence
-            curparam=curdict["Dict"]
+            curparam = curdict["Dict"][paramloc[0]] = {}
         else:
             #création d'un dict sur base du nom de paramètre
             curparam=groupdict[paramloc[0]]={}
@@ -1916,6 +1916,12 @@ class Wolf_Param(wx.Frame):
             savedDict[curGroup] = {}
 
         templateDict = self.myIncParam[genGroup][curIncParam]["Dict"]
+
+        if curIncParam in templateDict.keys():
+            templateDict = templateDict[curIncParam]
+        else:
+            logging.error(_("ERROR : the template of the incrementable parameter does not exist!"))
+
         if(nbElements is None):
             if self.wx_exists:
                 wx.MessageBox(_('The reference of the incrementable group does not exist!'), _('Error'), wx.OK|wx.ICON_ERROR)
@@ -1943,11 +1949,11 @@ class Wolf_Param(wx.Frame):
             else:
                 self.myparams[curGroup][curParam] = {}
                 self.myparams[curGroup][curParam][key_Param.NAME] = curParam
-                self.myparams[curGroup][curParam][key_Param.VALUE] = templateDict[curIncParam][key_Param.VALUE]
-                self.myparams[curGroup][curParam][key_Param.COMMENT] = templateDict[curIncParam][key_Param.COMMENT]
-                self.myparams[curGroup][curParam][key_Param.TYPE] = templateDict[curIncParam][key_Param.TYPE]
-                if key_Param.ADDED_JSON in templateDict[curIncParam]:
-                    self.myparams[curGroup][curParam][key_Param.ADDED_JSON] = templateDict[curIncParam][key_Param.ADDED_JSON]
+                self.myparams[curGroup][curParam][key_Param.VALUE] = templateDict[key_Param.VALUE]
+                self.myparams[curGroup][curParam][key_Param.COMMENT] = templateDict[key_Param.COMMENT]
+                self.myparams[curGroup][curParam][key_Param.TYPE] = templateDict[key_Param.TYPE]
+                if key_Param.ADDED_JSON in templateDict:
+                    self.myparams[curGroup][curParam][key_Param.ADDED_JSON] = templateDict[key_Param.ADDED_JSON]
 
         # transfert des paramètres en surplus dans le dictionnaire savedDict
         for i in range(nbElements+1, iterMax+1):

wolfhece/apps/version.py

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

wolfhece/mesh2d/wolf2dprev.py

@@ -12,6 +12,7 @@ except:
 import numpy as np
 import shutil
 from os.path import exists
+from os import makedirs
 import matplotlib.pyplot as plt
 import matplotlib.path as mpltPath
 import wx
@@ -19,7 +20,7 @@ import logging
 from enum import Enum
 
 from ..wolf_array import WOLF_ARRAY_FULL_INTEGER, WOLF_ARRAY_FULL_SINGLE, WolfArray, WolfArrayMB, WolfArrayMNAP, \
-    header_wolf, WolfArray_Sim2D, WolfArrayMNAP, WOLF_ARRAY_MB_SINGLE, WOLF_ARRAY_FULL_LOGICAL, WOLF_ARRAY_FULL_SINGLE, getkeyblock
+    header_wolf, WolfArray_Sim2D, WolfArrayMNAP, WOLF_ARRAY_MB_SINGLE, WOLF_ARRAY_FULL_LOGICAL, WOLF_ARRAY_FULL_SINGLE, getkeyblock, WOLF_ARRAY_MB_INTEGER
 
 from ..PyVertexvectors import *
 from ..PyVertex import getIfromRGB
@@ -2998,11 +2999,27 @@ class xy_file():
 
 
 class prev_sim2D():
+    """
+    Modélisation 2D CPU -- version 2D originale non OO
+
+    Cette classe est en construction et ne contient pas encore toutes les fonctionnalités.
+
+    Elle devrait à terme être utilisée dans l'objet Wolf2DModel de PyGui afin de séparer
+    le stockage des données de la visualisation et interface WX.
+
+    """
 
     def __init__(self, fname:str) -> None:
+        """
+        Initialisation de la classe
+
+        :param fname: nom du fichier générique de simulation - sans extension
+        """
 
         from pathlib import Path
 
+        fname = str(fname)
+
         self.filename = fname
         self.mydir = Path(fname).parent.as_posix()
         self.filenamegen = self.filename
@@ -3032,7 +3049,7 @@ class prev_sim2D():
         self.files_others={'Generic file':[
             ('','First parametric file - historical'),
             ('.par','Parametric file - multiblocks')],
-                        'Charachteristics':[
+                        'Characteristics':[
             ('.fil','Infiltration hydrographs [m³/s]'),
             ('.mnap','Resulting mesh [-]'),
             ('.trl','Translation to real world [m]')
@@ -3048,7 +3065,16 @@ class prev_sim2D():
         ]}
 
 
-    def get_header(self):
+    def get_header(self,abs=False):
+        """
+        Renvoi d'un header avec les infos géométriques de la simulation
+
+        Version monobloc et résolution fine
+
+        :param abs: si True, les origines sont décalées des translations et les translations sont mises à 0
+        :type abs: bool
+        """
+
         curhead = header_wolf()
 
         curhead.nbx = self.myparam.nxfin
@@ -3063,10 +3089,22 @@ class prev_sim2D():
         curhead.translx = self.myparam.translx
         curhead.transly = self.myparam.transly
 
+        if abs:
+            curhead.origx += curhead.translx
+            curhead.origy += curhead.transly
+            curhead.translx = 0.
+            curhead.transly = 0.
+
         return curhead
 
     def get_header_MB(self,abs=False):
-        """#> Renvoit un header avec les infos multi-blocs"""
+        """
+        Renvoi d'un header avec les infos multi-blocs
+
+        :param abs: si True, les origines sont décalées des translations et les translations sont mises à 0
+        :type abs: bool
+        """
+
         myheader:header_wolf
         myheader = self.mymnap.get_header(abs=abs)
         for curblock in self.mymnap.myblocks.values():
@@ -3075,7 +3113,12 @@ class prev_sim2D():
 
     def verify_files(self):
         """
-        Vérification de la présence des en-têtes dans les différents fichiers
+        Vérification de la présence des en-têtes dans les différents fichiers présents sur disque.
+
+        Cette routine est nécessaire pour s'assurer de la cohérence des headers. Certaines versions de l'interface VB6
+        présentaient un bug lors de la sauvegarde des fichiers ce qui peut avoir comme conséquence de décaler les données
+        (double application des translations vers le monde réel).
+
         """
 
         fhead = self.get_header()
@@ -3087,7 +3130,7 @@ class prev_sim2D():
             if exists(fname):
                 logging.info(f'Verifying header for {fname}')
                 fname += '.txt'
-                fhead.write_txt_header(fname,wolftype)
+                fhead.write_txt_header(fname, wolftype, forceupdate=True)
 
         mb = self.files_MB_array['Initial Conditions']
         for curextent,text,wolftype in mb:
@@ -3095,10 +3138,228 @@ class prev_sim2D():
             if exists(fname):
                 logging.info(f'Verifying header for {fname}')
                 fname += '.txt'
-                mbhead.write_txt_header(fname,wolftype)
+                mbhead.write_txt_header(fname, wolftype, forceupdate=True)
 
         fname = self.filenamegen + '.lst'
         if not exists(fname):
             logging.warning(f'File {fname} does not exist -- Creating it')
             with open(fname,'w') as f:
-                f.write('0\n')
+                f.write('0\n')
+
+    @property
+    def is_multiblock(self):
+        return self.mymnap.nb_blocks>1
+
+    @property
+    def nb_blocks(self):
+        return self.mymnap.nb_blocks
+
+    def read_fine_array(self, which:Literal['.top', '.hbin', '.qxbin', '.qybin', '.napbin', '.topini_fine', '.frot', '.inf']='') -> WolfArray:
+        """
+        Lecture d'une matrice fine
+
+        :param which: suffixe du fichier
+        :type which: str -- extension with point (e.g. '.hbin')
+        :return: WolfArray
+        """
+        which = str(which)
+        if not which.startswith('.'):
+            which = '.' + which
+
+        if Path(self.filenamegen + which).exists():
+            myarray = WolfArray(fname = self.filenamegen + which)
+            myarray.mask_reset()
+
+        else:
+            logging.error(f"File {self.filenamegen + which} does not exist")
+            myarray = None
+
+        return myarray
+
+    def read_MB_array(self, which:Literal['.hbinb', '.qxbinb', '.qybinb', '.frotini', '.topini']='') -> WolfArrayMB:
+        """
+        Lecture d'une matrice MB
+
+        :param which: suffixe du fichier
+        :type which: str -- extension with point (e.g. '.hbinb')
+        :return: WolfArrayMB
+        """
+
+        which = str(which)
+        if not which.startswith('.'):
+            which = '.' + which
+
+        if Path(self.filenamegen + which).exists():
+            myarray =WolfArrayMB()
+            myarray.set_header(self.get_header_MB())
+            myarray.filename = self.filenamegen+which
+            myarray.read_data()
+            myarray.mask_reset()
+        else:
+            logging.error(f"File {self.filenamegen + which} does not exist")
+            myarray = None
+
+        return myarray
+
+    def help_files(self) -> str:
+        """
+        Informations sur les fichiers et les types de données qu'ils contiennent.
+        """
+
+        ret=  _('Text files\n')
+        ret+=  ('----------\n')
+
+        for key, val in self.files_others['Characteristics']:
+            ret += f"{val} : {key}\n"
+
+        ret +='\n\n'
+
+        ret += _('Fine array - monoblock\n')
+        ret +=  ('----------------------\n')
+
+        for key, val, dtype in self.files_fine_array['Characteristics']:
+
+            if dtype == WOLF_ARRAY_FULL_LOGICAL:
+                ret += f"{val} : {key} [int16]\n"
+            elif dtype == WOLF_ARRAY_FULL_INTEGER:
+                ret += f"{val} : {key} [int32]\n"
+            elif dtype == WOLF_ARRAY_FULL_SINGLE:
+                ret += f"{val} : {key} [float32]\n"
+            else:
+                ret += f"{val} : {key} error - check code\n"
+
+        ret +='\n\n'
+
+        ret += _('Multiblock arrays\n')
+        ret +=  ('-----------------\n')
+
+        for key, val, dtype in self.files_MB_array['Initial Conditions']:
+
+            if dtype == WOLF_ARRAY_MB_INTEGER:
+                ret += f"{val} : {key} [int32]\n"
+            elif dtype == WOLF_ARRAY_MB_SINGLE:
+                ret += f"{val} : {key} [float32]\n"
+            else:
+                ret += f"{val} : {key} error - check code\n"
+
+        return ret
+
+    def check_infiltration(self) -> str:
+        """
+        Informations sur les zones d'infiltration :
+          - nombre de zones dans le fichier .inf et .fil
+          - nombre de cellules de chaque zone
+          - première maille de chaque zone
+          - nombre de temps énumérés dans le fichier .fil
+          - Warning si le nombre de zones est différent entre les fichiers .inf et .fil
+
+        """
+
+        ret =  _('inside .inf binary file') + '\n'
+        ret +=  ('-----------------------') + '\n'
+
+        inf = self.read_fine_array('.inf')
+
+        maxinf = inf.array.data.max()
+        ret += _('Maximum infiltration zone : ') + str(maxinf) + '\n'
+        for i in range(1,maxinf+1):
+
+            nb = np.sum(inf.array.data == i)
+            if nb>0:
+                indices = np.where(inf.array.data == i)
+                ret += f"Zone {i} : {nb} cells -- Indices (i,j) of the zone's first cell ({indices[0][0]+1} ; {indices[1][0]+1}) (1-based)\n"
+            else:
+                ret += f"Zone {i} : 0 cells\n"
+
+        ret += '\n'
+
+        ret += _('inside .fil text file') + '\n'
+        ret +=  ('----------------------') + '\n'
+
+        ret += f"Zones {self.myinfil.nb_zones}" + '\n'
+        ret += f"Time steps {self.myinfil.nb_steps}" + '\n'
+
+        if maxinf != self.myinfil.nb_zones:
+            ret += _('Warning : number of zones in .inf and .fil files are different') + '\n'
+
+        return ret
+
+
+    def copy2gpu(self, dirout:str='') -> str:
+        """
+        Copie des matrices d'une simulation CPU pour le code GPU
+
+        :param dirout: répertoire de sortie
+        :type dirout: str
+        """
+
+        def to_absolute(array:WolfArray):
+            array.origx += array.translx
+            array.origy += array.transly
+            array.translx = 0.
+            array.transly = 0.
+
+        ret = ''
+
+        dirout = Path(dirout)
+        makedirs(dirout, exist_ok=True)
+
+        inf = self.read_fine_array('.inf')
+        to_absolute(inf)
+        inf.write_all(dirout / 'infiltration_zones.npy')
+        del(inf)
+
+        ret += '.inf --> infiltration_zones.npy [np.int32]\n'
+
+        frot = self.read_fine_array('.frot')
+        to_absolute(frot)
+        frot.write_all(dirout / 'manning.npy')
+        del(frot)
+
+        ret += '.frot --> manning.npy [np.float32]\n'
+
+        hbin = self.read_fine_array('.hbin')
+        to_absolute(hbin)
+        hbin.write_all(dirout / 'h.npy')
+        del(hbin)
+
+        ret += '.hbin --> h.npy [np.float32]\n'
+
+        qxbin = self.read_fine_array('.qxbin')
+        to_absolute(qxbin)
+        qxbin.write_all(dirout / 'qx.npy')
+        del(qxbin)
+
+        ret += '.qxbin --> qx.npy [np.float32]\n'
+
+        qybin = self.read_fine_array('.qybin')
+        to_absolute(qybin)
+        qybin.write_all(dirout / 'qy.npy')
+        del(qybin)
+
+        ret += '.qybin --> qy.npy [np.float32]\n'
+
+        nap = self.read_fine_array('.napbin')
+        napgpu = np.zeros_like(nap.array.data, dtype = np.uint8)
+        napgpu[np.where(nap.array.data != 0)] = 1
+        np.save(dirout / 'nap.npy', napgpu)
+
+        ret += '.napbin --> nap.npy [np.uint8]\n'
+
+        top = self.read_fine_array('.top')
+        to_absolute(top)
+        top.array.data[np.where(napgpu != 1)] = 99999.
+        top.nullvalue = 99999.
+        top.write_all(dirout / 'bathymetry.npy')
+
+        ret += '.top --> bathymetry.npy [np.float32]\n'
+        ret += _('Force a value 99999. outside nap')
+
+        nb = np.sum(top.array.data != 99999.)
+        assert  nb == np.sum(napgpu == 1), 'Error in couting active cells'
+
+        ret += f'\n{nb} active cells in bathymetry.npy'
+
+        del(top)
+
+        return ret

wolfhece/wolf_array.py

@@ -5248,6 +5248,11 @@ class WolfArray(Element_To_Draw, header_wolf):
                 self.wolftype = WOLF_ARRAY_FULL_INTEGER16
             elif locarray.dtype == np.int8:
                 self.wolftype = WOLF_ARRAY_FULL_INTEGER8
+            else:
+                logging.error(_('Unsupported type in numpy file -- Abort loading'))
+                return
+
+            tmp_wolftype = self.wolftype
 
             # Il y de fortes chances que cette matrice numpy provienne d'une modélisation GPU
             #  et donc que les coordonnées et la résolution soient disponibles dans un fichier parameters.json
@@ -5270,6 +5275,13 @@ class WolfArray(Element_To_Draw, header_wolf):
             elif (locpath.parent / (locpath.name + '.txt')).exists():
                 self.read_txt_header()
 
+                # Le header contient également un type
+                # Vérification de la cohérence
+                if self.wolftype != tmp_wolftype:
+                    logging.warning(_('Inconsistent type in header and numpy file'))
+                    logging.warning(_('Forcing type from Numpy file'))
+                    self.wolftype = tmp_wolftype
+
             self.mask_data(self.nullvalue)
             self.loaded = True
 
@@ -5296,8 +5308,34 @@ class WolfArray(Element_To_Draw, header_wolf):
         if self.filename.endswith('.tif'):
             self.export_geotif()
         elif self.filename.endswith('.npy'):
+            
+            writing_header = True
+            if self.dtype !=  self.array.data.dtype:
+                logging.warning(_('Data type changed -- Force conversion to internal numpy array'))
+                locarray = self.array.data
+                if locarray.dtype == np.float32:
+                    self.wolftype = WOLF_ARRAY_FULL_SINGLE
+                    logging.warning(_('Data type changed to float32'))
+                elif locarray.dtype == np.float64:
+                    self.wolftype = WOLF_ARRAY_FULL_DOUBLE
+                    logging.warning(_('Data type changed to float64'))
+                elif locarray.dtype == np.int32:
+                    self.wolftype = WOLF_ARRAY_FULL_INTEGER
+                    logging.warning(_('Data type changed to int32'))
+                elif locarray.dtype == np.int16:
+                    self.wolftype = WOLF_ARRAY_FULL_INTEGER16
+                    logging.warning(_('Data type changed to int16'))
+                elif locarray.dtype == np.int8:
+                    self.wolftype = WOLF_ARRAY_FULL_INTEGER8
+                    logging.warning(_('Data type changed to int8'))
+                else:
+                    logging.error(_('Unsupported type in numpy file -- Abort wrting header file'))
+                    writing_header = False
+
             np.save(self.filename, self.array.data)
-            self.write_txt_header()
+
+            if writing_header:
+                self.write_txt_header()
         else:
             self.write_txt_header()
             self.write_array()
@@ -5306,6 +5344,8 @@ class WolfArray(Element_To_Draw, header_wolf):
         """
         Change resolution - in place
 
+        :param factor: factor of resolution change -- > 1.0 : decrease resolution, < 1.0 : increase resolution
+
         If you want to keep current data, copy the WolfArray into a new variable -> newWA = Wolfarray(mold=curWA)
         """
         operation = operation.lower()
@@ -5345,6 +5385,8 @@ class WolfArray(Element_To_Draw, header_wolf):
         else:
             self.array = np.kron(self.array, np.ones((int(1/factor), int(1/factor)), dtype=self.array.dtype))
 
+        self.mask_reset()
+
         self.count()
 
     def read_txt_header(self):
@@ -7035,6 +7077,142 @@ class WolfArrayMB(WolfArray):
                 self.myblocks[key].isblock = True
                 self.myblocks[key].blockindex = id
                 self.myblocks[key].idx = key
+
+    def set_header_from_added_blocks(self):
+        """ Set header from blocks """
+
+        if len(self.myblocks) > 0:
+
+            origx = min([curblock.origx + curblock.translx for curblock in self.myblocks.values()])
+            origy = min([curblock.origy + curblock.transly for curblock in self.myblocks.values()])
+            endx  = max([curblock.origx + curblock.translx + curblock.nbx*curblock.dx for curblock in self.myblocks.values()])
+            endy  = max([curblock.origy + curblock.transly + curblock.nby*curblock.dy for curblock in self.myblocks.values()])
+
+            self.dx = endx - origx
+            self.dy = endy - origy
+
+            self.nbx = 1
+            self.nby = 1
+
+            self.origx = origx
+            self.origy = origy
+
+            self.translx = 0.
+            self.transly = 0.
+
+    def as_WolfArray(self, abs:bool=True, forced_header:header_wolf = None) -> WolfArray:
+        """
+        Convert to WolfArray
+
+        Rebin blocks if necessary
+        """
+
+        newArray = WolfArray()
+
+        if forced_header is None:
+            myhead = self.get_header(abs=abs)
+        else:
+            myhead = forced_header
+            myhead.wolftype = self.wolftype
+
+        dx = set([curblock.get_header().dx for curblock in iter(self.myblocks.values())])
+        dy = set([curblock.get_header().dy for curblock in iter(self.myblocks.values())])
+
+        if len(dx) == 1 and len(dy) == 1:
+            # only one resolution
+
+            newArray.dx = list(dx)[0]
+            newArray.dy = list(dy)[0]
+
+            newArray.origx = myhead.origx
+            newArray.origy = myhead.origy
+            newArray.nbx   = int((myhead.nbx*myhead.dx)//newArray.dx)
+            newArray.nby   = int((myhead.nby*myhead.dy)//newArray.dy)
+            newArray.translx = myhead.translx
+            newArray.transly = myhead.transly
+
+            newArray.wolftype = WOLF_ARRAY_FULL_SINGLE if myhead.wolftype == WOLF_ARRAY_MB_SINGLE else WOLF_ARRAY_FULL_INTEGER
+
+            newArray.allocate_ressources()
+            newArray.array[:,:] = 0
+
+            for curblock in self.myblocks.values():
+
+                ij = np.where(~curblock.array.mask)
+                if len(ij[0]) > 0:
+                    if len(ij[0])>0:
+                        i = ij[0]
+                        j = ij[1]
+
+                        x0, y0 = curblock.get_xy_from_ij(0,0, abs=True)
+                        i0, j0 = newArray.get_ij_from_xy(x0, y0, abs=True)
+
+                        i_dest = i + i0
+                        j_dest = j + j0
+
+                        newArray.array[i_dest,j_dest] = curblock.array[i,j]
+                        newArray.array.mask[i_dest,j_dest] = False
+                    else:
+                        logging.debug(f"Block {curblock.idx} is empty or totally masked.")
+                else:
+                    logging.debug(f"Block {curblock.idx} is empty or totally masked.")
+
+        else:
+            # multiple resolutions
+
+            dx = list(dx)
+            dy = list(dy)
+
+            dx.sort()
+            dy.sort()
+
+            newArray.dx = dx[0]
+            newArray.dy = dy[0]
+            newArray.origx = myhead.origx
+            newArray.origy = myhead.origy
+            newArray.nbx   = int((myhead.nbx*myhead.dx)//newArray.dx)
+            newArray.nby   = int((myhead.nby*myhead.dy)//newArray.dy)
+            newArray.translx = myhead.translx
+            newArray.transly = myhead.transly
+
+            newArray.wolftype = WOLF_ARRAY_FULL_SINGLE if myhead.wolftype == WOLF_ARRAY_MB_SINGLE else WOLF_ARRAY_FULL_INTEGER
+
+            newArray.allocate_ressources()
+            newArray.array[:,:] = 0
+
+            for curblock in self.myblocks.values():
+
+                if curblock.dx == dx[0] and curblock.dy == dy[0]:
+                    # same resolution
+                    blockArray = curblock
+                else:
+                    # rebin
+
+                    factor = dx[0]/curblock.dx
+                    blockArray = WolfArray(mold=curblock)
+                    blockArray.rebin(factor)
+
+
+                ij = np.where(~blockArray.array.mask)
+                if len(ij[0]) > 0:
+                    if len(ij[0])>0:
+                        i = ij[0]
+                        j = ij[1]
+
+                        x0, y0 = blockArray.get_xy_from_ij(0,0, abs=True)
+                        i0, j0 = newArray.get_ij_from_xy(x0, y0, abs=True)
+
+                        i_dest = i + i0
+                        j_dest = j + j0
+
+                        newArray.array[i_dest,j_dest] = blockArray.array[i,j]
+                        newArray.array.mask[i_dest,j_dest] = False
+                    else:
+                        logging.debug(f"Block {curblock.idx} is empty or totally masked.")
+                else:
+                    logging.debug(f"Block {curblock.idx} is empty or totally masked.")
+
+        return newArray
 class WolfArrayMNAP(WolfArrayMB):
     """
     Matrice MNAP d'une modélisation WOLF2D

{wolfhece-2.0.52.dist-info → wolfhece-2.0.54.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wolfhece
-Version: 2.0.52
+Version: 2.0.54
 Author-email: Pierre Archambeau <pierre.archambeau@uliege.be>
 License: AGPL-v3 License
 Project-URL: Homepage, https://uee.uliege.be/hece

{wolfhece-2.0.52.dist-info → wolfhece-2.0.54.dist-info}/RECORD

@@ -7,11 +7,11 @@ wolfhece/Model1D.py,sha256=-cMz-ePSYzrKVVDidiDOz6cojEZ3y6u9gIb7RPwT6Y8,476593
 wolfhece/PyConfig.py,sha256=oGSL1WsLM9uinlNP4zGBLK3uHPmBfduUi7R-VtWuRFA,8034
 wolfhece/PyCrosssections.py,sha256=f4dNYRUGZKePruaaBiTcn5vlrw8TFTj9XwTDrdiF_uU,112450
 wolfhece/PyDraw.py,sha256=nUHEMpTG0zJvBJYOnreTvAISeP7cLsx14Qyrv-y32OY,344956
-wolfhece/PyGui.py,sha256=-LTnUVkRsqJw41DPN0jvhBOmDyygw6GgdGsno78cI_o,59833
+wolfhece/PyGui.py,sha256=fx66rJ6vw2m7fw_vElqO8AVDUGlaHG0FgAVwgsbH8NU,59829
 wolfhece/PyGuiHydrology.py,sha256=wKhR-KthPRyzJ887NmsozmUpm2CIQIwO3IbYORCYjrE,7290
 wolfhece/PyHydrographs.py,sha256=GKK8U0byI45H9O_e4LAOOi7Aw0Tg7Q0Lx322stPg5IQ,3453
 wolfhece/PyPalette.py,sha256=SYKYx_vxF_FVuceLhcIqFQsivGD6EoO_Xu-EGN9Ivko,22252
-wolfhece/PyParams.py,sha256=-0cax_Db6kFTe46BAgT24Ga2Xyp2Dm3gpuI-5uUSMxw,84758
+wolfhece/PyParams.py,sha256=SMmITkuZ4JYgF7ng3sj7TLUyDbD78mX7Am9ceCkCowg,84945
 wolfhece/PyPictures.py,sha256=-mJB0JL2YYiEK3D7_ssDkvYiMWK4ve9kXhozQXNeSx8,2216
 wolfhece/PyTranslate.py,sha256=4appkmNeHHZLFmUtaA_k5_5QL-5ymxnbVN4R2OblmtE,622
 wolfhece/PyVertex.py,sha256=OFo8VFxTSViWSTzv2paHeJ9O5BkFUyamXrRPFamlWoU,39630
@@ -48,7 +48,7 @@ wolfhece/rain_SPWMI.py,sha256=YqsF-yFro3y_a6MfVRFfr-Rxi7NR1gl_i8VX7scmzes,13548
 wolfhece/test_Results2DGPU.py,sha256=NOJ_hFXrcLSQXS1dtsqXRQltqIZtDSHMz_EgAJ2_FHU,307
 wolfhece/textpillow.py,sha256=zEfLrKhfCDyMaVuQOUjHqz6MGKeQ4aewMxOsWi5-wKI,13832
 wolfhece/tools_mpl.py,sha256=q8Yc4aukPPiUcEzREvZRM_em67XqXaahdoaNt0DETfE,266
-wolfhece/wolf_array.py,sha256=E6u0d6kABsegIZxPUZjtWS88lOrVc2d-lyW0uJgj6qo,289157
+wolfhece/wolf_array.py,sha256=WMiA4VvBsh_Dcabubs8tpi5hxvhZ9V_0vU1v2JjRmX0,296214
 wolfhece/wolf_hist.py,sha256=JpRXvzJLUP-RkSkvth3DQWglgTMFI2ZEUDb4RYOfeeI,3284
 wolfhece/wolf_texture.py,sha256=llQ7aV8scWXIkhpri9XjaPejzoBJsGfsln2ZnlRbFkU,16270
 wolfhece/wolf_tiles.py,sha256=F2JsJHdAP8fIffNJdG_J26bonCIRtIwMmxKFqdSCRDA,10088
@@ -66,7 +66,7 @@ wolfhece/apps/check_install.py,sha256=jrKR-njqnpIh6ZJqvP6KbDUPVCfwTNQj4glQhcyzs9
 wolfhece/apps/curvedigitizer.py,sha256=avWERHuVxPnJBOD_ibczwW_XG4vAenqWS8W1zjhBox8,4898
 wolfhece/apps/isocurrent.py,sha256=4XnNWPa8mYUK7V4zdDRFrHFIXNG2AN2og3TqWKKcqjY,3811
 wolfhece/apps/splashscreen.py,sha256=m9hMTqzhSUcTudApyNNjoAK9e2u5vgEkJVV79xmfM1s,2118
-wolfhece/apps/version.py,sha256=8oE3JduZOrh37rUOmSaJni3r3iRiovCtoxD28-Iwbn0,388
+wolfhece/apps/version.py,sha256=FjEAtmzKqev0MbA4BjHe-KyxIU3rJR3DImx2XMupK2A,388
 wolfhece/apps/wolf.py,sha256=gqfm-ZaUJqNsfCzmdtemSeqLw-GVdSVix-evg5WArJI,293
 wolfhece/apps/wolf2D.py,sha256=gWD9ee2-1pw_nUxjgRaJMuSe4kUT-RWhOeoTt_Lh1mM,267
 wolfhece/apps/wolf_logo.bmp,sha256=ruJ4MA51CpGO_AYUp_dB4SWKHelvhOvd7Q8NrVOjDJk,3126
@@ -211,7 +211,7 @@ wolfhece/mesh2d/bc_manager.py,sha256=vSVogXy1x3A6fZKWA6mPZSGX2e3EAUVmEjD9Bgww_hU
 wolfhece/mesh2d/cell_tracker.py,sha256=AR-Bty-QnrY1ni8Lwak2kU2UWMAJSBCF2ugl2YpfsB4,8660
 wolfhece/mesh2d/config_manager.py,sha256=vrxLku4isZJTxbHOACEEIEEjQB9pkLpaVPteJz9GhnE,14417
 wolfhece/mesh2d/cst_2D_boundary_conditions.py,sha256=BaJeKHyJiKEFWBkTQeYsDBW86703ooj65MFVpPMgjLg,2810
-wolfhece/mesh2d/wolf2dprev.py,sha256=q-5dwegcBjNy2IAn511Uuktnl8zt3cTtSowardpml2g,137113
+wolfhece/mesh2d/wolf2dprev.py,sha256=b1l4iKtptXkuzgx3Bp-fSZOJy-nPLN2aMy24IA3w3kA,145621
 wolfhece/models/HECE_169.pptx,sha256=OWJtsWz504A-REFaaxw8lwStHyQU2l7KEeiE7IZvtbk,3396930
 wolfhece/models/blue.pal,sha256=NnjJnjnYVdQkG54RyPXvo4Tl9ytB0cN7zpiHtj1N6bw,33
 wolfhece/models/diff16.pal,sha256=Pkp9kQ1GvmAKz3lgwohsw8eQySjVVKHbjhoWw-gZ6Nc,303
@@ -256,8 +256,8 @@ wolfhece/sounds/sonsw2.wav,sha256=pFLVt6By0_EPQNt_3KfEZ9a1uSuYTgQSX1I_Zurv9Rc,11
 wolfhece/ui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wolfhece/ui/wolf_multiselection_collapsiblepane.py,sha256=yGbU_JsF56jsmms0gh7mxa7tbNQ_SxqhpAZxhm-mTy4,14860
 wolfhece/ui/wolf_times_selection_comparison_models.py,sha256=wCxGRnE3kzEkWlWA6-3X8ADOFux_B0a5QWJ2GnXTgJw,4709
-wolfhece-2.0.52.dist-info/METADATA,sha256=fl0p2rqonKJIadsbbzLXDsXQgp6l3Z1a7cGZuL13Lc0,2233
-wolfhece-2.0.52.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-wolfhece-2.0.52.dist-info/entry_points.txt,sha256=AIu1KMswrdsqNq_2jPtrRIU4tLjuTnj2dCY-pxIlshw,276
-wolfhece-2.0.52.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
-wolfhece-2.0.52.dist-info/RECORD,,
+wolfhece-2.0.54.dist-info/METADATA,sha256=zSkV1unWFdQ-xAGkEZ_TAd8VfacBKdRc4ysmWkOjKS4,2233
+wolfhece-2.0.54.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+wolfhece-2.0.54.dist-info/entry_points.txt,sha256=AIu1KMswrdsqNq_2jPtrRIU4tLjuTnj2dCY-pxIlshw,276
+wolfhece-2.0.54.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
+wolfhece-2.0.54.dist-info/RECORD,,