wolfhece 2.0.4__py3-none-any.whl → 2.0.6__py3-none-any.whl

wolfhece/wolf_array.py

@@ -17,7 +17,7 @@ try:
 except:
     msg=_('Error importing OpenGL library')
     msg+=_('   Python version : ' + sys.version)
-    msg+=_('   Please check your version of opengl32.dll -- conflict may exist between different fils present on your desktop')
+    msg+=_('   Please check your version of opengl32.dll -- conflict may exist between different files present on your desktop')
     raise Exception(msg)
 
 import math
@@ -34,6 +34,7 @@ from shapely.ops import linemerge, substring
 from os.path import dirname,basename,join
 import logging
 from typing import Literal
+from copy import deepcopy
 
 from .PyTranslate import _
 from .GraphNotebook import PlotPanel
@@ -75,7 +76,7 @@ WOLF_ARRAY_MNAP_INTEGER = 20
 WOLF_ARRAY_MB = [WOLF_ARRAY_MB_SINGLE, WOLF_ARRAY_MB_INTEGER, WOLF_ARRAY_MNAP_INTEGER]
 
 
-def getkeyblock(i, addone=True):
+def getkeyblock(i, addone=True) -> str:
     """
     Name/Key of a block in the dictionnary of a WolfArrayMB instance
 
@@ -86,12 +87,22 @@ def getkeyblock(i, addone=True):
     else:
         return 'block' + str(i)
 
+def decodekeyblock(key, addone=True) -> int:
+    """
+    Decode key of a block in the dictionnary of a WolfArrayMB instance
+
+    For Fortran compatibility, addone is True by default so first block is "block1" and not "block0"
+    """
+    if addone:
+        return int(key[5:])
+    else:
+        return int(key[5:]) - 1
 class header_wolf():
     """
     Header of WolfArray
 
     In case of a mutliblock, the header have informations about all the blocks in head_blocks dictionnary.
-    Keys are generated by "getkeyblock" function
+    Block keys are generated by "getkeyblock" function
     """
 
     # FIXME It'd be wise to put the multiblock case into another class.
@@ -101,13 +112,19 @@ class header_wolf():
     head_blocks: dict[str,"header_wolf"]
 
     def __init__(self) -> None:
-        # Origin is the point in world space from which every other
-        # Origin is the point in world sapce from which every other
-        # coordinates are measured
+        """
+        Origin (origx, origy, [origz]) is the point in local space from which every other coordinates are measured.
+
+        Translation (translx, transly, [translz]) is the translation of the origin in global space. If translation is null, the origin is the same in local and global space. :-)
 
-        # In the multibloc case, there's the origin for the whole
-        # simulation and, for each block, the origin is ignored.
-        # It is replaced
+        Resolution (dx, dy, [dz]) is the spatial resolution of the array.
+
+        Nullvalue is the value of the null value in the array.
+
+        (nbx, nby, [nbz]) are the number of cells in the array along X and Y [and Z]. It is the shape of the array.
+
+        @property nbdims is the number of dimensions of the array (2 or 3)
+        """
 
         self.origx = 0.0
         self.origy = 0.0
@@ -127,9 +144,10 @@ class header_wolf():
 
         self.head_blocks = {}
 
-        self.nbdims = 0
+        self.nullvalue = 0.
 
     def __str__(self) -> str:
+        """ Return a string representation of the header """
         ret = ''
         ret += _('Shape  : {} x {} \n').format(self.nbx, self.nby)
         ret += _('Resolution  : {} x {} \n').format(self.dx, self.dy)
@@ -137,18 +155,59 @@ class header_wolf():
         ret += _('   - Origin : ({} ; {}) \n').format(self.origx, self.origy)
         ret += _('   - End : ({} ; {}) \n').format(self.origx + self.nbx * self.dx, self.origy +self.nby * self.dy)
         ret += _('   - Widht x Height : {} x {} \n').format(self.nbx * self.dx, self.nby * self.dy)
+        ret += _('Null value :{}\n'.format(self.nullvalue))
 
         return ret
 
+    @property
+    def nbdims(self):
+        if self.nbz == 0:
+            if self.nbx > 0 and self.nby > 0:
+                return 2
+            else:
+                return 0
+        elif self.nbz > 0:
+            return 3
+        else:
+            raise Exception(_('The number of dimensions is not correct'))
+
+    @nbdims.setter
+    def nbdims(self, value):
+        logging.warning(_('nbdims was an attribute of header_wolf.\nIt is now a read-only property.\nPlease use nbx, nby and nbz instead to define the shape of the array'))
+        raise Exception(_('This property is read-only'))
+
+    @property
+    def shape(self):
+        if self.nbdims == 2:
+            return (self.nbx, self.nby)
+        elif self.nbdims == 3:
+            return (self.nbx, self.nby, self.nbz)
+        else:
+            return (0, 0)
+        
+    @shape.setter
+    def shape(self, value:tuple[int]):
+        if len(value) == 3:
+            self.nbx = value[0]
+            self.nby = value[1]
+            self.nbz = value[2]
+        elif len(value) == 2:
+            self.nbx = value[0]
+            self.nby = value[1]
+            self.nbz = 0
+        else:
+            raise Exception(_('The number of dimensions is not correct'))
+
     @property
     def nb_blocks(self):
         return len(self.head_blocks)
 
     def __getitem__(self, key:Union[int,str]=None):
         """
-        return block header
+        Return block header
 
-        :param key:int = block's index (0-based)
+        :param key:int = block's index (0-based) or key (str)
+        :return : header_wolf instance if key is found, None otherwise
         """
         if key is None:
             return self
@@ -163,17 +222,54 @@ class header_wolf():
         else:
             return None
 
-    def set_orig(self, x:float, y:float, z:float):
+    def __setitem__(self, key:Union[int,str], value:"header_wolf"):
+        """
+        Set block header
+
+        :param value = tuple (key, header_wolf)
+
+        'key' can be an int (0-based) or a str
+        If str, please use getkeyblock function to generate the key
+        """
+
+        if isinstance(key,int):
+            _key = getkeyblock(key)
+        else:
+            _key = key
+
+        self.head_blocks[_key] = deepcopy(value)
+
+    def set_origin(self, x:float, y:float, z:float):
+        """
+        Set origin
+
+        :param x = origin along X
+        :param y = origin along Y
+        :param z = origin along Z
+        """
         self.origx = x
         self.origy = y
         self.origz = z
 
-    def set_transl(self, tr_x:float, tr_y:float, tr_z:float):
+    def set_translation(self, tr_x:float, tr_y:float, tr_z:float):
+        """
+        Set translation
+
+        :param tr_x = translation along X
+        :param tr_y = translation along Y
+        :param tr_z = translation along Z
+        """
         self.translx = tr_x
         self.transly = tr_y
         self.translz = tr_z
 
     def get_bounds(self, abs=True):
+        """
+        Return bounds in coordinates
+
+        :param abs = if True, add translation to (x, y) (coordinate to global space)
+        :return : tuple of two lists of two floats - ([xmin, xmax],[ymin, ymax])
+        """
         if abs:
             return ([self.origx + self.translx, self.origx + self.translx + float(self.nbx) * self.dx],
                     [self.origy + self.transly, self.origy + self.transly + float(self.nby) * self.dy])
@@ -181,13 +277,19 @@ class header_wolf():
             return ([self.origx, self.origx + float(self.nbx) * self.dx],
                     [self.origy, self.origy + float(self.nby) * self.dy])
 
-    def get_bounds_ij(self, abs=True):
+    def get_bounds_ij(self, abs=False):
+        """
+        Return bounds in indices
+
+        Firstly, get_bounds is called to get bounds in coordinates and then get_ij_from_xy is called to get bounds in indices.
 
+        :param abs = if True, add translation to (x, y) (coordinate to global space)
+        """
         mybounds = self.get_bounds(abs)
 
         return (
-            [self.get_ij_from_xy(mybounds[0][0], mybounds[1][0]), self.get_ij_from_xy(mybounds[0][1], mybounds[0][0])],
-            [self.get_ij_from_xy(mybounds[0][0], mybounds[1][1]), self.get_ij_from_xy(mybounds[0][1], mybounds[1][1])])
+            [self.get_ij_from_xy(mybounds[0][0], mybounds[1][0], abs=abs), self.get_ij_from_xy(mybounds[0][1], mybounds[0][0], abs=abs)],
+            [self.get_ij_from_xy(mybounds[0][0], mybounds[1][1], abs=abs), self.get_ij_from_xy(mybounds[0][1], mybounds[1][1], abs=abs)])
 
     def get_ij_from_xy(self, x:float, y:float, z:float=0., scale:float=1., aswolf:bool=False, abs:bool=True, forcedims2:bool=False) -> Union[tuple[np.int32,np.int32], tuple[np.int32,np.int32,np.int32]]:
         """
@@ -251,7 +353,7 @@ class header_wolf():
             locxy[:,1] -= self.transly
 
         i = np.int32(locxy[:,0] / (self.dx * scale))
-        j = np.int32(locxy[:,2] / (self.dy * scale))
+        j = np.int32(locxy[:,1] / (self.dy * scale))
 
         if aswolf:
             i += 1
@@ -261,7 +363,7 @@ class header_wolf():
             locxy[:,2] -= self.origz
             if abs:
                 locxy[:,2] -= self.translz
-            k = np.int32(locxy[:,3] / (self.dz * scale))
+            k = np.int32(locxy[:,2] / (self.dz * scale))
 
             if aswolf:
                 k += 1
@@ -353,13 +455,47 @@ class header_wolf():
         xy[:,0] = (np.float64( (ij[:,0])+decali) + .5) * (self.dx*scale) + self.origx + tr_x
         xy[:,1] = (np.float64( (ij[:,1])+decalj) + .5) * (self.dy*scale) + self.origy + tr_y
 
-        if self.nbdims == 3 and ij.shape[2]==3:
+        if self.nbdims == 3 and ij.shape[1]==3:
             xy[:,2] = (np.float64( (ij[:,2])+decalk) + .5) * (self.dz*scale) + self.origz + tr_z
 
         return xy
 
-    def find_intersection(self, other, ij=False):
+    def ij2xy(self, i:int, j:int, k:int=0, scale:float=1., aswolf:bool=False, abs:bool=True) -> Union[tuple[np.float64,np.float64], tuple[np.float64,np.float64,np.float64]]:
+        """ alias for get_xy_from_ij """
+        return self.get_xy_from_ij(i, j, k, scale, aswolf, abs)
+
+    def ij2xy(self, ij:np.ndarray, scale:float=1., aswolf:bool=False, abs:bool=True) -> np.ndarray:
+        """ alias for get_xy_from_ij_array """
+        return self.get_xy_from_ij_array(ij, scale, aswolf, abs)
+
+    def xy2ij(self, x:float, y:float, z:float=0., scale:float=1., aswolf:bool=False, abs:bool=True, forcedims2:bool=False) -> Union[tuple[np.int32,np.int32], tuple[np.int32,np.int32,np.int32]]:
+        """ alias for get_ij_from_xy """
+        return self.get_ij_from_xy(x, y, z, scale, aswolf, abs, forcedims2)
 
+    def xy2ij(self, xy:np.ndarray, scale:float=1., aswolf:bool=False, abs:bool=True) -> np.ndarray:
+        """ alias for get_xy_from_ij_array """
+        return self.get_xy_from_ij_array(xy, scale, aswolf, abs)
+
+    def xyz2ijk(self, xyz:np.ndarray, scale:float=1., aswolf:bool=False, abs:bool=True) -> np.ndarray:
+        """ alias for get_xy_from_ij_array """
+        assert xyz.shape[1] == 3, _('xyz must be a 2D array with 3 columns')
+        return self.get_xy_from_ij_array(xyz, scale, aswolf, abs)
+
+    def ijk2xyz(self, ijk:np.ndarray, scale:float=1., aswolf:bool=False, abs:bool=True) -> np.ndarray:
+        """ alias for get_xy_from_ij_array """
+        assert ijk.shape[1] == 3, _('ijk must be a 2D array with 3 columns')
+        return self.get_xy_from_ij_array(ijk, scale, aswolf, abs)
+
+
+    def find_intersection(self, other:"header_wolf", ij:bool = False) -> Union[tuple[list[float],list[float]], tuple[list[list[float]],list[list[float]]]]:
+        """
+        Find the intersection of two header
+
+        @arg other: other header
+        @arg ij: if True, return indices instead of coordinates
+
+        :return: None or tuple of two lists of two floats - ([xmin, xmax],[ymin, ymax]) or indices in each header (if ij=True) [[imin1, imax1], [jmin1, jmax1]], [[imin2, imax2], [jmin2, jmax2]]
+        """
         mybounds = self.get_bounds()
         otherbounds = other.get_bounds()
 
@@ -387,7 +523,12 @@ class header_wolf():
             else:
                 return ([ox, ex], [oy, ey])
 
-    def find_union(self, other):
+    def find_union(self, other:"header_wolf") -> tuple[list[float],list[float]]:
+        """
+        Find the union of two header
+
+        :return: tuple of two lists of two floats - ([xmin, xmax],[ymin, ymax])
+        """
 
         mybounds = self.get_bounds()
         otherbounds = other.get_bounds()
@@ -400,7 +541,16 @@ class header_wolf():
         return ([ox, ex], [oy, ey])
 
     def read_txt_header(self, filename:str):
-        """ Lecture du header .txt """
+        """ 
+        Read informations from header .txt 
+        
+        :param filename : path and filename of the basefile
+
+        If filename is a Path object, it is converted to a string
+        If filename ends with '.tif', nothing is done because infos are in the .tif file
+        If filename ends with '.flt', a .hdr file must be present and it will be read
+        Otherwise, a filename.txt file must be present
+        """
         if isinstance(filename, Path):
             filename = str(filename)
 
@@ -483,7 +633,6 @@ class header_wolf():
 
             decal = 9
             if self.wolftype == WOLF_ARRAY_FULL_SINGLE_3D:
-                self.nbdims = 3
                 tmp = lines[9].split(':')
                 self.nbz = int(tmp[1])
                 tmp = lines[10].split(':')
@@ -525,11 +674,13 @@ class header_wolf():
                          wolftype:int,
                          forceupdate:bool=False):
         """
-        Ecriture du header dans un fichier texte
+        Writing the header to a text file
 
-        filename : chemin d'accès et nom de fichier avec '.txt' qui ne sera pas ajouté automatiquement
-        wolftype : type de la matrice WOLF_ARRAY_*
+        Nullvalue is not written
 
+        :param filename : path and filename with '.txt' extension, which will NOT be automatically added
+        :param wolftype : type of the WOLF_ARRAY_* array
+        :param forceupdate : if True, the file is rewritten even if it already exists
         """
 
         assert wolftype in [WOLF_ARRAY_CSR_DOUBLE, WOLF_ARRAY_FULL_SINGLE, WOLF_ARRAY_FULL_DOUBLE, WOLF_ARRAY_SYM_DOUBLE, WOLF_ARRAY_FULL_LOGICAL, WOLF_ARRAY_CSR_DOUBLE, WOLF_ARRAY_FULL_INTEGER, WOLF_ARRAY_FULL_SINGLE_3D, WOLF_ARRAY_FULL_INTEGER8, WOLF_ARRAY_MB_SINGLE, WOLF_ARRAY_MB_INTEGER, WOLF_ARRAY_FULL_INTEGER16, WOLF_ARRAY_MNAP_INTEGER]
@@ -564,8 +715,15 @@ class header_wolf():
                         f.write('DX :\t{0}\n'.format(str(curhead.dx)))
                         f.write('DY :\t{0}\n'.format(str(curhead.dy)))
 
