wolfhece 2.0.17__py3-none-any.whl → 2.0.19__py3-none-any.whl

wolfhece/pythonfortran/example_makendarray.py

@@ -2,60 +2,65 @@ import numpy as np
 import ctypes as ct
 from tools import make_nd_array
 
-"""
-Création d'un matrice numpy depui un buffer/adresse mémoire
-"""
 
-a = np.zeros((10,10))
+def main():
+    """
+    Création d'un matrice numpy depui un buffer/adresse mémoire
+    """
 
-# a.ctypes.data => int, buffer's memory address
-# see : https://numpy.org/doc/stable/reference/generated/numpy.ndarray.ctypes.html
-q = make_nd_array(a.ctypes.data, a.shape)
+    a = np.zeros((10,10))
 
-#  récupération de la structure ct.pointer pointant vers l'espace de stockage de l'objet numpy "a"'
-p = a.ctypes.data_as(ct.POINTER(ct.c_double))
-#  récupération de l'adresse mémoire dans la structure ctypes.pointer
-addr_p = list(p.contents._b_base_._objects.values())[0].value
-# mais il y a plus simple ...
-addr_p_2 = ct.addressof(p.contents)
+    # a.ctypes.data => int, buffer's memory address
+    # see : https://numpy.org/doc/stable/reference/generated/numpy.ndarray.ctypes.html
+    q = make_nd_array(a.ctypes.data, a.shape)
 
-assert addr_p == addr_p_2
+    #  récupération de la structure ct.pointer pointant vers l'espace de stockage de l'objet numpy "a"'
+    p = a.ctypes.data_as(ct.POINTER(ct.c_double))
+    #  récupération de l'adresse mémoire dans la structure ctypes.pointer
+    addr_p = list(p.contents._b_base_._objects.values())[0].value
+    # mais il y a plus simple ...
+    addr_p_2 = ct.addressof(p.contents)
 
-#  comparaison avec l'adresse mémoire du buffer de a
-print(addr_p, a.ctypes.data)
-assert a.ctypes.data == addr_p, 'Not the same address'
+    assert addr_p == addr_p_2
 
-c=make_nd_array(addr_p, [10,10], dtype=np.float64, own_data=False, readonly=False, order='F')
-d=make_nd_array(addr_p, [10,10], dtype=np.float64, own_data=True , readonly=False, order='F')
+    #  comparaison avec l'adresse mémoire du buffer de a
+    print(addr_p, a.ctypes.data)
+    assert a.ctypes.data == addr_p, 'Not the same address'
 
-e=make_nd_array(addr_p, [10,10], dtype=np.float64, own_data=False, readonly=True, order='F')
-f=make_nd_array(addr_p, [10,10], dtype=np.float64, own_data=True , readonly=True, order='F')
-g=make_nd_array(addr_p, [10,10], dtype=np.float64, own_data=True , readonly=False, order='F')
+    c=make_nd_array(addr_p, [10,10], dtype=np.float64, own_data=False, readonly=False, order='F')
+    d=make_nd_array(addr_p, [10,10], dtype=np.float64, own_data=True , readonly=False, order='F')
 
-assert c.ctypes.data == a.ctypes.data, 'Not the same address'
-assert d.ctypes.data != a.ctypes.data, 'Same address'
+    e=make_nd_array(addr_p, [10,10], dtype=np.float64, own_data=False, readonly=True, order='F')
+    f=make_nd_array(addr_p, [10,10], dtype=np.float64, own_data=True , readonly=True, order='F')
+    g=make_nd_array(addr_p, [10,10], dtype=np.float64, own_data=True , readonly=False, order='F')
 
-assert e.flags.writeable == False, 'Array "e" is in read/write mode'
-assert f.flags.writeable == False, 'Array "f" is in read/write mode'
-assert g.flags.writeable == True,  'Array "g" is in read only mode'
+    assert c.ctypes.data == a.ctypes.data, 'Not the same address'
+    assert d.ctypes.data != a.ctypes.data, 'Same address'
 
+    assert e.flags.writeable == False, 'Array "e" is in read/write mode'
+    assert f.flags.writeable == False, 'Array "f" is in read/write mode'
+    assert g.flags.writeable == True,  'Array "g" is in read only mode'
 
-# Initialisation d'une Numpy array as 'C' order or 'F' order
-a = np.zeros((10,10), dtype=np.float64, order='C') # default order == 'C'
-a[:,1:]=3.
 
-h=make_nd_array(a.ctypes.data, [10,1], dtype=np.float64, own_data=True , readonly=False, order='F') # première ligne
-# h = [0,3,3,3,3,3,3,3,3,3,3]
+    # Initialisation d'une Numpy array as 'C' order or 'F' order
+    a = np.zeros((10,10), dtype=np.float64, order='C') # default order == 'C'
+    a[:,1:]=3.
 
-assert h.shape==(10,1)
-assert (h == np.asarray([[0.],[3.],[3.],[3.],[3.],[3.],[3.],[3.],[3.],[3.]])).all()
+    h=make_nd_array(a.ctypes.data, [10,1], dtype=np.float64, own_data=True , readonly=False, order='F') # première ligne
+    # h = [0,3,3,3,3,3,3,3,3,3,3]
 
-a = np.zeros((10,10), dtype=np.float64, order='F')
-a[:,1:]=3.
+    assert h.shape==(10,1)
+    assert (h == np.asarray([[0.],[3.],[3.],[3.],[3.],[3.],[3.],[3.],[3.],[3.]])).all()
 
-i=make_nd_array(a.ctypes.data, [10,1], dtype=np.float64, own_data=True , readonly=False, order='F') # première colonne
-# i = [0,0,0,0,0,0,0,0,0,0]
+    a = np.zeros((10,10), dtype=np.float64, order='F')
+    a[:,1:]=3.
 
-assert i.shape==(10,1)
-assert (i == np.asarray([0.,0.,0.,0.,0.,0.,0.,0.,0.,0.])).all()
-assert (i == np.asarray([[0.],[0.],[0.],[0.],[0.],[0.],[0.],[0.],[0.],[0.]])).all()
+    i=make_nd_array(a.ctypes.data, [10,1], dtype=np.float64, own_data=True , readonly=False, order='F') # première colonne
+    # i = [0,0,0,0,0,0,0,0,0,0]
+
+    assert i.shape==(10,1)
+    assert (i == np.asarray([0.,0.,0.,0.,0.,0.,0.,0.,0.,0.])).all()
+    assert (i == np.asarray([[0.],[0.],[0.],[0.],[0.],[0.],[0.],[0.],[0.],[0.]])).all()
+
+if __name__ == '__main__':
+    main()

wolfhece/pythonfortran/example_numpy_memory.py

@@ -2,117 +2,121 @@ import numpy as np
 import ctypes as ct
 from tools import make_nd_array
 
-"""
-Les matrices Numpy gardent-elles le même espace mémoire (buffer) lors des opérations méthématiques ??
-Une tentative d'analyse sur base de quelques exemples simples ...
+def main():
+    """
+    Les matrices Numpy gardent-elles le même espace mémoire (buffer) lors des opérations méthématiques ??
+    Une tentative d'analyse sur base de quelques exemples simples ...
 
-ATTENTION notammment à :
-   - la diférence de comportement entre "a += 3" et "a = a + 3"
-   - la diférence de comportement entre "a[:,:] = a[:,:] + 3" et "a = a + 3"
+    ATTENTION notammment à :
+    - la diférence de comportement entre "a += 3" et "a = a + 3"
+    - la diférence de comportement entre "a[:,:] = a[:,:] + 3" et "a = a + 3"
 
-Lire : https://numpy.org/doc/stable/reference/ufuncs.html
-"""
-a = np.zeros((10,10))
-b = a # b is an alias --> share memory
-c = a.copy() # c is a copy --> not share memory
+    Lire : https://numpy.org/doc/stable/reference/ufuncs.html
+    """
+    a = np.zeros((10,10))
+    b = a # b is an alias --> share memory
+    c = a.copy() # c is a copy --> not share memory
 