-    def is_like(self,other):
-        """Comparison of two headers"""
+    def is_like(self, other:"header_wolf", check_mb:bool=False) -> bool:
+        """
+        Comparison of two headers
+
+        :param other : other header to compare
+        :param check_mb : if True, the comparison is done on the blocks too
+
+        The nullvalue is not taken into account
+        """
         test = True
         test &= self.origx == other.origx
         test &= self.origy == other.origy
@@ -585,8 +743,151 @@ class header_wolf():
 
         test &= self.nbdims == other.nbdims
 
+        if check_mb:
+            test &= self.nb_blocks == other.nb_blocks
+            for block1, block2 in zip(self.head_blocks.values(), other.head_blocks.values()):
+                test &= block1.is_like(block2)
+
         return test
 
+    def align2grid(self, x1:float, y1:float, eps:float=0.0001) -> tuple[float,float]:
+        """ Align coordinates to nearest grid point """
+
+        if x1-self.origx < 0:
+            x2 = np.round((x1 - self.origx + eps) / self.dx) * self.dx + self.origx
+        else:
+            x2 = np.round((x1 - self.origx - eps) / self.dx) * self.dx + self.origx
+
+        if y1-self.origy < 0:
+            y2 = np.round((y1 - self.origy + eps) / self.dy) * self.dy + self.origy
+        else:
+            y2 = np.round((y1 - self.origy - eps) / self.dy) * self.dy + self.origy
+
+        return x2, y2
+
+    def _rasterize_segment(self,
+                           x1:float, y1:float,
+                           x2:float, y2:float,
+                           xstart:float=None, ystart:float=None) -> list[list[float]]:
+        """
+        Rasterize a segment according to the grid
+
+        :param x1: x coordinate of the first point
+        :param y1: y coordinate of the first point
+        :param x2: x coordinate of the second point
+        :param y2: y coordinate of the second point
+        :param xstart: x coordinate of the starting point
+        :param ystart: y coordinate of the starting point
+
+        :return: numpy array of the rasterized segment
+        """
+
+        if xstart is None and ystart is None:
+            xstart, ystart = self.align2grid(x1, y1)
+
+        x2, y2 = self.align2grid(x2, y2)
+
+        points=[]
+        points.append([xstart, ystart])
+
+        length = 99999.
+        prec = min(self.dx, self.dy)
+        direction = np.array([x2-xstart, y2-ystart])
+        length = np.linalg.norm(direction)
+        direction /= length
+
+        while length >= prec:
+
+            if np.abs(direction[0])>= np.abs(direction[1]):
+                xstart += self.dx * np.sign(direction[0])
+            else:
+                ystart += self.dy * np.sign(direction[1])
+
+            points.append([xstart, ystart])
+
+            direction = np.array([x2-xstart, y2-ystart])
+            length = np.linalg.norm(direction)
+            direction /= length
+
+        return points
+
+    def rasterize_vector(self, vector2raster:vector, outformat:Union[np.ndarray, vector]=vector) -> Union[np.ndarray,vector]:
+        """
+        Rasterize a vector according to the grid
+
+        :param vector2raster: vector to rasterize
+        :param outformat: output format (np.ndarray or vector)
+        """
+
+        assert outformat in [np.ndarray, vector], _('outformat must be np.ndarray or vector')
+
+        # get the vertices of the vector
+        xy = vector2raster.asnparray().tolist()
+
+        # rasterize the vector
+        rasterized = []
+        rasterized += self._rasterize_segment(xy[0][0], xy[0][1], xy[1][0], xy[1][1])
+
+        for i in range(1, len(xy)-1):
+            out =  self._rasterize_segment(xy[i][0], xy[i][1],
+                                                  xy[i+1][0], xy[i+1][1],
+                                                  rasterized[-1][0], rasterized[-1][1])
+            rasterized += out[1:]
+
+        # get the indices of the rasterized vector
+        xy = np.array(rasterized)
+
+        if outformat is np.ndarray:
+            return xy
+        elif outformat is vector:
+            #create new vector
+            newvector = vector()
+            newvector.add_vertices_from_array(xy)
+
+            return newvector
+
+    def get_xy_infootprint_vect(self, myvect: vector) -> np.ndarray:
+        """
+        Return the coordinates of the cells in the footprint of a vector
+
+        :param myvect = target vector
+        """
+
+        myptsij = self.get_ij_infootprint_vect(myvect)
+        mypts=np.asarray(myptsij.copy(),dtype=np.float64)
+        mypts[:,0] = (mypts[:,0]+.5)*self.dx +self.origx +self.translx
+        mypts[:,1] = (mypts[:,1]+.5)*self.dy +self.origy +self.transly
+
+        return mypts,myptsij
+
+    def get_ij_infootprint_vect(self, myvect: vector) -> np.ndarray:
+        """
+        Return the indices of the cells in the footprint of a vector
+
+        :param myvect = target vector
+        """
+
+        i1, j1 = self.get_ij_from_xy(myvect.xmin, myvect.ymin)
+        i2, j2 = self.get_ij_from_xy(myvect.xmax, myvect.ymax)
+        i1 = max(i1,0) # FIXME Why ??? How could i,j be negative ? --> because this fucntion can be called with a vector that is not in the array (e.g. a vector defined by clicks in the UI)
+        j1 = max(j1,0)
+        i2 = min(i2,self.nbx-1)
+        j2 = min(j2,self.nby-1)
+        xv,yv = np.meshgrid(np.arange(i1,i2+1),np.arange(j1,j2+1))
+        mypts = np.hstack((xv.flatten()[:,np.newaxis],yv.flatten()[:,np.newaxis]))
+
+        return mypts
+
+    def convert_xy2ij_np(self,xy):
+        """ Convert XY coordinates to IJ indices with Numpy without any check/options """
+        return np.asarray((xy[:,0]-self.origx -self.translx)/self.dx-.5,dtype=np.int32), \
+               np.asarray((xy[:,1]-self.origy -self.transly)/self.dy-.5,dtype=np.int32)
+
+    def convert_ij2xy_np(self,xy):
+        """ Convert IJ indices to XY coordinates with Numpy without any check/options """
+        return np.asarray((xy[:,0]+.5)*self.dx+self.origx +self.translx ,dtype=np.float64), \
+               np.asarray((xy[:,1]+.5)*self.dy+self.origy +self.transly ,dtype=np.float64)
+
 class NewArray(wx.Dialog):
     """
     wx GUI interaction to create a new WolfArray
@@ -665,9 +966,10 @@ class NewArray(wx.Dialog):
         self.Centre(wx.BOTH)
 
 
+#FIXME : Generalize to 3D
 class CropDialog(wx.Dialog):
     """
-    wx GUI interaction to crop array's data
+    wx GUI interaction to crop 2D array's data
 
     Used in "read_data" of a WolfArray
     """
@@ -747,6 +1049,8 @@ class CropDialog(wx.Dialog):
         self.Centre(wx.BOTH)
 
     def get_header(self):
+        """ Return a header_wolf object with the values of the dialog """
+
         myhead = header_wolf()
         myhead.origx = float(self.ox.Value)
         myhead.origy = float(self.oy.Value)
@@ -754,19 +1058,23 @@ class CropDialog(wx.Dialog):
         myhead.dy = float(self.dy.Value)
         myhead.nbx = int((float(self.ex.Value) - myhead.origx) / myhead.dx)
         myhead.nby = int((float(self.ey.Value) - myhead.origy) / myhead.dy)
-        myhead.nbdims = 2
 
         return myhead
 
 
 class Ops_Array(wx.Frame):
     """
-    Fenêtre d'opérations sur un WolfArray
+    Operations wx.Frame on WolfArray class
 
-    Cet objet permet de manipuler les données d'un WolfArray
+    This class is used to perform operations on a WolfArray
     """
 
     def __init__(self, parentarray:"WolfArray", mapviewer=None):
+        """ Init the Ops_Array class
+
+        :param parentarray: WolfArray to operate on
+        :param mapviewer: WolfMapViewer to update if necessary
+        """
 
         self.parentarray:WolfArray
         self.parentarray = parentarray
@@ -777,6 +1085,7 @@ class Ops_Array(wx.Frame):
 
         self.wx_exists = wx.App.Get() is not None
 
+        # active objects
         self.active_vector:vector = None
         self.active_zone:zone = None
         self.active_array:WolfArray = self.parentarray
@@ -793,7 +1102,7 @@ class Ops_Array(wx.Frame):
             self.set_GUI()
 
     def get_mapviewer(self):
-        """ Retourne une instance WolfMapViewer """
+        """ Retourne l'instance WolfMapViewer """
         return self.mapviewer
 
     def get_linked_arrays(self):
@@ -980,20 +1289,28 @@ class Ops_Array(wx.Frame):
 
         # Tools
         Toolssizer = wx.BoxSizer(wx.VERTICAL)
+
         hbox = wx.BoxSizer(wx.HORIZONTAL)
+
         self.lbl_nullval = wx.StaticText(self.tools,label=_('Null value'))
         self.txt_nullval = wx.TextCtrl(self.tools,value=str(self.parentarray.nullvalue), style=wx.TE_CENTER)
         self.txt_nullval.SetToolTip(_('Array null value'))
         hbox.Add(self.lbl_nullval, 0, wx.EXPAND|wx.ALL)
         hbox.Add(self.txt_nullval, 1, wx.EXPAND|wx.ALL)
 
-        self.ApplyTools = wx.Button(self.tools, wx.ID_ANY, _("Apply modifications"), wx.DefaultPosition,
+        self.ApplyTools = wx.Button(self.tools, wx.ID_ANY, _("Apply null value"), wx.DefaultPosition,
                                  wx.DefaultSize, 0)
 
+
+        self.nullborder = wx.Button(self.tools, wx.ID_ANY, _("Null border"), wx.DefaultPosition,
+                                    wx.DefaultSize, 0)
+
         Toolssizer.Add(hbox, 0, wx.EXPAND)
         Toolssizer.Add(self.ApplyTools, 1, wx.EXPAND)
+        Toolssizer.Add(self.nullborder, 1, wx.EXPAND)
 
         self.ApplyTools.SetToolTip(_("Save modifications into memmory/object"))
+        self.nullborder.SetToolTip(_("Set null value on the border of the array"))
 
         self.tools.SetSizer(Toolssizer)
         self.tools.Layout()
@@ -1008,12 +1325,12 @@ class Ops_Array(wx.Frame):
         bSizer16 = wx.BoxSizer(wx.VERTICAL)
 
         selectmethodChoices = [_("by clicks"), _("inside active vector"), _("inside active zone"),
-                               _("inside temporary vector"), _("under active vector"), _("under active zone"),
-                               _("under temporary vector")]
+                               _("inside temporary vector"), _("along active vector"), _("along active zone"),
+                               _("along temporary vector")]
         self.selectmethod = wx.RadioBox(self.selection, wx.ID_ANY, _("How to select nodes?"), wx.DefaultPosition,
                                         wx.DefaultSize, selectmethodChoices, 1, wx.RA_SPECIFY_COLS)
         self.selectmethod.SetSelection(0)
-        self.selectmethod.SetToolTip(_("Selection mode : \n - one by one (keyboard shortcut N) \n- inside the currently activated polygon (keyboard shortcut V) \n- inside the currently activated zone (multipolygons) \n- inside a temporary polygon (keyboard shortcut B) \n- under the currently activated polyline \n- under the currently activated zone (multipolylines) \n- under a temporary polyline"))
+        self.selectmethod.SetToolTip(_("Selection mode : \n - one by one (keyboard shortcut N) \n- inside the currently activated polygon (keyboard shortcut V) \n- inside the currently activated zone (multipolygons) \n- inside a temporary polygon (keyboard shortcut B) \n- along the currently activated polyline \n- along the currently activated zone (multipolylines) \n- along a temporary polyline"))
 
         bSizer16.Add(self.selectmethod, 0, wx.ALL, 5)
 
@@ -1227,7 +1544,8 @@ class Ops_Array(wx.Frame):
         self.saveas.Bind(wx.EVT_BUTTON, self.OnSaveasvec)
         self.save.Bind(wx.EVT_BUTTON, self.OnSavevec)
         self.ApplyOp.Bind(wx.EVT_BUTTON, self.OnApplyOpMath)
-        self.ApplyTools.Bind(wx.EVT_BUTTON, self.OnApplyTools)
+        self.ApplyTools.Bind(wx.EVT_BUTTON, self.OnApplyNullvalue)
+        self.nullborder.Bind(wx.EVT_BUTTON, self.OnNullBorder)
         self.SelectOp.Bind(wx.EVT_BUTTON, self.OnApplyOpSelect)
         self.palapply.Bind(wx.EVT_BUTTON, self.Onupdatepal)
         self.palsave.Bind(wx.EVT_BUTTON, self.Onsavepal)
@@ -1240,21 +1558,18 @@ class Ops_Array(wx.Frame):
         self.histoupdateerase.Bind(wx.EVT_BUTTON, self.OnClickHistoUpdate)
 
     def interpolation2D(self, event: wx.MouseEvent):
+        """ calling Interpolation 2D """
         self.parentarray.interpolation2D()
 
     def Unmaskall(self, event: wx.MouseEvent):
         """
-        Enlève le masque des tous les éléments
+        Unmask all values in the current array
         @author Pierre Archambeau
         """
-        curarray: WolfArray
-        curarray = self.parentarray
-        curarray.mask_reset()
-        curarray = self.parentarray
-        curarray.updatepalette()
-        curarray.delete_lists()
+        self.parentarray.mask_reset()
+        self.refresh_array()
 
-    def Unmasksel(self,event:wx.MouseEvent):
+    def Unmasksel(self, event:wx.MouseEvent):
         """
         Enlève le masque des éléments sélectionnés
         @author Pierre Archambeau
@@ -1271,17 +1586,12 @@ class Ops_Array(wx.Frame):
 
         curarray.array.mask[destij[:, 0], destij[:, 1]] = False
 
-        curarray.updatepalette()
-        curarray.delete_lists()
+        self.refresh_array()
 
     def InvertMask(self, event: wx.MouseEvent):
-
-        curarray: WolfArray
-        curarray = self.parentarray
-        curarray.mask_invert()
-        curarray = self.parentarray
-        curarray.updatepalette()
-        curarray.delete_lists()
+        """ Invert mask """
+        self.parentarray.mask_invert()
+        self.refresh_array()
 
     def interp2Dpolygons(self, event: wx.MouseEvent):
         """
@@ -1299,15 +1609,12 @@ class Ops_Array(wx.Frame):
         dlg.Destroy()
 
         actzone = self.active_zone
-        curarray: WolfArray
-        curarray = self.parentarray
 
         for curvec in actzone.myvectors:
             curvec: vector
             self._interp2Dpolygon(curvec, method)
 
-        curarray.updatepalette()
-        curarray.delete_lists()
+        self.refresh_array()
 
     def interp2Dpolygon(self, event: wx.MouseEvent):
         """
@@ -1324,14 +1631,9 @@ class Ops_Array(wx.Frame):
         method = dlg.GetStringSelection()
         dlg.Destroy()
 
-        actzone = self.active_zone
-        curarray: WolfArray
-        curarray = self.parentarray
-
         self._interp2Dpolygon(self.active_vector, method)
 
-        curarray.updatepalette()
-        curarray.delete_lists()
+        self.refresh_array()
 
     def _interp2Dpolygon(self, vect: vector, method):
         """
@@ -1370,28 +1672,21 @@ class Ops_Array(wx.Frame):
         cf _interp2Dpolyline
         """
         actzone = self.active_zone
-        curarray: WolfArray
-        curarray = self.parentarray
 
         for curvec in actzone.myvectors:
             curvec: vector
             self._interp2Dpolyline(curvec)
 
-        curarray.updatepalette()
-        curarray.delete_lists()
+        self.refresh_array()
 
     def interp2Dpolyline(self, event: wx.MouseEvent):
         """
         Bouton d'interpolation sous la polyligne active
         cf _interp2Dpolyline
         """
-        curarray: WolfArray
-        curarray = self.parentarray
-
         self._interp2Dpolyline(self.active_vector)
 
-        curarray.updatepalette()
-        curarray.delete_lists()
+        self.refresh_array()
 
     def _interp2Dpolyline(self, vect: vector, usemask=True):
         """
@@ -1515,14 +1810,17 @@ class Ops_Array(wx.Frame):
         self.reset_all_selection()
 
     def OnApplyOpSelect(self, event):
-        curcond = self.condition.GetSelection()
+        """ Select nodes based on condition """
 
+        # condition operator
+        curcond = self.condition.GetSelection()
+        # condition value
         curcondvalue = float(self.condvalue.GetValue())
 
         self.parentarray.mngselection.condition_select(curcond, curcondvalue)
 
-    def OnApplyTools(self, event:wx.MouseEvent):
-
+    def OnApplyNullvalue(self, event:wx.MouseEvent):
+        """ Apply null value to the array """
         newnull = self.txt_nullval.Value
         if newnull.lower() == 'nan':
             newnull = np.nan
@@ -1532,25 +1830,52 @@ class Ops_Array(wx.Frame):
         if self.parentarray.nullvalue!= newnull:
             self.parentarray.nullvalue = newnull
             self.parentarray.mask_data(newnull)
-            self.parentarray.reset_plot()
-            if self.mapviewer is not None:
-                self.mapviewer.Refresh()
+            self.refresh_array()
 
-    def OnApplyOpMath(self, event):
+    def refresh_array(self):
+        """ Force refresh of the parent array """
+        self.parentarray.reset_plot()
+
+    def OnNullBorder(self, event:wx.MouseEvent):
+        """ Nullify the border of the array """
+
+        dlg = wx.SingleChoiceDialog(None, "Choose the border width [number of nodes]", "Border width", [str(i) for i in range(1, 20)])
+
+        ret = dlg.ShowModal()
+        if ret == wx.ID_CANCEL:
+            dlg.Destroy()
+            return
 
+        borderwidth = int(dlg.GetStringSelection())
+
+        self.parentarray.nullify_border(borderwidth)
+
+    def OnApplyOpMath(self, event:wx.MouseEvent):
+        """ Apply math operator to the array """
+
+        # operator type
         curop = self.choiceop.GetSelection()
+        # condition type
         curcond = self.condition.GetSelection()
 
+        # operator value
         opval = self.opvalue.GetValue()
         if opval.lower() == 'null' or opval.lower() == 'nan':
             curopvalue = self.parentarray.nullvalue
         else:
             curopvalue = float(opval)
-        curcondvalue = float(self.condvalue.GetValue())
+
+        # condition value
+        curcondvalue = self.condvalue.GetValue()
+        if curcondvalue.lower() == 'null' or curcondvalue.lower() == 'nan':
+            curcondvalue = self.parentarray.nullvalue
+        else:
+            curcondvalue = float(curcondvalue)
 
         self.parentarray.mngselection.treat_select(curop, curcond, curopvalue, curcondvalue)
 
-    def Onmask(self, event):
+    def Onmask(self, event:wx.MouseEvent):
+        """ Mask nodes based on condition """
 
         curop = self.choiceop.GetSelection()
         curcond = self.condition.GetSelection()
@@ -1559,10 +1884,11 @@ class Ops_Array(wx.Frame):
         curcondvalue = float(self.condvalue.GetValue())
 
         self.parentarray.mngselection.mask_condition(curop, curcond, curopvalue, curcondvalue)
-        self.parentarray.reset_plot()
-        pass
+        self.refresh_array()
+
+    def OnManageVectors(self, event:wx.MouseEvent):
+        """ Open vector manager  """
 
-    def OnManageVectors(self, event):
         if self.mapviewer is not None:
             if self.mapviewer.linked:
                 if self.mapviewer.link_shareopsvect:
@@ -1572,7 +1898,9 @@ class Ops_Array(wx.Frame):
 
         self.myzones.showstructure()
 
-    def OnLoadvec(self, event):
+    def OnLoadvec(self, event:wx.MouseEvent):
+        """ Load vector file """
+
         dlg = wx.FileDialog(None, 'Select file',
                             wildcard='Vec file (*.vec)|*.vec|Vecz file (*.vecz)|*.vecz|Dxf file (*.dxf)|*.dxf|All (*.*)|*.*', style=wx.FD_OPEN)
 
@@ -1585,15 +1913,18 @@ class Ops_Array(wx.Frame):
         dlg.Destroy()
         self.myzones = Zones(self.fnsave, parent=self)
 
+        # Link the same vector manager to all the linked arrays
+        #FIXME : only works if the active_array is the good one
         if self.mapviewer is not None:
             if self.mapviewer.linked:
                 if not self.mapviewer.linkedList is None:
-                    for curFrame in self.mapviewer.linkedList:
-                        if curFrame.link_shareopsvect:
-                            curFrame.active_array.myops.myzones = self.myzones
-                            curFrame.active_array.myops.fnsave = self.fnsave
+                    for curViewer in self.mapviewer.linkedList:
+                        if curViewer.link_shareopsvect:
+                            curViewer.active_array.myops.myzones = self.myzones
+                            curViewer.active_array.myops.fnsave = self.fnsave
 
-    def OnSaveasvec(self, event):
+    def OnSaveasvec(self, event:wx.MouseEvent):
+        """ Save vector file """
 
         dlg = wx.FileDialog(None, 'Select file', wildcard='Vec file (*.vec)|*.vec|Vecz file (*.vecz)|*.vecz|All (*.*)|*.*', style=wx.FD_SAVE)
 
@@ -1607,49 +1938,64 @@ class Ops_Array(wx.Frame):
 
         self.myzones.saveas(self.fnsave)
 
+        # Link the same vector manager to all the linked arrays
+        #FIXME : only works if the active_array is the good one
         if self.mapviewer is not None:
             if self.mapviewer.linked:
                 if not self.mapviewer.linkedList is None:
-                    for curFrame in self.mapviewer.linkedList:
-                        if curFrame.link_shareopsvect:
-                            curFrame.active_array.myops.fnsave = self.fnsave
-
-    def OnSavevec(self, event):
+                    for curViewer in self.mapviewer.linkedList:
+                        if curViewer.link_shareopsvect:
+                            curViewer.active_array.myops.fnsave = self.fnsave
 
+    def OnSavevec(self, event:wx.MouseEvent):
+        """ Save vector file """
         if self.fnsave == '':
             return
 
         self.myzones.saveas(self.fnsave)
 
     def select_node_by_node(self):
+        """
+        Select nodes by individual clicks
+
+        Set the right action in the mapviewer who will attend the clicks
+        """
+
         if self.mapviewer is not None:
             self.mapviewer.action = 'select node by node'
             self.mapviewer.active_array = self.parentarray
 
     def select_zone_inside_manager(self):
+        """
+        Select nodes inside the active zone (manager)
+        """
 
         if self.active_zone is None:
-            wx.MessageBox('Please select an active zone !')
+            logging.warning(_('Please select an active zone !'))
             return
 
         for curvec in self.active_zone.myvectors:
             self._select_vector_inside_manager(curvec)
 
     def select_vector_inside_manager(self):
+        """
+        Select nodes inside the active vector (manager)
+        """
         if self.active_vector is None:
-            wx.MessageBox('Please select an active vector !')
+            logging.warning(_('Please select an active vector !'))
             return
 
         self._select_vector_inside_manager(self.active_vector)
 
     def _select_vector_inside_manager(self, vect: vector):
+        """ Select nodes inside a vector or set action to add vertices to a vector by clicks"""
 
-        if len(vect.myvertices) > 2:
+        if vect.nbvertices > 2:
             self.parentarray.mngselection.select_insidepoly(vect)
 
         elif self.mapviewer is not None:
-            if len(vect.myvertices) < 3:
-                wx.MessageBox('Please add points to vector by clicks !')
+            if vect.nbvertices < 3:
+                logging.info(_('Please add points to vector !'))
 
             self.mapviewer.action = 'select by vector inside'
             self.mapviewer.active_array = self.parentarray
@@ -1659,6 +2005,7 @@ class Ops_Array(wx.Frame):
             self.vectmp.add_vertex(firstvert)
 
     def select_zone_under_manager(self):
+        """ Select nodes along the active zone (manager) """
 
         if self.active_zone is None:
             wx.MessageBox('Please select an active zone !')
@@ -1668,6 +2015,7 @@ class Ops_Array(wx.Frame):
             self._select_vector_under_manager(curvec)
 
     def select_vector_under_manager(self):
+        """ Select nodes along the active vector (manager) """
         if self.active_vector is None:
             wx.MessageBox('Please select an active vector !')
             return
@@ -1675,15 +2023,16 @@ class Ops_Array(wx.Frame):
         self._select_vector_under_manager(self.active_vector)
 
     def _select_vector_under_manager(self, vect: vector):
+        """ Select nodes along a vector or set action to add vertices to a vector by clicks """
 
-        if len(vect.myvertices) > 1:
+        if vect.nbvertices > 1:
             self.parentarray.mngselection.select_underpoly(vect)
 
         elif self.mapviewer is not None:
-            if len(vect.myvertices) < 2:
-                wx.MessageBox('Please add points to vector by clicks !')
+            if vect.nbvertices < 2:
+                logging.info(_('Please add points to vector by clicks !'))
 
-            self.mapviewer.action = 'select by vector under'
+            self.mapviewer.action = 'select by vector along'
             self.mapviewer.active_array = self.parentarray
             self.Active_vector(vect)
 
@@ -1691,7 +2040,10 @@ class Ops_Array(wx.Frame):
             self.vectmp.add_vertex(firstvert)
 
     def select_vector_inside_tmp(self):
+        """ Select nodes inside the temporary vector """
+
         if self.mapviewer is not None:
+            logging.info(_('Please add points to vector by clicks !'))
             self.mapviewer.action = 'select by tmp vector inside'
             self.vectmp.reset()
             self.Active_vector(self.vectmp)
@@ -1701,8 +2053,10 @@ class Ops_Array(wx.Frame):
             self.vectmp.add_vertex(firstvert)
 
     def select_vector_under_tmp(self):
+        """ Select nodes along the temporary vector """
         if self.mapviewer is not None:
-            self.mapviewer.action = 'select by tmp vector under'
+            logging.info(_('Please add points to vector by clicks !'))
+            self.mapviewer.action = 'select by tmp vector along'
             self.vectmp.reset()
             self.Active_vector(self.vectmp)
             self.mapviewer.active_array = self.parentarray
@@ -1710,7 +2064,9 @@ class Ops_Array(wx.Frame):
             firstvert = wolfvertex(0., 0.)
             self.vectmp.add_vertex(firstvert)
 
-    def OnLaunchSelect(self, event):
+    def OnLaunchSelect(self, event:wx.MouseEvent):
+        """ Action button """
+
         id = self.selectmethod.GetSelection()
 
         if id == 0:
@@ -1732,23 +2088,24 @@ class Ops_Array(wx.Frame):
             logging.info(_(''))
             self.select_vector_inside_tmp()
         elif id == 4:
-            logging.info(_('Node selection under active vector (manager)'))
+            logging.info(_('Node selection along active vector (manager)'))
             self.select_vector_under_manager()
         elif id == 5:
-            logging.info(_('Node selection under active zone (manager)'))
+            logging.info(_('Node selection along active zone (manager)'))
             self.select_zone_under_manager()
         elif id == 6:
-            logging.info(_('Node selection under temporary vector'))
+            logging.info(_('Node selection along temporary vector'))
             logging.info(_(''))
             logging.info(_('   Choose vector by clicks...'))
             logging.info(_(''))
             self.select_vector_under_tmp()
 
-    def onclose(self, event):
+    def onclose(self, event:wx.MouseEvent):
+        """ Hide the window """
         self.Hide()
 
-    def onshow(self, event):
-
+    def onshow(self, event:wx.MouseEvent):
+        """ Show the window - set string with null value and update palette """
         if self.parentarray.nullvalue == np.nan:
             self.txt_nullval.Value = 'nan'
         else :
@@ -1756,7 +2113,9 @@ class Ops_Array(wx.Frame):
 
         self.update_palette()
 
-    def Active_vector(self, vect: vector, copyall=True):
+    def Active_vector(self, vect: vector, copyall:bool=True):
+        """ Set the active vector to vect and forward to mapviewer """
+
         if vect is None:
             return
         self.active_vector = vect
@@ -1768,24 +2127,33 @@ class Ops_Array(wx.Frame):
         if self.mapviewer is not None and copyall:
             self.mapviewer.Active_vector(vect)
 
-    def Active_zone(self, zone):
-        self.active_zone = zone
+    def Active_zone(self, target_zone:zone):
+        """ Set the active zone to target_zone and forward to mapviewer """
+        self.active_zone = target_zone
         if self.mapviewer is not None:
-            self.mapviewer.Active_zone(zone)
+            self.mapviewer.Active_zone(target_zone)
 
     def update_palette(self):
+        """
+        Update palette
+
+        Redraw the palette with Matplotlib and fill the grid with the values and RGB components
+        """
         self.Palette.add_ax()
         fig, ax = self.Palette.get_fig_ax()
         self.parentarray.mypal.plot(fig, ax)
         fig.canvas.draw()
         self.parentarray.mypal.fillgrid(self.palgrid)
 
-    def Onsavepal(self, event):
+    def Onsavepal(self, event:wx.MouseEvent):
+        """ Save palette to file """
+
         myarray: WolfArray
         myarray = self.parentarray
         myarray.mypal.savefile()
 
-    def Onloadpal(self, event):
+    def Onloadpal(self, event:wx.MouseEvent):
+        """ Load palette from file """
         myarray: WolfArray
         myarray = self.parentarray
         myarray.mypal.readfile()
@@ -1793,17 +2161,16 @@ class Ops_Array(wx.Frame):
         myarray.mypal.automatic = False
         self.palauto.SetValue(0)
 
-        myarray.reset_plot()
-        # myarray.updatepalette(0)
-        # myarray.delete_lists()
-        self.update_palette()
+        self.refresh_array()
 
-    def Onpalimage(self, event):
+    def Onpalimage(self, event:wx.MouseEvent):
+        """ Create image from palette """
         myarray: WolfArray
         myarray = self.parentarray
         myarray.mypal.export_image()
 
-    def Onpaldistribute(self, event):
+    def Onpaldistribute(self, event:wx.MouseEvent):
+        """ Distribute values in palette """
         myarray: WolfArray
         myarray = self.parentarray
         myarray.mypal.distribute_values()
@@ -1811,12 +2178,10 @@ class Ops_Array(wx.Frame):
         myarray.mypal.automatic = False
         self.palauto.SetValue(0)
 
-        myarray.reset_plot()
-        # myarray.updatepalette(0)
-        # myarray.delete_lists()
-        self.update_palette()
+        self.refresh_array()
 
-    def Onupdatepal(self, event):
+    def Onupdatepal(self, event:wx.MouseEvent):
+        """ Apply options to palette """
         curarray: WolfArray
         curarray = self.parentarray
 
@@ -1860,10 +2225,10 @@ class Ops_Array(wx.Frame):
                 curarray.shading = True
 
         if dellists:
-            curarray.reset_plot()
-            # curarray.delete_lists()
+            self.refresh_array()
 
     def OnClickHistoUpdate(self, event: wx.Event):
+        """ Create a histogram of the current array """
 
         itemlabel = event.GetEventObject().GetLabel()
         fig, ax = self.histo.get_fig_ax()
@@ -1888,7 +2253,8 @@ class Ops_Array(wx.Frame):
 
         fig.canvas.draw()
 