-id_a = id(a) # memory address
-id_b = id(b) # memory address
-id_c = id(c) # memory address
+    id_a = id(a) # memory address
+    id_b = id(b) # memory address
+    id_c = id(c) # memory address
 
-if id(b) == id(a):
-    print('1) a vs b - egalize -- Same memory address')
+    if id(b) == id(a):
+        print('1) a vs b - egalize -- Same memory address')
 
-if id(c) != id(a):
-    print('2) a vs c - egalize copy -- Not the same memory address')
+    if id(c) != id(a):
+        print('2) a vs c - egalize copy -- Not the same memory address')
 
-c+=4
-a=c.copy()
-if id_a != id(c):
-    print('3) a vs a (from c) - egalize copy -- Not the same memory address')
+    c+=4
+    a=c.copy()
+    if id_a != id(c):
+        print('3) a vs a (from c) - egalize copy -- Not the same memory address')
 
-# reset
-a=b
+    # reset
+    a=b
 
-a += 3
-id_newa = id(a) # memory address
-if id_newa == id_a:
-    print('4) a vs a - += 3 -- Same memory address')
+    a += 3
+    id_newa = id(a) # memory address
+    if id_newa == id_a:
+        print('4) a vs a - += 3 -- Same memory address')
 
-a[:,:] = a[:,:] + 3
-id_newa = id(a) # memory address
+    a[:,:] = a[:,:] + 3
+    id_newa = id(a) # memory address
 
-if id_newa == id_a:
-    print('5) a vs a - [:,:] + 3 -- Same memory address')
+    if id_newa == id_a:
+        print('5) a vs a - [:,:] + 3 -- Same memory address')
 
-a = a + 3
-id_newa2 = id(a) # memory address
-if id_newa2 != id_a:
-    print('6) a vs new_a_2 - = +3 -- Not the same memory address')
+    a = a + 3
+    id_newa2 = id(a) # memory address
+    if id_newa2 != id_a:
+        print('6) a vs new_a_2 - = +3 -- Not the same memory address')
 
-b = a + 3
-if id(b) != id(a):
-    print('7) a vs b - addition -- Not the same memory address')
+    b = a + 3
+    if id(b) != id(a):
+        print('7) a vs b - addition -- Not the same memory address')
 
-# Adresse mémoire
+    # Adresse mémoire
 
-a = np.zeros((10,10), dtype=np.float64)
-mem_a = a.ctypes.data
-a[:,1:]=3.
-assert mem_a == a.ctypes.data
+    a = np.zeros((10,10), dtype=np.float64)
+    mem_a = a.ctypes.data
+    a[:,1:]=3.
+    assert mem_a == a.ctypes.data
 
 
-# Créez deux matrices numpy distinctes avec des buffers mémoire séparés
-matrix1 = np.array([[1, 2], [3, 4]])
-matrix2 = np.array([[5, 6], [7, 8]])
+    # Créez deux matrices numpy distinctes avec des buffers mémoire séparés
+    matrix1 = np.array([[1, 2], [3, 4]])
+    matrix2 = np.array([[5, 6], [7, 8]])
 
-buf_m1 = matrix1.ctypes.data
-buf_m2 = matrix2.ctypes.data
+    buf_m1 = matrix1.ctypes.data
+    buf_m2 = matrix2.ctypes.data
 
-# Copiez le contenu de matrix1 dans matrix2 (les buffers de matrix2 ne sont pas affectés)
-matrix2[:] = matrix1
+    # Copiez le contenu de matrix1 dans matrix2 (les buffers de matrix2 ne sont pas affectés)
+    matrix2[:] = matrix1
 
-assert buf_m1 == matrix1.ctypes.data
-assert buf_m2 == matrix2.ctypes.data
-assert (matrix1 ==matrix2).all()
+    assert buf_m1 == matrix1.ctypes.data
+    assert buf_m2 == matrix2.ctypes.data
+    assert (matrix1 ==matrix2).all()
 
-matrix1 = np.array([[1, 2], [3, 4]])
-matrix2 = np.array([[5, 6], [7, 8]])
+    matrix1 = np.array([[1, 2], [3, 4]])
+    matrix2 = np.array([[5, 6], [7, 8]])
 
-buf_m1 = matrix1.ctypes.data
-buf_m2 = matrix2.ctypes.data
+    buf_m1 = matrix1.ctypes.data
+    buf_m2 = matrix2.ctypes.data
 
-# Copiez le contenu de matrix1 dans matrix2 (les buffers de matrix2 ne sont pas affectés)
-matrix2[:] = matrix1.copy()
+    # Copiez le contenu de matrix1 dans matrix2 (les buffers de matrix2 ne sont pas affectés)
+    matrix2[:] = matrix1.copy()
 
-assert buf_m1 == matrix1.ctypes.data
-assert buf_m2 == matrix2.ctypes.data
-assert (matrix1 ==matrix2).all()
+    assert buf_m1 == matrix1.ctypes.data
+    assert buf_m2 == matrix2.ctypes.data
+    assert (matrix1 ==matrix2).all()
 
-matrix1 = np.array([[1, 2], [3, 4]])
-matrix2 = np.array([[5, 6], [7, 8]])
+    matrix1 = np.array([[1, 2], [3, 4]])
+    matrix2 = np.array([[5, 6], [7, 8]])
 
-buf_m1 = matrix1.ctypes.data
-buf_m2 = matrix2.ctypes.data
+    buf_m1 = matrix1.ctypes.data
+    buf_m2 = matrix2.ctypes.data
 
-# Copiez le contenu de matrix1 dans matrix2 (les buffers de matrix2 SONT affectés)
-matrix2 = matrix1.copy()
+    # Copiez le contenu de matrix1 dans matrix2 (les buffers de matrix2 SONT affectés)
+    matrix2 = matrix1.copy()
 
-assert buf_m1 == matrix1.ctypes.data
-assert buf_m2 != matrix2.ctypes.data
-assert matrix2.ctypes.data != matrix1.ctypes.data
-assert (matrix1 ==matrix2).all()
+    assert buf_m1 == matrix1.ctypes.data
+    assert buf_m2 != matrix2.ctypes.data
+    assert matrix2.ctypes.data != matrix1.ctypes.data
+    assert (matrix1 ==matrix2).all()
 
-matrix1 = np.array([[1, 2], [3, 4]])
-matrix2 = np.array([[5, 6], [7, 8]])
+    matrix1 = np.array([[1, 2], [3, 4]])
+    matrix2 = np.array([[5, 6], [7, 8]])
 
-buf_m1 = matrix1.ctypes.data
-buf_m2 = matrix2.ctypes.data
+    buf_m1 = matrix1.ctypes.data
+    buf_m2 = matrix2.ctypes.data
 
-# Copiez le contenu de matrix1 dans matrix2 (les buffers de matrix2 SONT affectés)
-matrix2 = matrix1
+    # Copiez le contenu de matrix1 dans matrix2 (les buffers de matrix2 SONT affectés)
+    matrix2 = matrix1
 
-assert buf_m1 == matrix1.ctypes.data
-assert buf_m2 != matrix2.ctypes.data
-assert matrix2.ctypes.data == matrix1.ctypes.data
-assert (matrix1 ==matrix2).all()
+    assert buf_m1 == matrix1.ctypes.data
+    assert buf_m2 != matrix2.ctypes.data
+    assert matrix2.ctypes.data == matrix1.ctypes.data
+    assert (matrix1 ==matrix2).all()
+
+if __name__ == "__main__":
+    main()

wolfhece/pythonfortran/tools.py

@@ -1,4 +1,4 @@
-⁶import numpy as np
+import numpy as np
 import ctypes as ct
 
 

wolfhece/scenario/imposebc_void.py