-    def OnClickColorPal(self, event):
+    def OnClickColorPal(self, event: wx.Event):
+        """ Edit color of a palette item """
 
         gridto = self.palgrid
         k = gridto.GetGridCursorRow()
@@ -1920,51 +2286,71 @@ class Ops_Array(wx.Frame):
 
 class SelectionData():
     """
-    Données sélectionnées par l'utilisateur dans un WolfArray
+    User-selected data in a WolfArray
 
-    Contient deux éléments de stockage :
-        - myselection (list) : sélection courante qui sera perdue en cas reset
-        - selections( dict) : sélection(s) mémorisée(s) pour être exploitée par ex. dans une opération d'interpolation spatiale
-            Ces sélection ne sont perdues qu'en cas de reset général
+    Contains two storage elements :
+        - myselection (list): Current selection which will be lost in the event of a reset
+        - selections( dict): Stored selection(s) to be used, for example, in a spatial interpolation operation.
+                             These selections are only lost in the event of a general reset.
 
-    Les mailles sélectionnées sont stockées via leurs coordonnées sptiales "monde" afin de pouvoir les transférer facilement à d'autres objets
+    The selected nodes are stored using their "world" spatial coordinates so that they can be easily transferred to other objects.
     """
-    myselection: list
-    selections: dict
+    myselection:list[tuple[float, float]]
+    selections: dict[str:dict['select':list[tuple[float, float]], 'idgllist':int, 'color':list[float]]]
 
-    def __init__(self, parent) -> None:
+    def __init__(self, parent:"WolfArray") -> None:
         self.parent: WolfArray
         self.parent = parent
 
+        #copy of the resolution
         self.dx = parent.dx
         self.dy = parent.dy
 
         self.myselection = []
         self.selections = {}
-        self.update_plot_selection = False
+
+        self.update_plot_selection = False # force to update OpenGL list if True
         self.hideselection = False
-        self.numlist_select = 0
+        self.numlist_select = 0 # OpenGL list index
 
-    def move_selectionto(self, idx, color):
-        """Transfert de la sélection courante dans un dictionnaire"""
+    def move_selectionto(self, idx:str, color:list[float]):
+        """
+        Transfer current selection to dictionary
+
+        :param idx: id/key of the selection
+        :param color: color of the selection - list of 3 floats between 0 and 255
+        """
+
+        assert len(color) == 3, "color must be a list of 3 floats between 0 and 255"
+
+        # force idx to be a string
         idtxt = str(idx)
         self.selections[idtxt] = {}
         curdict = self.selections[idtxt]
 
         curdict['select'] = self.myselection
-        curdict['idgllist'] = 0
-        self.myselection = []
-        self.update_nb_nodes_sections()
+        curdict['idgllist'] = 0 # will be created later - index of OpenGL list
         curdict['color'] = color
 
+        self.myselection = []   # reset current selection
+        self.update_nb_nodes_sections()
+
     def plot_selection(self):
+        """ Plot current selection and stored selections """
 
+        # Make a copy of the current value of the flag because it will be modified in the function _plot_selection
+        # So, if we want to update the plot, we need to apply the flag on each selection (current ans stored)
         update_select = self.update_plot_selection
+
         if self.myselection != 'all':
+            # plot current selection in RED if not 'all'
             if len(self.myselection) > 0:
-                self.numlist_select = self._plot_selection(self.myselection, (1., 0., 0.), self.numlist_select)
+                self.numlist_select = self._plot_selection(self.myselection,
+                                                           (1., 0., 0.),
+                                                           self.numlist_select)
 
         if len(self.selections) > 0:
+            # plot stored selections
             for cur in self.selections.values():
                 if cur['select'] != 'all':
                     self.update_plot_selection = update_select
@@ -1974,8 +2360,16 @@ class SelectionData():
                                                             float(col[2]) / 255.),
                                                            cur['idgllist'])
 
-    def _plot_selection(self, curlist, color, loclist=0):
+    def _plot_selection(self, curlist:list[float], color:list[float], loclist:int=0):
+        """
+        Plot a selection
+
+        :param curlist: list of selected nodes -- list of tuples (x,y)
+        :param color: color of the selection - list of 3 floats between 0 and 1
+        :param loclist: index of OpenGL list
+        """
 
+        #FIXME : Is it a good idea to use SHADER rather than list ?
         if self.update_plot_selection:
             if loclist != 0:
                 glDeleteLists(loclist, 1)
@@ -2020,22 +2414,41 @@ class SelectionData():
 
         return loclist
 
-    def add_node_to_selection(self, x, y, verif=True):
-        """Ajout d'une coordonnée à la sélection"""
+    def add_node_to_selection(self, x:float, y:float, verif:bool=True):
+        """
+        Add one coordinate to the selection
+
+        :param x: x coordinate
+        :param y: y coordinate
+        :param verif: if True, the coordinates are checked to avoid duplicates
+        """
+
         # on repasse par les i,j car les coordonnées transférées peuvent venir d'un click souris
         # le but est de ne conserver que les coordonnées des CG de mailles
         i, j = self.parent.get_ij_from_xy(x, y)
         self.add_node_to_selectionij(i, j, verif)
 
-    def add_nodes_to_selection(self, xy, verif=True):
-        """Ajout d'une liste de coordonnées à la sélection"""
+    def add_nodes_to_selection(self, xy:list[float], verif:bool=True):
+        """
+        Add multiple coordinates to the selection
+
+        :param xy: list of coordinates
+        :param verif: if True, the coordinates are checked to avoid duplicates
+        """
+
         # on repasse par les i,j car les coordonnées transférées peuvent venir d'un click souris
         # le but est de ne conserver que les coordonnées des CG de mailles
         ij = [self.parent.get_ij_from_xy(x, y) for x, y in xy]
         self.add_nodes_to_selectionij(ij, verif)
 
-    def add_node_to_selectionij(self, i, j, verif=True):
-        """Ajout d'un couple d'indices à la sélection"""
+    def add_node_to_selectionij(self, i:int, j:int, verif=True):
+        """
+        Add one ij coordinate to the selection
+
+        :param i: i coordinate
+        :param j: j coordinate
+        :param verif: if True, the coordinates are checked to avoid duplicates
+        """
         x1, y1 = self.parent.get_xy_from_ij(i, j)
 
         if verif:
@@ -2050,8 +2463,14 @@ class SelectionData():
         else:
             self.myselection.append((x1, y1))
 
-    def add_nodes_to_selectionij(self, ij, verif=True):
-        """Ajout d'une liste de couples d'indices à la sélection"""
+    def add_nodes_to_selectionij(self, ij:list[tuple[float, float]], verif:bool=True):
+        """
+        Add multiple ij coordinates to the selection
+
+        :param ij: list of ij coordinates
+        :param verif: if True, the coordinates are checked to avoid duplicates
+        """
+
         if len(ij)==0:
             logging.info(_('Nothing to do in add_nodes_to_selectionij !'))
             return
@@ -2081,6 +2500,7 @@ class SelectionData():
                 self.myselection = np.unique(self.myselection, axis=0)
 
     def select_insidepoly(self, myvect: vector):
+        """ Select nodes inside a polygon """
 
         nbini = len(self.myselection)
 
@@ -2100,6 +2520,7 @@ class SelectionData():
         self.update_nb_nodes_sections()
 
     def select_underpoly(self, myvect: vector):
+        """ Select nodes along a polyline """
 
         nbini = len(self.myselection)
 
@@ -2147,6 +2568,29 @@ class SelectionData():
         array = self.parent.array
         nbini = len(self.myselection)
 
+        if array.dtype == np.float32:
+            condval = np.float32(condval)
+            condval2 = np.float32(condval2)
+        elif array.dtype == np.float64:
+            condval = np.float64(condval)
+            condval2 = np.float64(condval2)
+        elif array.dtype == np.int32:
+            condval = np.int32(condval)
+            condval2 = np.int32(condval2)
+        elif array.dtype == np.int64:
+            condval = np.int64(condval)
+            condval2 = np.int64(condval2)
+        elif array.dtype == np.int16:
+            condval = np.int16(condval)
+            condval2 = np.int16(condval2)
+        elif array.dtype == np.int8:
+            condval = np.int8(condval)
+            condval2 = np.int8(condval2)
+        else:
+            logging.error(_('Unknown dtype in treat_select !'))
+            return
+
+
         if usemask :
             mask=np.logical_not(array.mask)
             if nbini == 0:
@@ -2310,6 +2754,29 @@ class SelectionData():
                 return np.isnan(val)
 
         array = self.parent.array
+
+        if array.dtype == np.float32:
+            opval = np.float32(opval)
+            condval = np.float32(condval)
+        elif array.dtype == np.float64:
+            opval = np.float64(opval)
+            condval = np.float64(condval)
+        elif array.dtype == np.int32:
+            opval = np.int32(opval)
+            condval = np.int32(condval)
+        elif array.dtype == np.int64:
+            opval = np.int64(opval)
+            condval = np.int64(condval)
+        elif array.dtype == np.int16:
+            opval = np.int16(opval)
+            condval = np.int16(condval)
+        elif array.dtype == np.int8:
+            opval = np.int8(opval)
+            condval = np.int8(condval)
+        else:
+            logging.error(_('Unknown dtype in treat_select !'))
+            return
+
         if self.myselection == 'all':
             if op == 0:
                 if cond == 0:
@@ -2437,6 +2904,10 @@ class SelectionData():
                     ind = np.argwhere(np.logical_and(np.isnan(array), np.logical_not(array.mask)))
                     array[ind[:, 0], ind[:, 1]] = opval
         else:
+            if len(self.myselection) == 0:
+                logging.info(_('Nothing to do in treat_select ! -- PLease select some nodes'))
+                return
+
             ij = [self.parent.get_ij_from_xy(cur[0], cur[1]) for cur in self.myselection]
 
             if op == 0:
@@ -2461,9 +2932,13 @@ class SelectionData():
                         array.data[i, j] = opval
 
         self.parent.mask_data(self.parent.nullvalue)
+
+        self.refresh_parantarray()
+
+    def refresh_parantarray(self):
+        """ Refresh the parent array after a selection """
+
         self.parent.reset_plot()
-        if self.parent.mapviewer is not None:
-            self.parent.mapviewer.Refresh()
 
     def mask_condition(self, op, cond, opval, condval):
         # operationChoices = [ u"+", u"-", u"*", u"/", u"replace'" ]
@@ -2483,6 +2958,29 @@ class SelectionData():
                 return np.isnan(val)
 
         array = self.parent.array
+
+        if array.dtype == np.float32:
+            opval = np.float32(opval)
+            condval = np.float32(condval)
+        elif array.dtype == np.float64:
+            opval = np.float64(opval)
+            condval = np.float64(condval)
+        elif array.dtype == np.int32:
+            opval = np.int32(opval)
+            condval = np.int32(condval)
+        elif array.dtype == np.int64:
+            opval = np.int64(opval)
+            condval = np.int64(condval)
+        elif array.dtype == np.int16:
+            opval = np.int16(opval)
+            condval = np.int16(condval)
+        elif array.dtype == np.int8:
+            opval = np.int8(opval)
+            condval = np.int8(condval)
+        else:
+            logging.error(_('Unknown dtype in treat_select !'))
+            return
+
         if self.myselection == 'all':
             if cond == 0:
                 # <
@@ -2553,8 +3051,6 @@ class SelectionData():
         myhead.nbx = int((ex - myhead.origx) / array.dx)
         myhead.nby = int((ey - myhead.origy) / array.dy)
 
-        myhead.nbdims=2
-
         return myhead
 
     def get_newarray(self):
@@ -2613,7 +3109,8 @@ class WolfArray(Element_To_Draw, header_wolf):
                  srcheader=None,                    # initialize dimension from header_wolf instance
                  idx:str = '',                      # indentity --> required by the mapviewer
                  plotted:bool = False,              # True = will be plotted if required by the mapviewer
-                 need_for_wx:bool = False           # True = a wxApp is required (if no application is underway --> Error)
+                 need_for_wx:bool = False,          # True = a wxApp is required (if no application is underway --> Error)
+                 mask_source:np.ndarray = None,     # mask to link to the data
                  ) -> None:
 
         Element_To_Draw.__init__(self, idx, plotted, mapviewer, need_for_wx)
@@ -2629,7 +3126,6 @@ class WolfArray(Element_To_Draw, header_wolf):
         self.linkedarrays = []
 
         self.filename = ''
-        self.nbdims = 2
         self.isblock = False
         self.blockindex = 0
         self.wolftype = whichtype
@@ -2686,17 +3182,22 @@ class WolfArray(Element_To_Draw, header_wolf):
 
             self.head_blocks = header.head_blocks.copy()
 
-            # FIXME Why not initialize with nullvalue ?
-            self.array = ma.MaskedArray(np.ones((self.nbx, self.nby), order='F', dtype=self.dtype))
+            self.allocate_ressources()
+
+            # # FIXME Why not initialize with nullvalue ?
+            # self.array = ma.MaskedArray(np.ones((self.nbx, self.nby), order='F', dtype=self.dtype))
 
         if fname is not None:
-            self.filename = fname
+
+            self.filename = str(fname)
             self.read_all()
-            if masknull and self.preload:
+
+            if mask_source is not None:
+                self.copy_mask_log(mask_source)
+            elif masknull and self.preload:
                 self.mask_data(self.nullvalue)
 
         elif mold is not None:
-            self.nbdims = mold.nbdims
             self.nbx = mold.nbx
             self.nby = mold.nby
             self.nbz = mold.nbz
@@ -2726,12 +3227,11 @@ class WolfArray(Element_To_Draw, header_wolf):
         self.add_ops_sel() # Ajout d'un gestionnaire de sélection et d'opérations
 
     def show_properties(self):
-        """ Affichage des propriétés de la matrice """
+        """ Affichage des propriétés de la matrice dans une fenêtre wxPython """
         if self.wx_exists and self.myops is not None:
             self.myops.SetTitle(_('Operations on array: ') + self.idx)
             self.myops.Show()
 
-
     @property
     def dtype(self):
         """
@@ -2763,6 +3263,14 @@ class WolfArray(Element_To_Draw, header_wolf):
         return dtype
 
     def loadnap_and_apply(self):
+        """
+        Load a mask file (aka nap) and apply it to the array;
+
+        The mask values are set to the nullvalue.
+
+        The mask file must have the same name as the array file, with the extension .napbin.
+        It is useful for 2D WOLF simulations.
+        """
 
         file_name, file_extension = os.path.splitext(self.filename)
         fnnap = file_name + '.napbin'
@@ -2772,8 +3280,7 @@ class WolfArray(Element_To_Draw, header_wolf):
             self.array.data[np.where(locnap.array.mask)] = self.nullvalue
             self.mask_data(self.nullvalue)
 
-            if self.mapviewer is not None:
-                self.reset_plot()
+            self.reset_plot()
 
     def add_crosslinked_array(self, newlink:"WolfArray"):
         """Ajout d'une matrice liée croisée"""
@@ -2796,17 +3303,19 @@ class WolfArray(Element_To_Draw, header_wolf):
         if self.linkedvec is not None:
             self.mask_outsidepoly(self.linkedvec)
 
-        if self.mapviewer is not None:
-            self.reset_plot()
+        self.reset_plot()
 
-    def export_geotif(self,outdir='',extent = ''):
+    def export_geotif(self, outdir='', extent = ''):
         """
-        Export de la matrice au format Geotiff
+        Export de la matrice au format Geotiff (Lambert 72 - EPSG:31370)
 
         Formats supportés :
             - Int32
             - Float32
             - Float64
+
+        :param outdir: directory
+        :param extent: suffix to add to the filename before the extension '.tif'
         """
         from osgeo import gdal, osr, gdalconst
 
@@ -2849,7 +3358,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         band.FlushCache()
         band.ComputeStatistics(True)
 
-    def import_geotif(self, fn:str='', which = None, crop=None):
+    def import_geotif(self, fn:str='', which:int = None, crop:list[float]=None):
         """
         Import de la matrice au format Geotiff
 
@@ -2857,6 +3366,10 @@ class WolfArray(Element_To_Draw, header_wolf):
             - Int32
             - Float32
             - Float64
+
+        :param fn: filename
+        :param which: band to import
+        :param crop: crop the data - [xmin, xmax, ymin, ymax]
         """
         from osgeo import gdal, osr, gdalconst
 
@@ -2968,7 +3481,13 @@ class WolfArray(Element_To_Draw, header_wolf):
     def change_gui(self, newparentgui):
         """
         Move GUI to another instance
+
+        :param newparentgui: WolfMapViewer instance
         """
+
+        from .PyDraw import WolfMapViewer
+        assert isinstance(newparentgui, WolfMapViewer), _('newparentgui must be a WolfMapViewer instance')
+
         self.wx_exists = wx.App.Get() is not None
 
         if self.mapviewer is None:
@@ -3020,7 +3539,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         plt.show()
 
     def compare_tri(self,mytri:Triangulation):
-
+        """ Graphique de comparaison des valeurs d'un nuage de points et des valeurs de la matrice sous les mêmes positions """
         xyz_cloud = mytri.pts
         zarray = np.array([self.get_value(curxy[0],curxy[1]) for curxy in xyz_cloud])
 
@@ -3055,7 +3574,7 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         plt.show()
 
-    def interpolate_on_cloud(self, xy, z, method='linear'):
+    def interpolate_on_cloud(self, xy:np.ndarray, z:np.ndarray, method='linear'):
         """
         See : https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.griddata.html
 
@@ -3216,8 +3735,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         self.reset_plot()
         return
 
-    def import_from_gltf(self, fn='', fnpos='', interp_method = 'matplotlib'):
-
+    def import_from_gltf(self, fn:str='', fnpos:str='', interp_method:Literal['matplotlib','numpy'] = 'matplotlib'):
         """
         interp_method == 'matplotlib' or 'griddata'
         """
@@ -3274,7 +3792,13 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         self.reset_plot()
 
-    def export_to_gltf(self, bounds=None, fn=''):
+    def export_to_gltf(self, bounds:list[float]=None, fn:str=''):
+        """
+        Export to GLTF/GLB format
+
+        :param bounds: [[xmin,xmax],[ymin,ymax]]
+        :param fn: filename
+        """
 
         mytri, znull = self.get_triangulation(bounds)
         mytri.export_to_gltf(fn)
@@ -3321,7 +3845,12 @@ class WolfArray(Element_To_Draw, header_wolf):
             f.write(str(bounds[1][1]) + '\n')
             f.write(str(znull))
 
-    def get_triangulation(self, bounds=None):
+    def get_triangulation(self, bounds:list[float]=None):
+        """
+        Traingulation of the array
+
+        :param bounds: [[xmin,xmax],[ymin,ymax]]
+        """
 
         if bounds is None:
             ox = self.origx + self.translx
@@ -3376,7 +3905,9 @@ class WolfArray(Element_To_Draw, header_wolf):
         mytri = Triangulation(pts = points, tri = triangles)
         return mytri, znull
 
-    def hillshade(self, azimuth, angle_altitude):
+    def hillshade(self, azimuth:float, angle_altitude:float):
+        """ Create a hillshade array """
+
         azimuth = 360.0 - azimuth
 
         x, y = np.gradient(self.array)
@@ -3395,6 +3926,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         self.shaded.delete_lists()
 
     def get_gradient_norm(self):
+        """ Compute and return the norm of the gradient """
 
         mygradient = WolfArray(mold=self)
 
@@ -3405,6 +3937,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         return mygradient
 
     def get_laplace(self):
+        """ Compute and return the laplacian """
         mylap = WolfArray(mold=self)
         mylap.array = ma.asarray(laplace(self.array) / self.dx ** 2.)
         mylap.array.mask = self.array.mask
@@ -3412,6 +3945,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         return mylap
 
     def volume_estimation(self, axs=None):
+        """ Estimation of the volume of the selected zone """
 
         vect = self.array[np.logical_not(self.array.mask)].flatten()
         zmin = np.amin(vect)
@@ -3534,7 +4068,9 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         return axs
 
-    def paste_all(self, fromarray):
+    def paste_all(self, fromarray:"WolfArray"):
+        """ Paste all the values from another WolfArray """
+
         fromarray: WolfArray
 
         i1, j1 = self.get_ij_from_xy(fromarray.origx, fromarray.origy)
@@ -3560,8 +4096,14 @@ class WolfArray(Element_To_Draw, header_wolf):
         self.mask_data(self.nullvalue)
         self.reset_plot()
 
-    def set_values_sel(self, xy, z,update=True):
+    def set_values_sel(self, xy:list[float], z:list[float], update:bool=True):
+        """
+        Set values at the selected positions
 
+        :param xy: [[x1,y1],[x2,y2],...]
+        :param z: [z1,z2,...]
+        :param update: update the plot
+        """
         sel = np.asarray(xy)
 
         if len(sel) == 1:
@@ -3574,8 +4116,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         else:
             ijall = np.asarray(self.get_ij_from_xy(sel[:, 0], sel[:, 1])).transpose()
 
-            useful = np.where(
-                (ijall[:, 0] >= 0) & (ijall[:, 0] < self.nbx) & (ijall[:, 1] >= 0) & (ijall[:, 1] < self.nby))
+            useful = np.where((ijall[:, 0] >= 0) & (ijall[:, 0] < self.nbx) & (ijall[:, 1] >= 0) & (ijall[:, 1] < self.nby))
 
             self.array[ijall[useful, 0], ijall[useful, 1]] = z[useful]
 
@@ -3585,6 +4126,10 @@ class WolfArray(Element_To_Draw, header_wolf):
             self.reset_plot()
 
     def init_from_new(self, dlg: NewArray):
+        """
+        Initialize the array properties from the NewArray dialog
+        """
+
         self.dx = float(dlg.dx.Value)
         self.dy = float(dlg.dy.Value)
         self.nbx = int(dlg.nbx.Value)
@@ -3595,7 +4140,16 @@ class WolfArray(Element_To_Draw, header_wolf):
         self.array = ma.MaskedArray(np.ones((self.nbx, self.nby), order='F', dtype=np.float32))
         self.mask_reset()
 
-    def init_from_header(self, myhead: header_wolf, dtype:np.dtype = None):
+    def init_from_header(self, myhead: header_wolf, dtype:np.dtype = None, force_type_from_header:bool=False):
+        """
+        Initialize the array properties from a header_wolf object
+
+        :param myhead: header_wolf object
+        :param dtype: numpy dtype
+        :param force_type_from_header: force the type from the header passed as argument
+        """
+        if force_type_from_header:
+            self.wolftype = myhead.wolftype
 
         if dtype is None:
             if self.wolftype == WOLF_ARRAY_FULL_DOUBLE:
@@ -3619,11 +4173,15 @@ class WolfArray(Element_To_Draw, header_wolf):
         self.array = ma.MaskedArray(np.ones((self.nbx, self.nby), order='F', dtype=dtype))
         self.mask_reset()
 
-    def interpolation2D(self):
+    def interpolation2D(self, key:str='1'):
+        """ Interpolation 2D basde on selected points in key 1 """
+
+        #FIXME : auhtorize interpolation on other keys
 
-        if '1' in self.mngselection.selections.keys():
+        key = str(key)
+        if key in self.mngselection.selections.keys():
             if len(self.mngselection.myselection)>0:
-                curlist = self.mngselection.selections['1']['select']
+                curlist = self.mngselection.selections[key]['select']
                 cursel = self.mngselection.myselection
                 if len(curlist) > 0:
                     ij = [self.get_ij_from_xy(cur[0], cur[1]) for cur in curlist]
@@ -3645,60 +4203,98 @@ class WolfArray(Element_To_Draw, header_wolf):
 
                     self.reset_plot()
 
-    def copy_mask(self, source:"WolfArray", forcenullvalue= False):
+    def copy_mask(self, source:"WolfArray", forcenullvalue:bool= False, link:bool=True):
+        """
+        Copy/Link the mask from another WolfArray
+
+        :param source: WolfArray source
+        :param forcenullvalue: force nullvalue in the masked zone
+        :param link: link the mask if True (default), copy it otherwise
+        """
+
+        assert self.shape == source.shape, _('Bad shape')
 
         if forcenullvalue:
             self.array[np.where(source.array.mask)] = self.nullvalue
 
-        self.array.mask = source.array.mask
+        if link:
+            self.array.mask = source.array.mask
+        else:
+            self.array.mask = source.array.mask.copy()
+
         self.nbnotnull = source.nbnotnull
 
-        if self.plotted:
-            self.reset_plot()
+        self.reset_plot()
 
-    def count(self):
-        self.nbnotnull = self.array.count()
+    def mask_union(self, source:"WolfArray", link:bool=True):
+        """
+        Union of the mask with another WolfArray
 
-    def mask_union(self, source:"WolfArray"):
+        :param source: WolfArray source
+        :param link: link the mask if True (default), copy it otherwise
+        """
 
         union = self.array.mask & source.array.mask
 
-        self.array[(~union) & (self.array.mask)] = 0.
-        source.array[(~union) & (source.array.mask)] = 0.
+        self.array[(~union) & (self.array.mask)] = self.nullvalue
+        source.array[(~union) & (source.array.mask)] = self.nullvalue
 
-        self.array.mask = union
-        source.array.mask = union
 
-        self.count()
+        if link:
+            self.array.mask = union
+            source.array.mask = union
+        else:
+            self.array.mask = union.copy()
+            source.array.mask = union.copy()
 
-        if self.plotted:
-            self.reset_plot()
+        self.reset_plot()
+        source.reset_plot()
 
-    def copy_mask_log(self,mask):
-        self.array.mask = mask
-        self.count()
+    def copy_mask_log(self, mask:np.ndarray, link:bool=True):
+        """
+        Copy the mask from a numpy array
 
-        if self.plotted:
-            self.reset_plot()
+        :param mask: numpy array
+        :param link: link the mask if True (default), copy it otherwise
+        """
+        assert self.shape == mask.shape, _('Bad shape')
+
+        if link:
+            self.array.mask = mask
+        else:
+            self.array.mask = mask.copy()
+
+        self.reset_plot()
 
     def check_plot(self):
+        """ Make sure the array is plotted """
+
         self.plotted = True
 
         if not self.loaded and self.filename != '':
+            # if not loaded, load it
             self.read_data()
             if self.masknull:
-                self.mask_data(0.)
+                self.mask_data(self.nullvalue)
 
         self.loaded = True
 
         if self.rgb is None:
             self.updatepalette(0)
 
-    def uncheck_plot(self, unload=True, forceresetOGL=False, askquestion=True):
+    def uncheck_plot(self, unload:bool=True, forceresetOGL:bool=False, askquestion:bool=True):
+        """
+        Make sure the array is not plotted
+
+        :param unload: unload the data if True (default), keep it otherwise
+        :param forceresetOGL: force the reset of the OpenGL lists
+        :param askquestion: ask the question if True and a wx App is running (default), don't ask it otherwise
+        """
+
         self.plotted = False
 
         if unload and self.filename != '':
-            if askquestion:
+            if askquestion and self.wx_exists:
                 dlg = wx.MessageDialog(None,
                                     _('Do you want to unload data? \n If YES, the data will be reloaded from file once checekd \n If not saved, modifications will be lost !!'),
                                     style=wx.YES_NO)
@@ -3714,7 +4310,7 @@ class WolfArray(Element_To_Draw, header_wolf):
                 return
 
         if not forceresetOGL:
-            if askquestion:
+            if askquestion and self.wx_exists:
                 dlg = wx.MessageDialog(None, _('Do you want to reset OpenGL lists?'), style=wx.YES_NO)
                 ret = dlg.ShowModal()
                 if ret == wx.ID_YES:
@@ -3724,7 +4320,13 @@ class WolfArray(Element_To_Draw, header_wolf):
             self.delete_lists()
             self.rgb = None
 
-    def get_header(self, abs=True) -> header_wolf:
+    def get_header(self, abs:bool=True) -> header_wolf:
+        """
+        Return a header_wolf object - different from the self object header
+
+        :param abs: if True (default), return an absolute header (shifted origin) and translation set to 0.
+        """
+
         curhead = header_wolf()
 
         curhead.origx = self.origx
@@ -3745,7 +4347,7 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         curhead.head_blocks = self.head_blocks.copy()
 
-        curhead.nbdims = self.nbdims
+        curhead.wolftype = self.wolftype
 
         if abs:
             curhead.origx += curhead.translx
@@ -3758,6 +4360,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         return curhead
 
     def set_header(self, header: header_wolf):
+        """ Set the header from a header_wolf object """
         self.origx = header.origx
         self.origy = header.origy
         self.origz = header.origz
@@ -3774,8 +4377,6 @@ class WolfArray(Element_To_Draw, header_wolf):
         self.nby = header.nby
         self.nbz = header.nbz
 
-        self.nbdims = header.nbdims
-
         self.head_blocks = header.head_blocks.copy()
 
         self.add_ops_sel()
@@ -3783,7 +4384,6 @@ class WolfArray(Element_To_Draw, header_wolf):
     def __add__(self, other):
         """Surcharge de l'opérateur d'addition"""
         newArray = WolfArray()
-        newArray.nbdims = self.nbdims
         newArray.nbx = self.nbx
         newArray.nby = self.nby
         newArray.dx = self.dx
@@ -3809,7 +4409,6 @@ class WolfArray(Element_To_Draw, header_wolf):
     def __mul__(self, other):
         """Surcharge de l'opérateur d'addition"""
         newArray = WolfArray()
-        newArray.nbdims = self.nbdims
         newArray.nbx = self.nbx
         newArray.nby = self.nby
         newArray.dx = self.dx
@@ -3835,7 +4434,6 @@ class WolfArray(Element_To_Draw, header_wolf):
     def __sub__(self, other):
         """Surcharge de l'opérateur de soustraction"""
         newArray = WolfArray()
-        newArray.nbdims = self.nbdims
         newArray.nbx = self.nbx
         newArray.nby = self.nby
         newArray.dx = self.dx
@@ -3861,7 +4459,6 @@ class WolfArray(Element_To_Draw, header_wolf):
     def __pow__(self, other):
         """Surcharge de l'opérateur puissance"""
         newArray = WolfArray()
-        newArray.nbdims = self.nbdims
         newArray.nbx = self.nbx
         newArray.nby = self.nby
         newArray.dx = self.dx
@@ -3883,7 +4480,6 @@ class WolfArray(Element_To_Draw, header_wolf):
     def __truediv__(self, other):
         """Surcharge de l'opérateur division"""
         newArray = WolfArray()
-        newArray.nbdims = self.nbdims
         newArray.nbx = self.nbx
         newArray.nby = self.nby
         newArray.dx = self.dx
@@ -3908,6 +4504,11 @@ class WolfArray(Element_To_Draw, header_wolf):
         return newArray
 
     def mask_outsidepoly(self, myvect: vector):
+        """
+        Mask nodes outside a polygon and set values to nullvalue
+
+        :param myvect: target vector in global coordinates
+        """
         # The polygon here is in world coordinates
         # (coord will be converted back with translation, origin and dx/dy)
         # (mesh coord, 0-based)
@@ -3916,7 +4517,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         mask[:,:] = True # Mask everything
 
         # trouve les indices dans le polygone
-        myij = self.get_ij_inside_polygon(myvect,False)
+        myij = self.get_ij_inside_polygon(myvect, False)
         # démasquage des mailles contenues
         mask[myij[:,0],myij[:,1]] = False
         # annulation des valeurs en dehors du polygone