@@ -24,7 +24,7 @@ class Impose_Boundary_Conditions:
     def impose_bc(self, simul:SimpleSimulation):
         """
         FR
-        --
+
         Cette fonction doit être particularisée afin d'appliquer des conditions aux limites à la simulation.
         L'instance de simulation est passée en argument et ne doit pas être créee/modifiée.
 
@@ -37,7 +37,7 @@ class Impose_Boundary_Conditions:
         Les directions sont soit "LEFT" ou "BOTTOM". L'énumération d'une cellule (i,j) permet donc d'imposer la condition sur le bord gauche de la cellule (i-1/2,j) et sur le bord bas de la cellule (i,j-1/2).
 
         EN
-        --
+
         This function must be specialized in order to apply boundary conditions to the simulation.
         The simulation is passed as an argument and must not be created/modified.
 
@@ -50,7 +50,6 @@ class Impose_Boundary_Conditions:
         The directions are either "LEFT" or "BOTTOM." Enumerating a cell (i, j) thus imposes the condition on the left edge of cell (i-1/2, j) and on the bottom edge of cell (i, j-1/2).
 
         Exemple :
-        -------
 
         # Weak Normal Froude condition (value 0.3) on the left edge of the cell (3,997) -> (3,1002)
         for j in range(997,1003):

wolfhece/scenario/update_void.py

@@ -19,7 +19,7 @@ class Update_Sim:
     def update_topobathy(self, topobahty:WolfArray):
         """
         FR
-        --
+
         Cette fonction doit être particularisée afin d'appliquer des modifications
         à la topographie du lit majeur ou à la bathymétrie du lit mineur.
 
@@ -33,7 +33,7 @@ class Update_Sim:
         Il n'est pas permis de remplacer la matrice (création d'une nouvelle matrice et/ou pointage d'una autre matrice). Toutes les operations doivent se faire dans l'esace alloué.
 
         EN
-        --
+
         This function must be customized to apply modifications to the topography of the main bed or the bathymetry of the minor bed.
 
         The basic information is located in the 'topobahty' parameter ('WolfArray' class).
@@ -50,7 +50,7 @@ class Update_Sim:
     def update_manning(self, manning:WolfArray):
         """
         FR
-        --
+
         Cette fonction doit être particularisée afin d'appliquer des modifications
         à la distribution du coefficient de Manning.
 
@@ -64,7 +64,7 @@ class Update_Sim:
         Il n'est pas permis de remplacer la matrice (création d'une nouvelle matrice et/ou pointage d'una autre matrice). Toutes les operations doivent se faire dans l'esace alloué.
 
         EN
-        --
+
         This function must be customized to apply modifications to the Manning roughness parameter.
 
         The basic information is located in the 'manning' parameter ('WolfArray' class).
@@ -81,7 +81,7 @@ class Update_Sim:
     def update_infiltration(self, infiltration_zones:WolfArray):
         """
         FR
-        --
+
         Cette fonction doit être particularisée afin d'appliquer des modifications
         à la distribution des zones d'infiltration (matrice en Int32)
 
@@ -95,7 +95,7 @@ class Update_Sim:
         Il n'est pas permis de remplacer la matrice (création d'une nouvelle matrice et/ou pointage d'una autre matrice). Toutes les operations doivent se faire dans l'esace alloué.
 
         EN
-        --
+
         This function must be customized to apply modifications to the Infiltration zones parameter.
 
         The basic information is located in the 'infiltration_zones' parameter ('WolfArray' class).

wolfhece/wolf_array.py

@@ -3773,28 +3773,47 @@ class WolfArray(Element_To_Draw, header_wolf):
             else:
                 self.add_ops_sel()
 
-    def compare_cloud(self,mycloud:cloud_vertices):
+    def compare_cloud(self, mycloud:cloud_vertices, delta:list[float] = [.15, .5, 1.]):
         """
         Graphique de comparaison des valeurs d'un nuage de points et des valeurs de la matrice sous les mêmes positions
+
+        :param mycloud: cloud_vertices
+        :param delta: list of tolerance for the comparison
+
         """
+
+        # Get the values of the cloud
         xyz_cloud = mycloud.get_xyz()