@@ -3932,31 +4533,18 @@ class WolfArray(Element_To_Draw, header_wolf):
         # FIXME This operation seems to contradict mask[:,:] = True
         self.mask_data(self.nullvalue)
 
-    def get_xy_infootprint_vect(self, myvect: vector) -> np.ndarray:
-
-        myptsij = self.get_ij_infootprint_vect(myvect)
-        mypts=np.asarray(myptsij.copy(),dtype=np.float64)
-        mypts[:,0] = (mypts[:,0]+.5)*self.dx +self.origx +self.translx
-        mypts[:,1] = (mypts[:,1]+.5)*self.dy +self.origy +self.transly
-
-        return mypts,myptsij
 
-    def get_ij_infootprint_vect(self, myvect: vector) -> np.ndarray:
-        i1, j1 = self.get_ij_from_xy(myvect.xmin, myvect.ymin)
-        i2, j2 = self.get_ij_from_xy(myvect.xmax, myvect.ymax)
-        i1 = max(i1,0) # FIXME Why ??? How could i,j be negative ?
-        j1 = max(j1,0)
-        i2 = min(i2,self.nbx-1)
-        j2 = min(j2,self.nby-1)
-        xv,yv = np.meshgrid(np.arange(i1,i2+1),np.arange(j1,j2+1))
-        mypts = np.hstack((xv.flatten()[:,np.newaxis],yv.flatten()[:,np.newaxis]))
-
-        return mypts
-
-    def get_xy_inside_polygon(self, myvect: vector, usemask=True):
+    # *************************************************************************************************************************
+    # POSITION and VALUES associated to a vector/polygon/polyline
+    # These functions can not be stored in header_wolf, because wa can use the mask of the array to limit the search
+    # These functions are also present in WolfResults_2D, but they are not exactly the same dur to the structure of the results
+    # *************************************************************************************************************************
+    def get_xy_inside_polygon(self, myvect: vector, usemask:bool=True):
         """
-        Obtention des coordonnées contenues dans un polygone
-         usemask = restreint les éléments aux éléments non masqués de la matrice
+        Return the coordinates inside a polygon
+
+        :param myvect = target vector
+        :param usemask = limit potential nodes to unmaksed nodes
         """
 
         myvect.find_minmax()
@@ -3974,10 +4562,12 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         return mypointsxy
 
-    def get_xy_under_polyline(self, myvect: vector, usemask=True):
+    def get_xy_under_polyline(self, myvect: vector, usemask:bool=True):
         """
-        Obtention des coordonnées contenues sous une polyligne
-         usemask = restreint les éléments aux éléments non masqués de la matrice
+        Return the coordinates along a polyline
+
+        :param myvect = target vector
+        :param usemask = limit potential nodes to unmaksed nodes
         """
 
         allij = self.get_ij_under_polyline(myvect, usemask)
@@ -3985,18 +4575,12 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         return mypoints
 
-    def convert_xy2ij(self,xy):
-        return np.asarray((xy[:,0]-self.origx -self.translx)/self.dx-.5,dtype=np.int32), \
-               np.asarray((xy[:,1]-self.origy -self.transly)/self.dy-.5,dtype=np.int32)
-
-    def convert_ij2xy(self,xy):
-        return np.asarray((xy[:,0]+.5)*self.dx+self.origx +self.translx ,dtype=np.float64), \
-               np.asarray((xy[:,1]+.5)*self.dy+self.origy +self.transly ,dtype=np.float64)
-
-    def get_ij_inside_polygon(self, myvect: vector, usemask=True):
+    def get_ij_inside_polygon(self, myvect: vector, usemask:bool=True):
         """
-        Obtention des indices contenues dans un polygone
-         usemask = restreint les éléments aux éléments non masqués de la matrice
+        Return the indices inside a polygon
+
+        :param myvect = target vector
+        :param usemask = limit potential nodes to unmaksed nodes
         """
 
         myvect.find_minmax()
@@ -4014,10 +4598,12 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         return mypointsij
 
-    def get_ij_under_polyline(self, myvect: vector, usemask=True):
+    def get_ij_under_polyline(self, myvect: vector, usemask:bool=True):
         """
-        Obtention des coordonnées sous une polyligne
-         usemask = restreint les éléments aux éléments non masqués de la matrice
+        Return the indices along a polyline
+
+        :param myvect = target vector
+        :param usedmask = limit potential nodes to unmaksed nodes
         """
 
         ds = min(self.dx, self.dy)
@@ -4033,7 +4619,7 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         return allij
 
-    def get_values_insidepoly(self, myvect: vector, usemask=True, getxy=False):
+    def get_values_insidepoly(self, myvect: vector, usemask:bool=True, getxy:bool=False):
         """
         Récupération des valeurs contenues dans un polygone
 
@@ -4048,7 +4634,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         else:
             return myvalues, None
 
-    def get_values_underpoly(self, myvect: vector, usemask=True, getxy=False):
+    def get_values_underpoly(self, myvect: vector, usemask:bool=True, getxy:bool=False):
         """
         Récupération des valeurs contenues sous une polyligne
 
@@ -4064,7 +4650,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         else:
             return myvalues, None
 
-    def get_all_values_insidepoly(self, myvect: vector, usemask=True, getxy=False):
+    def get_all_values_insidepoly(self, myvect: vector, usemask:bool=True, getxy:bool=False):
         """
         Récupération de toutes les valeurs contenues dans un polygone
 
@@ -4077,7 +4663,7 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         return self.get_values_insidepoly(myvect, usemask,getxy)
 
-    def get_all_values_underpoly(self, myvect: vector, usemask=True, getxy=False):
+    def get_all_values_underpoly(self, myvect: vector, usemask:bool=True, getxy:bool=False):
         """
         Récupération de toutes les valeurs sous la polyligne
 
@@ -4090,22 +4676,29 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         return self.get_values_underpoly(myvect, usemask, getxy)
 
+    # *************************************************************************************************************************
+    # END POSITION and VALUES associated to a vector/polygon/polyline
+    # *************************************************************************************************************************
+
     def reset(self):
-        # FIXME Shouldn't it be self.nullvalue  instead of zero ?
+        """ Reset the array to nullvalue """
+
         if self.nbdims == 2:
-            self.array[:, :] = 0.0
+            self.array[:, :] = self.nullvalue
         elif self.nbdims == 3:
-            self.array[:, :, :] = 0.0
+            self.array[:, :, :] = self.nullvalue
 
     def allocate_ressources(self):
         """ Memory Allocation according to dtype/wolftype"""
+
         if self.nbdims == 2:
-            self.array = ma.ones([self.nbx, self.nby], dtype=self.dtype)
+            self.array = ma.ones([self.nbx, self.nby], order='F', dtype=self.dtype)
         elif self.nbdims == 3:
-            self.array = ma.ones([self.nbx, self.nby, self.nbz], dtype=self.dtype)
+            self.array = ma.ones([self.nbx, self.nby, self.nbz], order='F', dtype=self.dtype)
 
     def read_all(self, which_band = None):
         """ Lecture d'un Wolf aray depuis le nom de fichier """
+
         if not os.path.exists(self.filename):
             if self.wx_exists:
                 logging.warning(_('No data file : ')+self.filename)
@@ -4162,8 +4755,15 @@ class WolfArray(Element_To_Draw, header_wolf):
                 self.loaded = True
         return
 
-    def write_all(self, newpath = None):
-        """ Ecriture de tous les fichiers d'un Wolf array """
+    def write_all(self, newpath:str = None):
+        """ 
+        Ecriture de tous les fichiers d'un Wolf array 
+        
+        :param newpath: path and filename with extension
+        """
+        
+        if isinstance(newpath, Path):
+            newpath = str(newpath)
 
         if newpath is not None:
             self.filename = newpath
@@ -4227,7 +4827,6 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         super().read_txt_header(self.filename)
 
-
     def write_txt_header(self):
         """
         Write header to txt file
@@ -4321,6 +4920,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         self.loaded = True
 
     def _read_binary_data(self, f, seek=0):
+        """ Read binary data from file """
 
         if seek > 0:
             f.seek(0)
@@ -4353,13 +4953,15 @@ class WolfArray(Element_To_Draw, header_wolf):
         """ Ecriture du tableau en binaire """
         self.array.data.transpose().tofile(self.filename, "")
 
-    def write_xyz(self, fname):
+    def write_xyz(self, fname:str):
         """ Ecriture d un fichier xyz avec toutes les données du Wolf Array """
         my_file = XYZFile(fname)
         my_file.fill_from_wolf_array(self)
         my_file.write_to_file()
 
-    def get_xyz(self, which='all'):
+    def get_xyz(self, which='all') -> np.ndarray:
+        """ Return an array of xyz coordinates and values """
+
         x1, y1 = self.get_xy_from_ij(0, 0)
         x2, y2 = self.get_xy_from_ij(self.nbx, self.nby, aswolf=True)
         xloc = np.linspace(x1, x2, self.nbx)
@@ -4372,25 +4974,45 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         return xyz[filter]
 
-    def set_general_frame_from_xyz(self, fname, dx, dy):
-        """ Lecture d'un fichier xyz et initialisation des données de base """
+    def set_general_frame_from_xyz(self, fname:str, dx:float, dy:float, border_size:int=5):
+        """
+        Lecture d'un fichier texte xyz et initialisation des données de base
+
+        :param fname: nom du fichier xyz
+        :param dx: pas en x
+        :param dy: pas en y
+        :param border_size: nombre de mailles de bordure en plus de l'extension spatiale du fichier
+        """
+
         my_file = XYZFile(fname)
         my_file.read_from_file()
         (xlim, ylim) = my_file.get_extent()
 
         self.dx = dx
         self.dy = dy
-        self.origx = m.floor(xlim[0]) - 5.0 * self.dx
-        self.origy = m.floor(ylim[0]) - 5.0 * self.dy
-        self.nbx = int((m.floor(xlim[1]) - m.ceil(xlim[0])) / self.dx) + 10
-        self.nby = int((m.floor(ylim[1]) - m.ceil(ylim[0])) / self.dy) + 10
+        self.origx = m.floor(xlim[0]) - float(border_size) * self.dx
+        self.origy = m.floor(ylim[0]) - float(border_size) * self.dy
+        self.nbx = int((m.floor(xlim[1]) - m.ceil(xlim[0])) / self.dx) + 2*border_size
+        self.nby = int((m.floor(ylim[1]) - m.ceil(ylim[0])) / self.dy) + 2*border_size
 
         self.array = np.ma.zeros((self.nbx, self.nby))
         return my_file
 
-    def fillin_from_xyz(self, xyz):
-
-        self.array.data[self.get_ij_from_xy(xyz[:, 0], xyz[:, 1])] = np.float32(xyz[:, 2])
+    def fillin_from_xyz(self, xyz:np.ndarray):
+        """ Remplissage du tableau à partir d'un tableau xyz """
+
+        if self.dtype == np.float32:
+            self.array.data[self.get_ij_from_xy(xyz[:, 0], xyz[:, 1])] = np.float32(xyz[:, 2])
+        elif self.dtype == np.float64:
+            self.array.data[self.get_ij_from_xy(xyz[:, 0], xyz[:, 1])] = np.float64(xyz[:, 2])
+        elif self.dtype == np.int32:
+            self.array.data[self.get_ij_from_xy(xyz[:, 0], xyz[:, 1])] = np.int32(xyz[:, 2])
+        elif self.dtype == np.int16:
+            self.array.data[self.get_ij_from_xy(xyz[:, 0], xyz[:, 1])] = np.int16(xyz[:, 2])
+        elif self.dtype == np.int8:
+            self.array.data[self.get_ij_from_xy(xyz[:, 0], xyz[:, 1])] = np.int8(xyz[:, 2])
+        else:
+            logging.warning(_('Type not supported : ')+str(self.dtype))
 
     def mask_force_null(self):
         """
@@ -4398,8 +5020,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         """
         self.mask_reset()
         self.mask_data(self.nullvalue)
-        if self.plotted:
-            self.reset_plot()
+        self.reset_plot()
 
     def unmask(self):
         """ alias to mask_reset """
@@ -4413,7 +5034,6 @@ class WolfArray(Element_To_Draw, header_wolf):
         """
         Unmask everything
         """
-        # FIXME For WolfArray_Sim2D, this is strange since that class is there to share a mask...
 
         if self.nbdims == 2:
             # FIXME if WolfArray_Sim2D mask linking should work
@@ -4421,19 +5041,29 @@ class WolfArray(Element_To_Draw, header_wolf):
             # to avoid replacing the linked mask by a (non linked) one.
 
             if isinstance(self.array.mask, np.bool_):
+                # mask is not an array, but a single boolean value
                 self.array.mask = np.zeros(self.array.shape)
             else:
                 self.array.mask.fill(False) # False == not masked
+
             self.nbnotnull = self.nbx * self.nby
+
         elif self.nbdims == 3:
-            self.array.mask = np.zeros((self.nbx, self.nby, self.nbz))
+            if isinstance(self.array.mask, np.bool_):
+                self.array.mask = np.zeros((self.nbx, self.nby, self.nbz))
+            else:
+                self.array.mask.fill(False) # False == not masked
+
             self.nbnotnull = self.nbx * self.nby * self.nbz
 
     def count(self):
+        """ Count the number of not masked values """
+
         self.nbnotnull = self.array.count()
         return self.nbnotnull
 
     def mask_data(self, value):
+        """ Mask cell where values are equal to `value`"""
         if self.array is None:
             return
 
@@ -4441,10 +5071,22 @@ class WolfArray(Element_To_Draw, header_wolf):
             value=int(value)
 
         if value is not None:
-            if np.isnan(value) or math.isnan(value):
-                self.array.mask = np.isnan(self.array.data)
+
+            if isinstance(self.array.mask, np.bool_):
+                # mask is not an array, but a single boolean value
+                # we must create a new mask array
+                if np.isnan(value) or math.isnan(value):
+                    self.array.mask = np.isnan(self.array.data)
+                else:
+                    self.array.mask = self.array.data == value
             else:
-                self.array.mask = self.array.data == value
+                # Copy to prevent unlinking the mask (see `mask_reset`)
+                if np.isnan(value) or math.isnan(value):
+                    np.copyto(self.array.mask, np.isnan(self.array.data))
+                    # self.array.mask[:,:] = np.isnan(self.array.data)
+                else:
+                    np.copyto(self.array.mask, self.array.data == value)
+                    # self.array.mask[:,:] = self.array.data == value
         self.count()
 
     def mask_lower(self, value):
@@ -4457,6 +5099,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         self.count()
 
     def mask_lowerequal(self, value):
+        """ Mask cell where values are lower or equal than `value`"""
         if self.array is None:
             return
 
@@ -4465,22 +5108,30 @@ class WolfArray(Element_To_Draw, header_wolf):
         self.count()
 
     def set_nullvalue_in_mask(self):
+        """ Set nullvalue in masked cells """
         if self.array is None:
             return
         self.array.data[self.array.mask] = self.nullvalue
 
     def reset_plot(self, whichpal=0, mimic=True):
-        self.delete_lists()
-
-        if mimic:
-            for cur in self.linkedarrays:
-                if id(cur.mypal) == id(self.mypal) and id(self) !=id(cur):
-                    cur.reset_plot(whichpal=whichpal, mimic=False)
+        """ Reset plot of the array """
 
         self.count()
-        self.updatepalette(whichpal)
+        if self.plotted:
+            self.delete_lists()
+
+            if mimic:
+                for cur in self.linkedarrays:
+                    if id(cur.mypal) == id(self.mypal) and id(self) !=id(cur):
+                        cur.reset_plot(whichpal=whichpal, mimic=False)
+
+            self.updatepalette(whichpal)
+
+            if self.mapviewer is not None:
+                self.mapviewer.Refresh()
 
     def mask_allexceptdata(self, value):