+        # Get values of the array at the same positions
         zarray = np.array([self.get_value(curxy[0],curxy[1]) for curxy in xyz_cloud])
 
+        # count the number of points outside the array
         nbout = np.count_nonzero(zarray==-99999)
 
+        # Get the values of the cloud that are not outside the array
+        # Separate XY and Z values (cloud and array)
+        #  - z values
         z_cloud = xyz_cloud[zarray!=-99999][:,2]
+        #  - xy values
         xy_cloud = xyz_cloud[zarray!=-99999][:,:2]
+
+        #  - array values
         zarray = zarray[zarray!=-99999]
 
+        # concatenate all z values
         zall = np.concatenate([z_cloud,zarray])
+        # find the min and max values
         zmin = np.min(zall)
         zmax = np.max(zall)
 
+        # compute differences
         diffz = zarray-z_cloud
+        # choose a colormap
         cmap = plt.cm.get_cmap('RdYlBu')
         mindiff = np.min(diffz)
         maxdiff = np.max(diffz)
 
+        # Plot the differences [0] and the position [1]
         fig,ax = plt.subplots(2,1)
         ax[0].set_title(_('Comparison Z - ') + str(nbout) + _(' outside points on ') + str(len(xyz_cloud)))
         sc0 = ax[0].scatter(z_cloud,zarray,s=10,c=diffz,cmap = cmap, vmin=mindiff, vmax=maxdiff)
@@ -3802,7 +3821,16 @@ class WolfArray(Element_To_Draw, header_wolf):
         ax[0].set_ylabel(_('Array values'))
         ax[0].set_xlim([zmin,zmax])
         ax[0].set_ylim([zmin,zmax])
-        ax[0].plot([zmin,zmax],[zmin,zmax])
+
+        ax[0].plot([zmin,zmax],[zmin,zmax], color='black')
+
+        if delta is not None:
+            if isinstance(delta, list):
+                for idx, curdelta in enumerate(delta):
+                    curdelta = abs(float(curdelta))
+                    ax[0].plot([zmin,zmax],[zmin+delta,zmax+delta], 'k--', alpha=1.-1./(idx+1))
+                    ax[0].plot([zmin,zmax],[zmin-delta,zmax-delta], 'k--', alpha=1.-1./(idx+1))
+
         ax[0].axis('equal')
 
         sc1 = ax[1].scatter(xy_cloud[:,0],xy_cloud[:,1],s=10,c=diffz,cmap = cmap, vmin=mindiff, vmax=maxdiff)
@@ -4825,8 +4853,8 @@ class WolfArray(Element_To_Draw, header_wolf):
         """
         Return the coordinates inside a polygon
 
-        :param myvect = target vector
-        :param usemask = limit potential nodes to unmaksed nodes
+        :param myvect : target vector
+        :param usemask : limit potential nodes to unmaksed nodes
         """
 
         myvect.find_minmax()
@@ -4848,8 +4876,8 @@ class WolfArray(Element_To_Draw, header_wolf):
         """
         Return the coordinates along a polyline
 
-        :param myvect = target vector
-        :param usemask = limit potential nodes to unmaksed nodes
+        :param myvect : target vector
+        :param usemask : limit potential nodes to unmaksed nodes
         """
 
         allij = self.get_ij_under_polyline(myvect, usemask)
@@ -4861,8 +4889,8 @@ class WolfArray(Element_To_Draw, header_wolf):
         """
         Return the indices inside a polygon
 
-        :param myvect = target vector
-        :param usemask = limit potential nodes to unmaksed nodes
+        :param myvect : target vector
+        :param usemask : limit potential nodes to unmaksed nodes
         """
 
         myvect.find_minmax()
@@ -4905,8 +4933,8 @@ class WolfArray(Element_To_Draw, header_wolf):
         """
         Récupération des valeurs contenues dans un polygone
 
-        usemask (optional) restreint les éléments aux éléments non masqués de la matrice
-        getxy (optional) retourne en plus les coordonnées des points
+        :param usemask : (optional) restreint les éléments aux éléments non masqués de la matrice
+        :param getxy : (optional) retourne en plus les coordonnées des points
         """
         mypoints = self.get_xy_inside_polygon(myvect, usemask)
         myvalues = np.asarray([self.get_value(cur[0], cur[1]) for cur in mypoints])