+        """ Mask cell where values are different from `value`"""
         if self.array is None:
             return
 
@@ -4489,13 +5140,20 @@ class WolfArray(Element_To_Draw, header_wolf):
         self.count()
 
     def mask_invert(self):
+        """ Invert the mask """
         if self.array is None:
             return
         # Copy to prevent unlinking the mask (see `mask_reset`)
         np.copyto(self.array.mask, np.logical_not(self.array.mask))
         self.count()
 
-    def meshgrid(self, mode='gc'):
+    def meshgrid(self, mode:Literal['gc', 'borders']='gc'):
+        """
+        Création d'un maillage 2D
+
+        :param mode: 'gc' pour les centres de mailles, 'borders' pour les bords de mailles
+        """
+
         x_start = self.translx + self.origx
         y_start = self.transly + self.origy
         if mode == 'gc':
@@ -4508,22 +5166,41 @@ class WolfArray(Element_To_Draw, header_wolf):
         y, x = np.meshgrid(y_discr, x_discr)
         return x, y
 
-    def crop(self, i_start, j_start, nbx, nby, k_start=1, nbz=1):
-        # FIXME Sanitize parameters
+    def crop(self, i_start:int, j_start:int, nbx:int, nby:int, k_start:int=1, nbz:int=1):
+        """
+        Crop the array
+
+        :param i_start: start index in x
+        :param j_start: start index in y
+        :param nbx: number of cells in x
+        :param nby: number of cells in y
+        :param k_start: start index in z
+        :param nbz: number of cells in z
+
+        :return: cropped array, WolfArray instance
+        """
+
+        assert type(i_start) == int, "i_start must be an integer"
+        assert type(j_start) == int, "j_start must be an integer"
+        assert type(nbx) == int, "nbx must be an integer"
+        assert type(nby) == int, "nby must be an integer"
+        assert type(k_start) == int, "k_start must be an integer"
+        assert type(nbz) == int, "nbz must be an integer"
+
         newWolfArray = WolfArray()
         newWolfArray.nbx = nbx
         newWolfArray.nby = nby
         newWolfArray.dx = self.dx
         newWolfArray.dy = self.dy
-        newWolfArray.origx = self.origx + i_start * self.dx
-        newWolfArray.origy = self.origy + j_start * self.dy
+        newWolfArray.origx = self.origx + float(i_start) * self.dx
+        newWolfArray.origy = self.origy + float(j_start) * self.dy
         newWolfArray.translx = self.translx
         newWolfArray.transly = self.transly
 
         if self.nbdims == 3:
             newWolfArray.nbz = nbz
             newWolfArray.dz = self.dz
-            newWolfArray.origz = self.origz + k_start * self.dz
+            newWolfArray.origz = self.origz + float(k_start) * self.dz
             newWolfArray.translz = self.translz
 
             newWolfArray.array = self.array[i_start:i_start + nbx, j_start:j_start + nby, k_start:k_start + nbz]
@@ -4532,64 +5209,32 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         return newWolfArray
 
-    def extremum(self, which='min'):
+    def extremum(self, which:Literal['min','max']='min'):
+        """ Return the extremum value """
+
         if which == 'min':
             my_extr = np.amin(self.array)
-        else:
+        elif which == 'max':
             my_extr = np.amax(self.array)
-
-        return my_extr
-
-    def get_bounds(self, abs=True):
-        if abs:
-            return ([self.origx + self.translx, self.origx + self.translx + float(self.nbx) * self.dx],
-                    [self.origy + self.transly, self.origy + self.transly + float(self.nby) * self.dy])
         else:
-            return ([self.origx, self.origx + float(self.nbx) * self.dx],
-                    [self.origy, self.origy + float(self.nby) * self.dy])
-
-    def find_intersection(self, other, ij=False):
-
-        mybounds = self.get_bounds()
-        otherbounds = other.get_bounds()
-
-        if otherbounds[0][0] > mybounds[0][1]:
-            return None
-        elif otherbounds[1][0] > mybounds[1][1]:
-            return None
-        elif otherbounds[0][1] < mybounds[0][0]:
-            return None
-        elif otherbounds[1][1] < mybounds[0][1]:
-            return None
-        else:
-            ox = max(mybounds[0][0], otherbounds[0][0])
-            oy = max(mybounds[1][0], otherbounds[1][0])
-            ex = min(mybounds[0][1], otherbounds[0][1])
-            ey = min(mybounds[1][1], otherbounds[1][1])
-            if ij:
-                i1, j1 = self.get_ij_from_xy(ox, oy)
-                i2, j2 = self.get_ij_from_xy(ex, ey)
+            logging.warning(_('Extremum not supported : ')+which)
+            my_extr = -99999.
 
-                i3, j3 = other.get_ij_from_xy(ox, oy)
-                i4, j4 = other.get_ij_from_xy(ex, ey)
-                return ([[i1, i2], [j1, j2]],
-                        [[i3, i4], [j3, j4]])
-            else:
-                return ([ox, ex], [oy, ey])
-
-    def find_union(self, other):
-
-        mybounds = self.get_bounds()
-        otherbounds = other.get_bounds()
+        return my_extr
 
-        ox = min(mybounds[0][0], otherbounds[0][0])
-        oy = min(mybounds[1][0], otherbounds[1][0])
-        ex = max(mybounds[0][1], otherbounds[0][1])
-        ey = max(mybounds[1][1], otherbounds[1][1])
+    def get_value(self, x:float, y:float, z:float=0., nullvalue:float=-99999):
+        """
+        Return the value at given coordinates
 
-        return ([ox, ex], [oy, ey])
+        :param x: x coordinate
+        :param y: y coordinate
+        :param z: z coordinate
+        :param nullvalue: value to return if the point is outside the array
+        """
 
-    def get_value(self, x, y, z=0., nullvalue=-99999):
+        if isinstance(self.array.mask, np.bool_):
+            logging.error(_('Mask is not an array - Please check your data'))
+            return nullvalue
 
         if self.nbdims == 2:
             i, j = self.get_ij_from_xy(x, y)
@@ -4600,6 +5245,7 @@ class WolfArray(Element_To_Draw, header_wolf):
                     value = self.array[i, j]
             else:
                 value = nullvalue
+
         elif self.nbdims == 3:
             i, j, k = self.get_ij_from_xy(x, y, z)
             if i >= 0 and i < self.nbx and j >= 0 and j < self.nby and k >= 0 and k < self.nbz:
@@ -4611,11 +5257,20 @@ class WolfArray(Element_To_Draw, header_wolf):
             else:
                 value = nullvalue
 
+        #FIXME : forcing to convert to float is not a good idea
         return float(value)
 
-    def get_xlim(self, window_x, window_y):
-        a_x = window_x / (self.nbx * self.dx)
-        a_y = window_y / (self.nby * self.dy)
+    def get_xlim(self, window_x:float, window_y:float):
+        """
+        Return the limits in x for a given window size
+
+        :param window_x: window size in x
+        :param window_y: window size in y
+        """
+
+        a_x = window_x / (float(self.nbx) * self.dx)
+        a_y = window_y / (float(self.nby) * self.dy)
+
         if a_x < a_y:
             # C'est la mise à l'échelle selon x qui compte
             return (self.origx + self.translx, self.origx + self.translx + self.nbx * self.dx)
@@ -4625,9 +5280,15 @@ class WolfArray(Element_To_Draw, header_wolf):
             return (self.origx + self.translx + self.nbx * self.dx * 0.5 - l * 0.5,
                     self.origx + self.translx + self.nbx * self.dx * 0.5 + l * 0.5)
 
-    def get_ylim(self, window_x, window_y):
-        a_x = window_x / (self.nbx * self.dx)
-        a_y = window_y / (self.nby * self.dy)
+    def get_ylim(self, window_x:float, window_y:float):
+        """
+        Retrun the limits in y for a given window size
+
+        :param window_x: window size in x
+        :param window_y: window size in y
+        """
+        a_x = window_x / (float(self.nbx) * self.dx)
+        a_y = window_y / (float(self.nby) * self.dy)
         if a_x < a_y:
             # C'est la mise à l'échelle selon x qui compte
             l = (self.nbx * self.dx) / window_x * window_y
@@ -4637,7 +5298,13 @@ class WolfArray(Element_To_Draw, header_wolf):
             # C'est la mise à l'échelle selon y qui compte
             return (self.origy + self.transly, self.origy + self.transly + self.nby * self.dy)
 
-    def get_working_array(self, onzoom=[]):
+    def get_working_array(self, onzoom:list[float]=[]):
+        """
+        Return the part of the array in the zoom window
+
+        :param onzoom: zoom window -- [xmin, xmax, ymin, ymax]
+        """
+
         if onzoom != []:
             istart, jstart = self.get_ij_from_xy(onzoom[0], onzoom[2])
             iend, jend = self.get_ij_from_xy(onzoom[1], onzoom[3])
@@ -4653,7 +5320,13 @@ class WolfArray(Element_To_Draw, header_wolf):
         else:
             return self.array[self.array.mask == False]
 
-    def updatepalette(self, which=0, onzoom=[]):
+    def updatepalette(self, which:int=0, onzoom=[]):
+        """
+        Update the palette/colormap
+
+        :param which: which palette to update
+        :param onzoom: zoom window -- [xmin, xmax, ymin, ymax]
+        """
 
         if self.array is None:
             return
@@ -4677,10 +5350,21 @@ class WolfArray(Element_To_Draw, header_wolf):
         self.rgb[self.array.mask] = [1., 1., 1., 1.]
 
         if self.myops is not None:
+            # update the wx
             self.myops.update_palette()
 
-    def plot(self, sx=None, sy=None, xmin=None, ymin=None, xmax=None, ymax=None, size=None):
-
+    def plot(self, sx:float=None, sy:float=None, xmin:float=None, ymin:float=None, xmax:float=None, ymax:float=None, size:float=None):
+        """
+        Plot the array - OpenGL
+
+        :param sx: scale along X
+        :param sy: scale along Y
+        :param xmin: Lower-Left coordinates in X
+        :param ymin: Lower-Left coordinates in Y
+        :param xmax: Upper-Right coordinates in X
+        :param ymax: Upper-Right coordinates in Y
+        :param size: size of the window (not used here but necessary for compatibility with Element_To_Draw)
+        """
         if not self.plotted:
             return
 
@@ -4781,6 +5465,8 @@ class WolfArray(Element_To_Draw, header_wolf):
             self.myops.myzones.plot()
 
     def delete_lists(self):
+        """ Delete OpenGL lists """
+
         for idx, cursize in enumerate(self.mygrid):
             curlist = self.mygrid[cursize]
             nbx = curlist['nbx']
@@ -4793,8 +5479,13 @@ class WolfArray(Element_To_Draw, header_wolf):
         self.gridmaxscales = -1
 
     def plot_matplotlib(self):
+        """
+        Plot the array - Matplotlib version
+
+        Using imshow and RGB array
+        """
 
-        self.mask_data(0.)
+        self.mask_data(self.nullvalue)
         self.updatepalette(0)
 
         fig = plt.figure()
@@ -4807,6 +5498,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         plt.show()
 
     def fillonecellgrid(self, curscale, loci, locj, force=False):
+        """ Fill one cell of the plotted grid """
 
         cursize = curscale  # 2**curscale
 
@@ -4863,14 +5555,14 @@ class WolfArray(Element_To_Draw, header_wolf):
 
             curlist['done'][loci, locj] = 1
 
-    def suxsuy_contour(self, filename='', abs=False) -> tuple[list[int,int], list[int,int], vector, bool]:
+    def suxsuy_contour(self, filename:str='', abs:bool=False) -> tuple[list[int,int], list[int,int], vector, bool]:
         """
         The borders are computed on basis of the current *mask*
 
-        @param filename : if provided, write 'sux', 'sux' and 'xy' files
-        @param abs : add translation coordinates (Global World Coordinates)
+        :param filename : if provided, write 'sux', 'sux' and 'xy' files
+        :param abs : add translation coordinates (Global World Coordinates)
 
-        @return indicesX, indicesY, contourgen, interior
+        :return indicesX, indicesY, contourgen, interior
 
         indicesX : list of coupled indices along X - vertical border - 1-based like Fortran
         indicesY : list of coupled indices along Y - horizontal border - 1-based like Fortran
@@ -5058,6 +5750,8 @@ class WolfArray(Element_To_Draw, header_wolf):
                 return WOLF_ARRAY_FULL_SINGLE
             elif curarray.dtype == np.int32:
                 return WOLF_ARRAY_FULL_INTEGER
+            elif curarray.dtype == np.int8:
+                return WOLF_ARRAY_FULL_INTEGER8
 
         self.array = np.ma.array(array.copy())
         self.wolftype = wolftype_from_npz(array)
@@ -5066,6 +5760,20 @@ class WolfArray(Element_To_Draw, header_wolf):
             self.nullvalue = nullvalue
         self.mask_data(self.nullvalue)
         self.reset_plot()
+
+    def nullify_border(self, width:int = 1):
+        """
+        Set border to nullvalue
+        """
+        self.array.data[:width,:] = self.nullvalue
+        self.array.data[-width:,:] = self.nullvalue
+        self.array.data[:,:width] = self.nullvalue
+        self.array.data[:,-width:] = self.nullvalue
+
+        self.array.mask[:width,:] = True
+        self.array.mask[-width:,:] = True
+        self.array.mask[:,:width] = True
+        self.array.mask[:,-width:] = True
 class WolfArrayMB(WolfArray):
     """
     Matrice multiblocks
@@ -5080,7 +5788,7 @@ class WolfArrayMB(WolfArray):
                  create=False, mapviewer=None, nullvalue=0, srcheader=None):
         self.myblocks = {}
         super().__init__(fname, mold, masknull, crop, whichtype, preload, create, mapviewer, nullvalue, srcheader)
-        self.wolftype = WOLF_ARRAY_MB_SINGLE
+        # self.wolftype = whichtype
 
     def __getitem__(self, block_key:Union[int,str]) -> WolfArray:
         """Access a block of this multi-blocks array."""
@@ -5094,13 +5802,31 @@ class WolfArrayMB(WolfArray):
         else:
             return None
 