@@ -4920,8 +4948,8 @@ class WolfArray(Element_To_Draw, header_wolf):
         """
         Récupération des valeurs contenues sous une polyligne
 
-        usemask (optional) restreint les éléments aux éléments non masqués de la matrice
-        getxy (optional) retourne en plus les coordonnées des points
+        :param usemask : (optional) restreint les éléments aux éléments non masqués de la matrice
+        :param getxy : (optional) retourne en plus les coordonnées des points
         """
         mypoints = self.get_xy_under_polyline(myvect, usemask)
 
@@ -4936,8 +4964,8 @@ class WolfArray(Element_To_Draw, header_wolf):
         """
         Récupération de toutes les valeurs contenues dans un polygone
 
-        usemask (optional) restreint les éléments aux éléments non masqués de la matrice
-        getxy (optional) retourne en plus les coordonnées des points
+        :param usemask : (optional) restreint les éléments aux éléments non masqués de la matrice
+        :param getxy : (optional) retourne en plus les coordonnées des points
 
         ICI on retourne le résultat de get_values_insidepoly, car une seule matrice, mais une autre classe pourrait vouloir faure autre chose
           C'est le cas notamment de Wolfresults_2D
@@ -4949,8 +4977,8 @@ class WolfArray(Element_To_Draw, header_wolf):
         """
         Récupération de toutes les valeurs sous la polyligne
 
-        usemask (optional) restreint les éléments aux éléments non masqués de la matrice
-        getxy (optional) retourne en plus les coordonnées des points
+        :param usemask : (optional) restreint les éléments aux éléments non masqués de la matrice
+        :param getxy : (optional) retourne en plus les coordonnées des points
 
         ICI on retourne le résultat de get_values_underpoly, car une seule matrice, mais une autre classe pourrait vouloir faure autre chose
           C'est le cas notamment de Wolfresults_2D
@@ -6931,8 +6959,9 @@ class WolfArrayMNAP(WolfArrayMB):
 class WolfArray_Sim2D(WolfArray):
     """
     Surcharge de WolfArray pour les matrices fines de simulation
-    Objectif :
-        - lier la matrice de mask à une source commune
+
+    Objectif : lier la matrice de mask à une source commune
+
     """
     def __init__(self,
                  fname:str=None,

wolfhece/wolfresults_2D.py

@@ -2723,10 +2723,8 @@ class Wolfresults_2D(Element_To_Draw):
 
         which_block : numéro du bloc; 1-based;
 
-        ***
-        ATTENTION :
-            Les indices sont passés comme WOLF --> en numérottaion Fortran (démarrage à 1 et non à 0)
-        ***
+        ATTENTION : Les indices sont passés comme WOLF --> en numérottaion Fortran (démarrage à 1 et non à 0)
+
         """
         k=-1
         e=-1

{wolfhece-2.0.17.dist-info → wolfhece-2.0.19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wolfhece
-Version: 2.0.17
+Version: 2.0.19
 Author-email: Stéphane Champailler <stephane.champailler@uliege.be>, Pierre Archambeau <pierre.archambeau@uliege.be>
 Project-URL: Homepage, https://uee.uliege.be/hece
 Project-URL: Issues, https://uee.uliege.be/hece
@@ -53,6 +53,12 @@ Requires-Dist: h5py
 Requires-Dist: basemap
 Requires-Dist: exif
 Requires-Dist: pyglm
+Requires-Dist: mqtt
+Requires-Dist: wradlib
+Requires-Dist: seaborn
+Requires-Dist: autograd
+Requires-Dist: plyfile
+Requires-Dist: tabulate
 
 Ce paquet contient l'interface graphique Python du logiciel WOLF (HECE - ULiège) de même que plusieurs outils de traitements topographique, hydraulique et hydrologique.