-    def add_block(self, arr: WolfArray):
-        """ Adds a properly configured block this multiblock.
-        The index/key must already be set on `arr`.
+    def add_block(self, arr: WolfArray, force_idx:bool=False, copy_array=False):
+        """ 
+        Adds a properly configured block this multiblock.
+        
+        :param arr: The block to add.
+        :param force_idx: If True, the index/key will be set on `arr`. If False, the index/key must already be set on `arr`.
         """
-        assert arr.idx is not None and type(arr.idx) == str and arr.idx.strip() != '', f"The block index/key is wrong {arr.idx}"
-        assert arr.idx not in self.myblocks, "You can't have the same block twice"
+
+        if copy_array:
+            arr = WolfArray(mold=arr)
+            force_idx = True
+
+        if force_idx:
+            arr.idx = getkeyblock(len(self.myblocks))
+        else:
+            assert arr.idx is not None and type(arr.idx) == str and arr.idx.strip() != '', f"The block index/key is wrong {arr.idx}"
+            assert arr.idx not in self.myblocks, "You can't have the same block twice"
+            pos = len(self.myblocks)
+            posidx = decodekeyblock(arr.idx, False)
+            assert pos == posidx, f"The block index/key is wrong {arr.idx}"
+        
         self.myblocks[arr.idx] = arr
+        
+        arr.isblock = True
+        arr.blockindex = len(self.myblocks) - 1
 
     def share_palette(self):
         """Partage de la palette de couleurs entre matrices liées"""
@@ -5109,7 +5835,8 @@ class WolfArrayMB(WolfArray):
                 cur.mypal = self.mypal
                 cur.link_palette()
 
-    def copy_mask(self, source:"WolfArrayMB", forcenullvalue= False):
+    def copy_mask(self, source:"WolfArrayMB", forcenullvalue:bool= False):
+        """ Copy the mask of two arrays """
 
         if isinstance(self, type(source)):
             if self.check_consistency(source):
@@ -5118,8 +5845,11 @@ class WolfArrayMB(WolfArray):
                     curblock.copy_mask(curblockother, forcenullvalue)
                     i+=1
                 self.reset_plot()
+        else:
+            logging.warning(_('Copy mask not supported between different types of arrays'))
 
     def count(self):
+        """ Count the number of not null cells """
 
         self.nbnotnull = 0
         for i in range(self.nb_blocks):
@@ -5130,6 +5860,8 @@ class WolfArrayMB(WolfArray):
             self.nbnotnull += nbnotnull
 
     def check_plot(self):
+        """ Check plot and apply to each block """
+
         self.plotted = True
         self.mimic_plotdata()
 
@@ -5137,7 +5869,7 @@ class WolfArrayMB(WolfArray):
             if os.path.exists(self.filename):
                 self.read_data()
                 if self.masknull:
-                    self.mask_data(0.)
+                    self.mask_data(self.nullvalue)
                 if self.rgb is None:
                     self.rgb = np.ones((self.nbx, self.nby, 4), order='F', dtype=np.integer)
                 self.updatepalette(0)
@@ -5145,33 +5877,69 @@ class WolfArrayMB(WolfArray):
             else:
                 raise Exception(_(f"Trying to load an array that doesn't exist ({self.filename})"))
 
-    def uncheck_plot(self, unload=True, forceresetOGL=False, askquestion=True):
+    def uncheck_plot(self, unload:bool=True, forceresetOGL:bool=False, askquestion:bool=True):
+        """ Uncheck plot and apply to each block """
+
         self.plotted = False
         self.mimic_plotdata()
 
         if unload and self.filename != '':
             if askquestion and not forceresetOGL:
-                dlg = wx.MessageDialog(None, _('Do you want to reset OpenGL lists?'), style=wx.YES_NO)
-                ret = dlg.ShowModal()
-                if ret == wx.ID_YES:
+                if self.wx_exists:
+                    dlg = wx.MessageDialog(None, _('Do you want to reset OpenGL lists?'), style=wx.YES_NO)
+                    ret = dlg.ShowModal()
+                    if ret == wx.ID_YES:
                         forceresetOGL = True
+                else:
+                    forceresetOGL = True
 
             for curblock in self.myblocks.values():
                 curblock.uncheck_plot(unload, forceresetOGL, askquestion=False)
                 self.rgb = None
+
             self.myblocks = {}
             self.loaded = False
 
     def mask_data(self, value):
-        for i in range(self.nb_blocks):
-            curblock = self.myblocks[getkeyblock(i)]
-            curarray = curblock.array
-            curarray.mask = curarray.data == value
+        """ Mask cells where values are equal to `value`"""
 
-        self.count()
+        if self.wolftype in [WOLF_ARRAY_FULL_INTEGER, WOLF_ARRAY_FULL_INTEGER16]:
+            value=int(value)
+
+        if value is not None:
+
+            for curblock in self.myblocks.values():
+                curarray = curblock.array
+
+                if isinstance(curarray.mask, np.bool_):
+                    # mask is not an array, but a single boolean value
+                    # we must create a new mask array
+                    if np.isnan(value) or math.isnan(value):
+                        curarray.mask = np.isnan(curarray.data)
+                    else:
+                        curarray.mask = curarray.data == value
+                else:
+                    # Copy to prevent unlinking the mask (see `mask_reset`)
+                    if np.isnan(value) or math.isnan(value):
+                        np.copyto(curarray.mask, np.isnan(curarray.data))
+                    else:
+                        np.copyto(curarray.mask, curarray.data == value)
+
+            self.count()
+
+        # for i in range(self.nb_blocks):
+        #     curblock = self.myblocks[getkeyblock(i)]
+        #     curarray = curblock.array
+        #     curarray.mask = curarray.data == value
+
+        # self.count()
 
     def mask_union(self, source:"WolfArrayMB"):
+        """
+        Union of the masks of two arrays
 
+        Applying for each block iteratively.
+        """
         if isinstance(self, type(source)):
             if self.check_consistency(source):
                 i=0
@@ -5181,14 +5949,22 @@ class WolfArrayMB(WolfArray):
                 self.reset_plot()
 
     def read_data(self):
+        """ Lecture du tableau en binaire """
+
         with open(self.filename, 'rb') as f:
             for i in range(self.nb_blocks):
-                curblock = WolfArray(whichtype=WOLF_ARRAY_FULL_SINGLE)
+                
+                if self.wolftype == WOLF_ARRAY_MB_SINGLE:
+                    curblock = WolfArray(whichtype=WOLF_ARRAY_FULL_SINGLE, srcheader=self.head_blocks[getkeyblock(i)])
+                elif self.wolftype == WOLF_ARRAY_MB_INTEGER:
+                    curblock = WolfArray(whichtype=WOLF_ARRAY_FULL_INTEGER)
+
                 curblock.isblock = True
                 curblock.blockindex = i
                 curblock.idx = getkeyblock(i)
-                curblock.set_header(self.head_blocks[getkeyblock(i)])
+
                 curblock._read_binary_data(f)
+                
                 self.myblocks[getkeyblock(i)] = curblock
 
     def write_array(self):
@@ -5199,9 +5975,31 @@ class WolfArrayMB(WolfArray):
                 f.write(curarray.array.data.transpose().tobytes())
 
     def get_ij_from_xy(self, x:float, y:float, z:float=0., scale:float=1., aswolf:bool=False, abs:bool=True, which_block:int=1):
+        """
+        alias for get_ij_from_xy for the block `which_block
+
+        :param x: x coordinate
+        :param y: y coordinate
+        :param z: z coordinate
+        :param scale: scale factor
+        :param aswolf: if True, then the indices are 1-based like Fortran, otherwise 0-based like Python
+        :param abs: if True, then the translation is taken into account
+        :param which_block: block index 1-based
+        """
         return self.myblocks[getkeyblock(which_block, False)].get_ij_from_xy(x, y, z, scale, aswolf, abs)
 
-    def get_values_as_wolf(self, i, j, which_block=1):
+    def get_values_as_wolf(self, i:int, j:int, which_block:int=1):
+        """
+        Return the value at indices (i,j) of the block `which_block.
+
+        :param i: i index
+        :param j: j index
+        :param which_block: block index 1-based
+        """
+        h = np.NaN
+        if which_block == 0:
+            logging.warning("Block index is probably 0-based. It should be 1-based.")
+            return h
 
         keyblock = getkeyblock(which_block, False)
         curblock = self.myblocks[keyblock]
@@ -5214,13 +6012,20 @@ class WolfArrayMB(WolfArray):
 
         return h
 
-    def get_value(self, x, y, abs=True):
-        """ Read the value at world coordinate (x,y). if `abs` is
+    def get_value(self, x:float, y:float, abs:bool=True):
+        """
+        Read the value at world coordinate (x,y). if `abs` is
         given, then the translation is is taken into account.
 
         If no block covers the coordinate, then np.NaN is returned
         If several blocks cover the given coordinate then the first
         match is returned (and thus, the others are ignored).
+
+        :param x: x coordinate
+        :param y: y coordinate
+        :param abs: if True, then the translation is taken into account
+
+        :return: the value at (x,y) or np.NaN if no block covers the coordinate
         """
 
         h = np.NaN
@@ -5238,13 +6043,37 @@ class WolfArrayMB(WolfArray):
 
         return h
 
-    def get_xy_from_ij(self, i, j, which_block, aswolf=False, abs=True):
+    def get_xy_from_ij(self, i:int, j:int, which_block:int, aswolf:bool=False, abs:bool=True):
+        """
+        Return the world coordinates (x,y) of the indices (i,j) of the block `which_block.
+
+        :param i: i index -- 1-based like Fortran or 0-based like Python, see 'aswolf' parameter
+        :param j: j index -- 1-based like Fortran or 0-based like Python, see 'aswolf' parameter
+        :param which_block: block index 1-based
+        :param aswolf: if True, (i,j) are 1-based like Fortran, otherwise 0-based like Python
+        :param abs: if True, then the translation is taken into account
+        """
+
+        if which_block == 0:
+            logging.warning("Block index is probably 0-based. It should be 1-based.")
+            return
+
         k = getkeyblock(which_block, False)
         assert k in self.myblocks, f"The block '{k}' you ask for doesn't exist."
+
         x, y = self.myblocks[k].get_xy_from_ij(i, j, aswolf=aswolf, abs=abs)
         return x, y
 
-    def get_blockij_from_xy(self, x, y, abs=True):
+    def get_blockij_from_xy(self, x:float, y:float, abs:bool=True):
+        """
+        Return the block indices (i,j) of the block covering the world coordinate (x,y)
+
+        :param x: x coordinate
+        :param y: y coordinate
+        :param abs: if True, then the translation is taken into account
+
+        :return: the block indices (i,j,[k]) or (-1,-1,-1) if no block covers the coordinate
+        """
 
         exists = False
         k = 1
@@ -5267,11 +6096,19 @@ class WolfArrayMB(WolfArray):
             return -1, -1, -1
 
     def link_palette(self):
-        """Lie les palettes des blocs à la palette de l'objet parent"""
+        """Lier les palettes des blocs à la palette de l'objet parent"""
+
         for curblock in self.myblocks.values():
             curblock.mypal = self.mypal
 
-    def updatepalette(self, which=0, onzoom=[]):
+    def updatepalette(self, which:int=0, onzoom:list[float]=[]):
+        """
+        Update the palette/colormap of the array
+
+        :param which: which colormap to use
+        :param onzoom: if not empty, then only the values within the zoom are used to update the palette -- [xmin,xmax,ymin,ymax]
+
+        """
 
         if len(self.myblocks) == 0:
             return
@@ -5308,17 +6145,19 @@ class WolfArrayMB(WolfArray):
             self.myops.update_palette()
 
     def delete_lists(self):
+        """ Delete OpenGL lists """
         for curblock in self.myblocks.values():
             curblock.delete_lists()
 
     def mimic_plotdata(self):
+        """ Copy plot flags to children """
         for curblock in self.myblocks.values():
             curblock: WolfArray
             curblock.plotted = self.plotted
             curblock.plotting = self.plotting
 
     def plot(self, sx=None, sy=None, xmin=None, ymin=None, xmax=None, ymax=None):
-
+        """ Plot the array """
         self.plotting = True
         self.mimic_plotdata()
 
@@ -5332,8 +6171,8 @@ class WolfArrayMB(WolfArray):
         for curblock in self.myblocks.values():
             curblock.fillonecellgrid(curscale, loci, locj, force)
 
-    def check_consistency(self,other):
-
+    def check_consistency(self, other):
+        """ Vérifie la cohérence entre deux matrices """
         test = isinstance(self, type(other))
 
         if test:
@@ -5502,6 +6341,7 @@ class WolfArrayMB(WolfArray):
         return newArray
 
     def reset(self):
+        """ Reset each block"""
         for i in range(self.nb_blocks):
             self[i].reset()
 
@@ -5632,7 +6472,19 @@ class WolfArrayMB(WolfArray):
 
         return fig,ax
 
-
+    def allocate_ressources(self):
+        """ Allocate memory ressources """
+
+        if len(self.myblocks)==0:
+            for id, (key, curhead) in enumerate(self.head_blocks.items()):
+                if self.wolftype == WOLF_ARRAY_MB_SINGLE:
+                    self.myblocks[key] = WolfArray(srcheader=curhead, whichtype=WOLF_ARRAY_FULL_SINGLE)
+                elif self.wolftype == WOLF_ARRAY_MB_INTEGER:
+                    self.myblocks[key] = WolfArray(srcheader=curhead, whichtype=WOLF_ARRAY_FULL_INTEGER)
+
+                self.myblocks[key].isblock = True
+                self.myblocks[key].blockindex = id
+                self.myblocks[key].idx = key    
 class WolfArrayMNAP(WolfArrayMB):
     """
     Matrice MNAP d'une modélisation WOLF2D
@@ -5678,8 +6530,6 @@ class WolfArrayMNAP(WolfArrayMB):
                     v : wolfvertex
                     f.write(padf(v.x) + padf(v.y) + "\n")
 
-
-
     def read_data(self):
         if os.path.exists(self.filename + '.mnap'):
             with open(self.filename + '.mnap') as f:
@@ -5778,21 +6628,35 @@ class WolfArray_Sim2D(WolfArray):
     """
     Surcharge de WolfArray pour les matrices fines de simulation
     Objectif :
-        - reporter la matrice de mask depuis une source
+        - lier la matrice de mask à une source commune
     """
-
-    # FIXME Shouldn't we overload mask_reset() since this one
-    # creates a mask of its own ?
-
-    def __init__(self, fname=None, mold=None, masknull=True, crop=None, whichtype=WOLF_ARRAY_FULL_SINGLE, preload=True, create=False, mapviewer=None, nullvalue=0, srcheader=None,masksrc=None):
-        self.masksrc=masksrc
+    def __init__(self,
+                 fname:str=None,
+                 mold:"WolfArray"=None,
+                 masknull:bool=True,
+                 crop:list[float]=None,
+                 whichtype=WOLF_ARRAY_FULL_SINGLE,
+                 preload:bool=True,
+                 create:bool=False,
+                 mapviewer=None,
+                 nullvalue:float=0,
+                 srcheader:header_wolf=None,
+                 masksrc:np.ndarray=None):
+
+        # link to mask source
+        self.masksrc = masksrc
 
         # FIXME __init__ will initialize a mask of its own and so self.masksrc
         # will be ignored at this point. That's misleading, I'd thought
         # that passing a mask would wire it to this array, forever.
-        super().__init__(fname, mold, masknull, crop, whichtype, preload, create, mapviewer, nullvalue, srcheader)
+        super().__init__(fname, mold, masknull, crop, whichtype, preload, create, mapviewer, nullvalue, srcheader, mask_source=masksrc)
 
     def check_plot(self):
+        """
+        Surcharge de la fonction de vérification du plot
+
+        Utile notamment pour lier le masque
+        """
         self.plotted = True
 
         if not self.loaded and self.filename != '':
@@ -5804,7 +6668,7 @@ class WolfArray_Sim2D(WolfArray):
                 return
 
             if self.masksrc is not None:
-                    self.array.mask = self.masksrc
+                self.array.mask = self.masksrc
 
         self.loaded = True
 
@@ -5812,6 +6676,12 @@ class WolfArray_Sim2D(WolfArray):
             self.updatepalette(0)
 
     def read_all(self):
+        """
+        Surcharge de la fonction de lecture de la matrice
+
+        Utile notamment puor le fichier zbin
+        """
+
         if self.filename[-4:]=='zbin':
             fileold = self.filename
 
@@ -5827,6 +6697,11 @@ class WolfArray_Sim2D(WolfArray):
             return super().read_all()
 
     def read_data(self):
+        """
+        Surcharge de la fonction de lecture de la matrice
+
+        Utile notamment puor le fichier zbin
+        """
 
         if self.filename[-4:]=='zbin':
             fileold = self.filename
@@ -5859,6 +6734,11 @@ class WolfArray_Sim2D(WolfArray):
         return super().write_all()
 
     def write_array(self):
+        """
+        Surcharge de la fonction d'écriture de la matrice
+
+        Utile notamment puor le fichier zbin
+        """
         if self.filename[-4:]=='zbin':
             fileold = self.filename