wolfhece 2.2.29__py3-none-any.whl → 2.2.31__py3-none-any.whl

wolfhece/pyshields.py

@@ -19,6 +19,7 @@ from .friction_law import f_barr_bathurst, f_colebrook, f_colebrook_pure
 
 RHO_PUREWATER = 1000. # kg/m3
 RHO_SEAWATER = 1025.  # kg/m3
+RHO_SEDIMENT = 2650. # kg/m3
 KIN_VISCOSITY = 1.e-6 # m2/s
 GRAVITY = 9.81 # m/s2
 
@@ -90,7 +91,7 @@ Autres :
 
 """
 
-def get_sadim(d:float, rhom:float =2650., rho:float =RHO_PUREWATER) -> float:
+def get_sadim(d:float, rhom:float = RHO_SEDIMENT, rho:float =RHO_PUREWATER) -> float:
       """
       s_adim = d**(3/2) * ((s-1) * g)**.5 / (4 * nu)
 
@@ -99,7 +100,7 @@ def get_sadim(d:float, rhom:float =2650., rho:float =RHO_PUREWATER) -> float:
       s=rhom/rho
       return d**(3./2.) * ((s-1) * GRAVITY)**.5 / (4 * KIN_VISCOSITY)
 
-def get_dstar(d:float, rhom:float =2650., rho:float=RHO_PUREWATER) -> float:
+def get_dstar(d:float, rhom:float = RHO_SEDIMENT, rho:float=RHO_PUREWATER) -> float:
       """ compute d* """
       s = rhom/rho
       return d*(GRAVITY*(s-1)/KIN_VISCOSITY**2)**(1./3.) #VanRijn Formula
@@ -110,7 +111,7 @@ def sadim2dstar(sadim:float) -> float:
 def dstar2sadim(dstar:float) -> float:
       return dstar**(3./2.) / 4
 
-def get_d_from_sadim(sadim:float, rhom:float=2650., rho:float=RHO_PUREWATER) -> float:
+def get_d_from_sadim(sadim:float, rhom:float= RHO_SEDIMENT, rho:float=RHO_PUREWATER) -> float:
       """
       s_adim = d**(3/2) * ((s-1) * g)**.5 / (4 * nu)
 
@@ -119,7 +120,7 @@ def get_d_from_sadim(sadim:float, rhom:float=2650., rho:float=RHO_PUREWATER) ->
       s=rhom/rho
       return (sadim*(4*KIN_VISCOSITY)/math.sqrt((s-1)*GRAVITY))**(2/3)
 
-def get_d_from_dstar(dstar:float, rhom:float=2650., rho:float=RHO_PUREWATER) -> float:
+def get_d_from_dstar(dstar:float, rhom:float= RHO_SEDIMENT, rho:float=RHO_PUREWATER) -> float:
       """
       d_star = d * (g * (s-1) / nu**2)**(1/3)
 
@@ -166,26 +167,38 @@ def get_psi_cr3(dstar:float) -> float:
       psicr = 0.13*dstar**-0.392*math.exp(-0.015*dstar**2.)+0.045*(1-math.exp(-0.068*dstar))
       return psicr
 
-# def get_shields_cr(d, rhom=2650., rho=RHO_PUREWATER, which=2):
-#       """
-#        Example:
-#         [critical_shear_velocity, tau_cr,xadim_val, psicr] = get_shields_cr(0.2E-3, 2650)
-#       """
+def get_shields_cr(d, rhom = RHO_SEDIMENT, rho = RHO_PUREWATER, which=2):
+      """
+      :param d: grain diameter [m]
+      :param rhom: sediment density [kg/m3]
+      :param rho: water density [kg/m3]
+      :param which: which formula to use (default 2) -- see funcs = [(get_sadim, get_psi_cr), (get_dstar, get_psi_cr2), (get_dstar, get_psi_cr3)]
+
+      :return: [critical_shear_velocity, tau_cr, xadim_val, psicr]
+
+       Example:
+        [critical_shear_velocity, tau_cr, xadim_val, psicr] = get_shields_cr(0.2E-3, 2650)
+      """
+
+      assert which in [0, 1, 2], "which must be 0, 1 or 2"
 
-#       funcs = [(get_sadim,get_psi_cr),(get_dstar,get_psi_cr2),(get_dstar,get_psi_cr3)]
-#       # % Getting the sediment-fluid parameter
-#       s = rhom/rho # [-]
-#       denom_shields= (s-1)*GRAVITY*d  # [m²/s²] en réalité denom/rho
+      funcs = [(get_sadim,get_psi_cr),
+               (get_dstar,get_psi_cr2),
+               (get_dstar,get_psi_cr3)]
 
-#       xadim_val = funcs[which][0](d,rhom,rho)
-#       psicr = funcs[which][1](xadim_val)
+      # % Getting the sediment-fluid parameter
+      s = rhom/rho # [-]
+      denom_shields= (s-1)*GRAVITY*d  # [m²/s²] en réalité denom/rho
 
-#       # Using the critical value of Shields parameter
-#       # Knowing the maximum bottom shear stress
-#       tau_cr = rho * denom_shields * psicr  # Pa
-#       critical_shear_velocity = math.sqrt(denom_shields * psicr) # m/s
+      xadim_val = funcs[which][0](d,rhom,rho)
+      psicr = funcs[which][1](xadim_val)
 
-#       return [critical_shear_velocity, tau_cr,xadim_val, psicr]
+      # Using the critical value of Shields parameter
+      # Knowing the maximum bottom shear stress
+      tau_cr = rho * denom_shields * psicr  # Pa
+      critical_shear_velocity = math.sqrt(denom_shields * psicr) # m/s
+
+      return [critical_shear_velocity, tau_cr, xadim_val, psicr]
 
 def _poly(x:float) -> float:
       return ((0.002235*x**5)-(0.06043*x**4)+(0.20307*x**3)+ \
@@ -204,7 +217,7 @@ def get_tau_from_psiadim(psiadim, d:float, rhom:float=2650, rho:float=RHO_PUREWA
       denom_shields= (s-1)*GRAVITY*d  ## en réalité denom/rho
       return rho * denom_shields * psiadim
 
-def get_d_min(rhom:float=2650., rho:float=RHO_PUREWATER) -> float:
+def get_d_min(rhom:float = RHO_SEDIMENT, rho:float=RHO_PUREWATER) -> float:
       return get_d_from_sadim(get_sadim_min(),rhom,rho)
 
 def _d_cr(x:float, tau_obj:float, rhom:float, rho:float, xadim:float, yadim:float) -> float:
@@ -215,66 +228,91 @@ def _d_cr(x:float, tau_obj:float, rhom:float, rho:float, xadim:float, yadim:floa
       psi_cr=yadim(xadim(x,rhom,rho))
       return psi_obj-psi_cr
 
-# def _get_d_cr(tau_cr,rhom=2650,rho=RHO_PUREWATER):
+def _get_d_cr(tau_cr, rhom = RHO_SEDIMENT, rho=RHO_PUREWATER, which=2) -> float:
+      """ Critical diameter d_cr for Shields criterion
+
+      :param tau_cr: critical shear stress [Pa]
+      :param rhom: sediment density [kg/m3]
+      :param rho: water density [kg/m3]
+      :param which: which formula to use (default 2) -- see funcs = [(get_sadim, get_psi_cr), (get_dstar, get_psi_cr2), (get_dstar, get_psi_cr3)]
+      """
+
+      assert which in [0, 1, 2], "which must be 0, 1 or 2"
+
+      dminabs = 1.e-100
+      dmaxabs = 20
+      funcs = [(get_sadim, get_psi_cr),
+               (get_dstar, get_psi_cr2),
+               (get_dstar, get_psi_cr3)]
 
-#       dminabs = 1.e-6
-#       dmaxabs = .5
-#       d_cr = root_scalar(_d_cr,(tau_cr,rhom,rho,get_sadim,get_psi_cr),'bisect',bracket=[dminabs, dmaxabs])
+      d_cr = root_scalar(_d_cr,(tau_cr, rhom, rho, funcs[which][0],funcs[which][1]), 'bisect', bracket=[dminabs, dmaxabs])
 
-#       return d_cr
+      return d_cr.root
 
-def get_d_cr(q:float, h:float, K:float, rhom:float=2650., rho:float=RHO_PUREWATER, method='brenth', which=2) -> list[float]:
+def get_d_cr(q:float, h:float, K:float,
+             rhom:float = RHO_SEDIMENT, rho:float=RHO_PUREWATER,
+             method='brenth', which=2,
+             friction_law:Literal['Strickler', 'Colebrook'] = 'Strickler') -> list[float]:
       """
       Diamètre critique d'emportement par :
             - Shields
             - Izbach
 
-      :param q : discharge [m3/s]
-      :param h : water depth [m]
-      :param K : Strickler friction coefficient [m1/3/s]
-      :param rhom : sediment density [kg/m3]
-      :param rho : water density [kg/m3]
-      :param method : method to solve the equation (default 'brenth')
-      :param which : which formula to use (default 2)  -- see funcs = [(get_sadim,get_psi_cr),(get_dstar,get_psi_cr2),(get_dstar,get_psi_cr3)]
+      :param q: discharge [m3/s]
+      :param h: water depth [m]
+      :param K: Strickler friction coefficient [m1/3/s]
+      :param rhom: sediment density [kg/m3]
+      :param rho: water density [kg/m3]
+      :param method: method to solve the equation (default 'brenth')
+      :param which: which formula to use (default 2)  -- see funcs = [(get_sadim,get_psi_cr),(get_dstar,get_psi_cr2),(get_dstar,get_psi_cr3)]
       """
+
+      assert which in [0, 1, 2], "which must be 0, 1 or 2"
+      assert friction_law in ['Strickler', 'Colebrook'], "friction_law must be 'Strickler' or 'Colebrook'"
+
       if q==0.:
             return 0.,0.
 
-      tau_cr = (q/K)**2 / h**(7/3) * rho  * GRAVITY # rho*g*h*J
+      # tau_cr = (q/K)**2 / h**(7/3) * rho  * GRAVITY # rho*g*h*J
+      if friction_law == 'Strickler':
+            tau_cr = get_friction_slope_2D_Manning(q, h, 1/K)  * rho * GRAVITY * h # rho*g*h*J
+      elif friction_law == 'Colebrook':
+            tau_cr = get_friction_slope_2D_Colebrook(q, h, K) * rho * GRAVITY * h
+
       dminabs = 1.e-100
       dmaxabs = 20
 
       funcs = [(get_sadim, get_psi_cr),(get_dstar, get_psi_cr2),(get_dstar, get_psi_cr3)]
 
       try:
-            d_cr = root_scalar(_d_cr,(tau_cr,rhom,rho,funcs[which][0],funcs[which][1]),method,bracket=[dminabs, dmaxabs],rtol = 1e-2)
+            d_cr = root_scalar(_d_cr,(tau_cr,rhom,rho,funcs[which][0],funcs[which][1]), method, bracket=[dminabs, dmaxabs], rtol = 1e-2)
             return d_cr.root, izbach_d_cr(q,h,rhom,rho)
       except:
             izbach = izbach_d_cr(q,h,rhom,rho)
             return izbach,izbach
 
-def get_settling_vel(d:float, rhom:float=2650., rho:float=RHO_PUREWATER) -> float:
+def get_settling_vel(d:float, rhom:float= RHO_SEDIMENT, rho:float=RHO_PUREWATER) -> float:
       """
       Vitesse de chute
 
-      :param d : grain diameter [m]
-      :param rhom : sediment density [kg/m3]
-      :param rho : water density [kg/m3]
+      :param d: grain diameter [m]
+      :param rhom: sediment density [kg/m3]
+      :param rho: water density [kg/m3]
       """
       dstar = get_dstar(d,rhom,rho)
       ws = KIN_VISCOSITY/d*(math.sqrt(25+1.2*dstar**2.)-5)**(3./2.)
       return ws
 
-def get_Rouse(d:float, q:float, h:float, K:float, rhom:float=2650., rho:float=RHO_PUREWATER) -> float:
+def get_Rouse(d:float, q:float, h:float, K:float, rhom:float= RHO_SEDIMENT, rho:float=RHO_PUREWATER) -> float:
       """
       Vitesse de chute
 
-      :param d : grain diameter [m]
-      :param q : discharge [m3/s]
-      :param h : water depth [m]
-      :param K : Strickler friction coefficient [m1/3/s]
-      :param rhom : sediment density [kg/m3]
-      :param rho : water density [kg/m3]
+      :param d: grain diameter [m]
+      :param q: discharge [m3/s]
+      :param h: water depth [m]
+      :param K: Strickler friction coefficient [m1/3/s]
+      :param rhom: sediment density [kg/m3]
+      :param rho: water density [kg/m3]
       """
       # tau_cr = (q/K)**2 / h**(7/3) * rho  * GRAVITY
       # shear_vel = math.sqrt(tau_cr/rho)
@@ -285,16 +323,16 @@ def get_Rouse(d:float, q:float, h:float, K:float, rhom:float=2650., rho:float=RH
 
       return ws/(k*shear_vel)
 
-def _get_Rouse(d:float, q:float, h:float, K:float, rhom:float=2650., rho:float=RHO_PUREWATER, frac:float=50) -> float:
+def _get_Rouse(d:float, q:float, h:float, K:float, rhom:float= RHO_SEDIMENT, rho:float=RHO_PUREWATER, frac:float=50) -> float:
       """
       Settling velocity function -- used in root_scalar
 
-      :param d : grain diameter [m]
-      :param q : discharge [m3/s]
-      :param h : water depth [m]
-      :param K : Strickler friction coefficient [m1/3/s]
-      :param rhom : sediment density [kg/m3]
-      :param rho : water density [kg/m3]
+      :param d: grain diameter [m]
+      :param q: discharge [m3/s]
+      :param h: water depth [m]
+      :param K: Strickler friction coefficient [m1/3/s]
+      :param rhom: sediment density [kg/m3]
+      :param rho: water density [kg/m3]
       """
       # tau_cr = (q/K)**2 / h**(7/3) * rho  * GRAVITY
       # shear_vel = math.sqrt(tau_cr/rho)
@@ -313,18 +351,18 @@ def _get_Rouse(d:float, q:float, h:float, K:float, rhom:float=2650., rho:float=R
       elif frac==100:
             return rouse-1.2
 
-def get_transport_mode(d:float, q:float, h:float, K:float, rhom:float=2650., rho:float=RHO_PUREWATER): # -> BED_LOAD | SUSPENDED_LOAD_50 | SUSPENDED_LOAD_100 | WASH_LOAD:
+def get_transport_mode(d:float, q:float, h:float, K:float, rhom:float= RHO_SEDIMENT, rho:float=RHO_PUREWATER): # -> BED_LOAD | SUSPENDED_LOAD_50 | SUSPENDED_LOAD_100 | WASH_LOAD:
       """
       Transport mode
 
       return in [BED_LOAD, SUSPENDED_LOAD_50, SUSPENDED_LOAD_100, WASH_LOAD]
 
-      :param d : grain diameter [m]
-      :param q : discharge [m3/s]
-      :param h : water depth [m]
-      :param K : Strickler friction coefficient [m1/3/s]
-      :param rhom : sediment density [kg/m3]
-      :param rho : water density [kg/m3]
+      :param d: grain diameter [m]
+      :param q: discharge [m3/s]
+      :param h: water depth [m]
+      :param K: Strickler friction coefficient [m1/3/s]
+      :param rhom: sediment density [kg/m3]
+      :param rho: water density [kg/m3]
 
       """
 
@@ -338,15 +376,15 @@ def get_transport_mode(d:float, q:float, h:float, K:float, rhom:float=2650., rho
       else:
             return WASH_LOAD
 
-def get_d_cr_susp(q:float, h:float, K:float, rhom:float=2650., rho:float=RHO_PUREWATER, method='brenth', which=50) -> float:
+def get_d_cr_susp(q:float, h:float, K:float, rhom:float= RHO_SEDIMENT, rho:float=RHO_PUREWATER, method='brenth', which=50) -> float:
       """
       Diamètre critique d'emportement par suspension à 50% --> cf Rouse 1.2
 
-      :param q : discharge [m3/s]
-      :param h : water depth [m]
-      :param K : Strickler friction coefficient [m1/3/s]
-      :param rhom : sediment density [kg/m3]
-      :param rho : water density [kg/m3]
+      :param q: discharge [m3/s]
+      :param h: water depth [m]
+      :param K: Strickler friction coefficient [m1/3/s]
+      :param rhom: sediment density [kg/m3]
+      :param rho: water density [kg/m3]
 
       """
       if q==0.:
@@ -360,8 +398,13 @@ def get_d_cr_susp(q:float, h:float, K:float, rhom:float=2650., rho:float=RHO_PUR
       except:
             return 0.
 
-def shieldsdia_sadim(s_psicr=None, dstar_psicr=None, rhom=2650., rho=RHO_PUREWATER, figax=None) -> tuple[plt.Figure,plt.Axes]:
-      """ Plot Shields diagram with sadim"""
+def shieldsdia_sadim(s_psicr=None, dstar_psicr=None, figax=None) -> tuple[plt.Figure,plt.Axes]:
+      """ Plot Shields diagram with sadim as x-axis
+
+      :param s_psicr: tuple (S, psicr) for a specific point to plot on the diagram
+      :param dstar_psicr: tuple (dstar, psicr) for a specific point to plot on the diagram
+      :param figax: tuple (fig, ax) to plot on a specific figure and axes
+      """
 
       smax = 1000
       rangoS = np.arange(0.1,smax,0.1)
@@ -416,8 +459,13 @@ def shieldsdia_sadim(s_psicr=None, dstar_psicr=None, rhom=2650., rho=RHO_PUREWAT
 
       return fig,ax
 
-def shieldsdia_dstar(s_psicr=None, dstar_psicr=None, rhom=2650., rho=RHO_PUREWATER, figax=None) -> tuple[plt.Figure,plt.Axes]:
-      """ Plot Shields diagram with dstar"""
+def shieldsdia_dstar(s_psicr=None, dstar_psicr=None, figax=None) -> tuple[plt.Figure,plt.Axes]:
+      """ Plot Shields diagram with dstar as x-axis
+
+      :param s_psicr: tuple (S, psicr) for a specific point to plot on the diagram
+      :param dstar_psicr: tuple (dstar, psicr) for a specific point to plot on the diagram
+      :param figax: tuple (fig, ax) to plot on a specific figure and axes
+      """
 
       smax = 1000
       d_stars = np.arange(0.1,smax,0.1)
@@ -517,9 +565,9 @@ def get_friction_slope_2D_Manning(q:float, h:float, n:float) -> float:
       """
       Compute friction slope j for 2D flow with Manning/Strickler friction law
 
-      :param q : discharge [m3/s]
-      :param h : water depth [m]
-      :param n : Manning friction coefficient [m-1/3.s]
+      :param q: discharge [m3/s]
+      :param h: water depth [m]
+      :param n: Manning friction coefficient [m^{-1/3}.s]
       """
 
       denom = h**(4./3.)
@@ -530,13 +578,24 @@ def get_friction_slope_2D_Manning(q:float, h:float, n:float) -> float:
 
       return j
 
+def get_friction_slope_2D_Strickler(q:float, h:float, K:float) -> float:
+      """
+      Compute friction slope j for 2D flow with Strickler friction law
+
+      :param q: discharge [m3/s]
+      :param h: water depth [m]
+      :param K: Strickler friction coefficient [m^{1/3}/s]
+      """
+
+      return get_friction_slope_2D_Manning(q, h, 1./K)  # n = 1/K
+
 def get_friction_slope_2D_Colebrook(q:float, h:float, K:float) -> float:
       """
       Compute friction slope j for 2D flow with Colebrook-White friction law
 
-      :param q : discharge [m3/s]
-      :param h : water depth [m]
-      :param K : Colebrook-White friction coefficient [m]
+      :param q: discharge [m3/s]
+      :param h: water depth [m]
+      :param K: height of roughness [m] - will be used to compute k/D or k/(4h) in 2D flow
       """
 
       four_hydraulic_radius = 4.0 * h
@@ -554,10 +613,10 @@ def get_shear_velocity_2D_Manning(q:float, h:float, n:float) -> float:
       """
       Compute shear velocity u_* for 2D flow with Manning/Strickler friction law
 
-      :param j : friction slope [-]
-      :param h : water depth [m]
-      :param q : discharge [m3/s]
-      :param n : Manning friction coefficient [m-1/3.s]
+      :param j: friction slope [-]
+      :param h: water depth [m]
+      :param q: discharge [m3/s]
+      :param n: Manning friction coefficient [m-1/3.s]
       """
 
       j = get_friction_slope_2D_Manning(q,h,n)
@@ -570,10 +629,10 @@ def get_shear_velocity_2D_Colebrook(q:float, h:float, K:float) -> float:
       """
       Compute shear velocity u_* for 2D flow with Colebrook-White friction law
 
-      :param j : friction slope [-]
-      :param h : water depth [m]
-      :param q : discharge [m3/s]
-      :param K : Colebrook-White friction coefficient [m]
+      :param j: friction slope [-]
+      :param h: water depth [m]
+      :param q: discharge [m3/s]
+      :param K: Colebrook-White friction coefficient [m]
       """
 
       j = get_friction_slope_2D_Colebrook(q,h,K)
@@ -586,11 +645,11 @@ def get_Shields_2D_Manning(s:float, d:float, q:float, h:float, n:float) -> float
       """
       Compute Shields dimensionless parameter for 2D flow with Manning/Strickler friction law
 
-      :param s : sediment density / water density [-]
-      :param d : sediment diameter [m]
-      :param q : discharge [m3/s]
-      :param h : water depth [m]
-      :param n : Manning friction coefficient [m-1/3.s]
+      :param s: sediment density / water density [-]
+      :param d: sediment diameter [m]
+      :param q: discharge [m3/s]
+      :param h: water depth [m]
+      :param n: Manning friction coefficient [m-1/3.s]
 
       See also get_Shields_2D_Strickler
       """
@@ -607,11 +666,11 @@ def get_Shields_2D_Strickler(s:float, d:float, q:float, h:float, K:float) -> flo
       """
       Compute Shields dimensionless parameter for 2D flow with Manning/Strickler friction law
 
-      :param s : sediment density / water density [-]
-      :param d : sediment diameter [m]
-      :param q : discharge [m3/s]
-      :param h : water depth [m]
-      :param K : Strickler friction coefficient [m1/3/s]
+      :param s: sediment density / water density [-]
+      :param d: sediment diameter [m]
+      :param q: discharge [m3/s]
+      :param h: water depth [m]
+      :param K: Strickler friction coefficient [m1/3/s]
 
       See also get_Shields_2D_Manning
       """
@@ -631,21 +690,23 @@ def izbach_d_cr(q:float, h:float, rhom:float=2650, rho:float=RHO_PUREWATER, meth
             (s-1) = (rho_m - rho) / rho
             u_c = 85% u_moyen)
 
-      --> d = u_c**2 / (s * g) / 1.7**2
+      --> d = u_c**2 / ((s-1) * g) / 1.7**2
 
-      --> d = (0.85 * q/h)**2 / (s * g) / 1.7**2
+      --> d = (0.85 * q/h)**2 / ((s-1) * g) / 1.7**2
 
-      :param q : discharge [m3/s]
-      :param h : water depth [m]
-      :param rhom : sediment density [kg/m3]
-      :param rho : water density [kg/m3]
-      :param method : method to solve the equation (default 'ridder')
+      :param q: discharge [m3/s]
+      :param h: water depth [m]
+      :param rhom: sediment density [kg/m3]
+      :param rho: water density [kg/m3]
+      :param method: method to solve the equation (default 'ridder')
       """
       s = rhom/rho
       #      (0.85 * q/h)**2. / ((s-1.) * GRAVITY) / 1.7**2.
-      # <=>  0.7 * (0.85*q/h)**2. / (2 * GRAVITY) / (s-1.)
-      # <=>  (q/h)**2. / (2 * GRAVITY) / (s-1.) / .86**2
-      return (q/h)**2. / (2 * GRAVITY) / (s-1.) / 1.2**2
+      # avec (2 / 1.7**2) = 0.692041... = 0.7
+      # <=>  0.7 * (0.85 * q/h)**2. / (2 * GRAVITY) / (s-1.)
+      # <=>  (q/h)**2. / (2 * GRAVITY) / (s-1.) / 1.406**2
+
+      return (q/h)**2. / (2 * GRAVITY) / (s-1.) / 1.2**2 # We are using 1.2 instead of 1.406 -- see GCIV2035-1 - Hydrodynamique fluviale
 
 
 ## Portage de WOLF2D - Fortran pour Barr-Bathurst

wolfhece/wolf_array.py

@@ -111,6 +111,11 @@ except ImportError as e:
     print(e)
     raise Exception(_('Error importing modules'))
 
+try:
+    from .pydownloader import download_file, toys_dataset
+except ImportError as e:
+    raise Exception(_('Error importing pydownloader module'))
+
 WOLF_ARRAY_HILLSHAPE = -1
 WOLF_ARRAY_FULL_SINGLE = 1
 WOLF_ARRAY_FULL_DOUBLE = 2
@@ -5605,6 +5610,14 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         if fname is not None:
 
+            # check if fname is an url
+            if str(fname).startswith('http:') or str(fname).startswith('https:'):
+                try:
+                    fname = download_file(fname)
+                except Exception as e:
+                    logging.error(_('Error while downloading file: %s') % e)
+                    return
+
             self.filename = str(fname)
             logging.info(_('Loading file : %s') % self.filename)
             self.read_all()
@@ -6240,20 +6253,39 @@ class WolfArray(Element_To_Draw, header_wolf):
         if reset_plot:
             self.reset_plot()
 
-    def statistics(self, inside_polygon:vector | Polygon = None):
+    def statistics(self, inside_polygon:vector | Polygon | np.ndarray = None) -> dict[str, float | np.ndarray]:
         """
         Statistics on Selected data or the whole array if no selection
 
         :param inside_polygon: vector or Polygon to select data inside the polygon
         :return: mean, std, median, sum, volume (sum*dx*dy), values
+        :rtype: dict[str, float | np.ndarray]
+
+        Translated Keys are:
+            - _('Mean'): mean value of the selected data
+            - _('Std'): standard deviation of the selected data
+            - _('Median'): median value of the selected data
+            - _('Sum'): sum of the selected data
+            - _('Volume'): volume of the selected data (sum * dx * dy)
+            - _('Values'): values of the selected data as a numpy array
         """
 
         if inside_polygon is not None:
-            ij = self.get_ij_inside_polygon(inside_polygon)
+            if isinstance(inside_polygon, vector | Polygon):
+                ij = self.get_ij_inside_polygon(inside_polygon)
+            elif isinstance(inside_polygon, np.ndarray):
+                if inside_polygon.ndim == 2 and inside_polygon.shape[1] == 2:
+                    ij = self.get_ij_from_xy_array(inside_polygon)
+                else:
+                    logging.error(_('Invalid shape for inside_polygon numpy array'))
+                    return {}
+
             vals = self.array[ij[:,0], ij[:,1]]
+
         elif self.SelectionData.nb == 0 or self.SelectionData.myselection == 'all':
             logging.info(_('No selection -- statistics on the whole array'))
             vals = self.array[~self.array.mask].ravel().data	# all values
+
         else:
             vals = self.SelectionData.get_values_sel()
 
@@ -8996,7 +9028,7 @@ class WolfArray(Element_To_Draw, header_wolf):
           C'est le cas notamment de Wolfresults_2D
         """
 
-        return self.get_values_insidepoly(myvect, usemask,getxy)
+        return self.get_values_insidepoly(myvect, usemask, getxy)
 
     def get_all_values_underpoly(self, myvect: vector, usemask:bool=True, getxy:bool=False):
         """
@@ -10145,7 +10177,7 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         return my_extr
 
-    def get_value(self, x:float, y:float, z:float=0., nullvalue:float=-99999):
+    def get_value(self, x:float, y:float, z:float=0., nullvalue:float=-99999, convert_to_float:bool=True):
         """
         Return the value at given coordinates
 
@@ -10180,8 +10212,10 @@ class WolfArray(Element_To_Draw, header_wolf):
             else:
                 value = nullvalue
 
-        #FIXME : forcing to convert to float is not a good idea
-        return float(value)
+        if convert_to_float:
+            return float(value)
+        else:
+            return value
 
     def get_xlim(self, window_x:float, window_y:float):
         """

{wolfhece-2.2.29.dist-info → wolfhece-2.2.31.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wolfhece
-Version: 2.2.29
+Version: 2.2.31
 Author-email: Pierre Archambeau <pierre.archambeau@uliege.be>
 Project-URL: Homepage, https://uee.uliege.be/hece
 Project-URL: Issues, https://uee.uliege.be/hece

{wolfhece-2.2.29.dist-info → wolfhece-2.2.31.dist-info}/RECORD

@@ -7,8 +7,8 @@ wolfhece/ManageParams.py,sha256=EeuUI5Vvh9ixCvYf8YShMC1s1Yacc7OxOCN7q81gqiQ,517
 wolfhece/Model1D.py,sha256=snEmu8Uj2YGcp1ybPnly-4A389XRnuOujGduqInNcgw,477001
 wolfhece/PandasGrid.py,sha256=YIleVkUkoP2MjtQBZ9Xgwk61zbgMj4Pmjj-clVTfPRs,2353
 wolfhece/PyConfig.py,sha256=Zs9852UnTMDjiH9RhC_-cQdOowDaS1U5PbmmU9nEpv0,18265
-wolfhece/PyCrosssections.py,sha256=igU_ELrg5VrHU6RNbF5tHxPyVImpR3xdpfopJYc7haw,114711
-wolfhece/PyDraw.py,sha256=-hPVoASNtB7k9_P7F3uq-4Vqytie4wjEL36OUiqtszQ,671455
+wolfhece/PyCrosssections.py,sha256=iSmuQ1753bWxRLgOkrRLPd3tiMwGRCvfKD2Mim26_8c,114836
+wolfhece/PyDraw.py,sha256=cloYUTYk6tTCuSmBehVcz2DOadkb7J5w9i1ihBilT2Q,671960
 wolfhece/PyGui.py,sha256=DqMTDsC9GthnMdYOXvkMKfl5pNciExVzxG4ogptWf6g,146010
 wolfhece/PyGuiHydrology.py,sha256=sKafpOopBg50L5llZCI_fZtbebVTDtxvoRI6-osUwhg,14745
 wolfhece/PyHydrographs.py,sha256=1P5XAURNqCvtSsMQXhOn1ihjTpr725sRsZdlCEhhk6M,3730
@@ -17,7 +17,7 @@ wolfhece/PyParams.py,sha256=BgTAwxxq831rYEq_KLcFBX_upjiSUpVtfoQnCxCNWUI,100443
 wolfhece/PyPictures.py,sha256=m1kY0saW6Y9Q0bDCo47lW6XxDkBrbQG-Fd8uVn8G5ic,2514
 wolfhece/PyTranslate.py,sha256=4appkmNeHHZLFmUtaA_k5_5QL-5ymxnbVN4R2OblmtE,622
 wolfhece/PyVertex.py,sha256=a56oY1NB45QnwARg96Tbnq-z-mhZKFkYOkFOO1lNtlk,51056
-wolfhece/PyVertexvectors.py,sha256=DZpuqfzAEWAtGJ5oSzRY0kRMlkwErogcGMJQOh6niDE,341983
+wolfhece/PyVertexvectors.py,sha256=MXoqgHVRMvpUOngqpErwT68JwUJo9FhEl1H4HB10-Zk,352574
 wolfhece/PyWMS.py,sha256=XcSlav5icct2UwV7K2r7vpxa5rKZWiHkp732lI94HFI,31534
 wolfhece/RatingCurve.py,sha256=bUjIrQjvIjkD4V-z8bZmA6pe1ILtYNM0-3fT6YUY1RU,22498
 wolfhece/RatingCurveData.py,sha256=5UvnIm89BwqjnEbLCcY3CA8WoFd_xHJbooNy62fX5iY,57660
@@ -26,7 +26,7 @@ wolfhece/ReadDataDCENN.py,sha256=vm-I4YMryvRldjXTvRYEUCxZsjb_tM7U9yj6OaPyD0k,153
 wolfhece/Results2DGPU.py,sha256=GTu7PMuwfH-xH8J7sVr6zq2CTkGKF24fG1ujEW62PtM,31598
 wolfhece/__init__.py,sha256=EnpZ2yDEXueP7GAKV0uA2vAwMiZFyBjDAFcL5Y7LzbM,1850
 wolfhece/_add_path.py,sha256=mAyu85CQHk0KgUI6ZizweeQiw1Gdyea9OEjGLC6lLA4,916
-wolfhece/analyze_poly.py,sha256=jsCUsd0ZJtTwSk5hekcXj8i0tGhH-WCfNkrBtPRJpCc,12715
+wolfhece/analyze_poly.py,sha256=gJlQZ0vwDG_N98eMDtUsLng9kKu-HlJ8a4xER9ubfDc,54527
 wolfhece/analyze_vect.py,sha256=3lkMwaQ4KRddBVRvlP9PcM66wZwwC0eCmypP91AW-os,6015
 wolfhece/cli.py,sha256=h1tSMHALiftktreyugKcjbASXfpJUm9UYMeVxR-MtG4,6424
 wolfhece/color_constants.py,sha256=Snc5RX11Ydi756EkBp_83C7DiAQ_Z1aHD9jFIBsosAU,37121
@@ -51,16 +51,17 @@ wolfhece/pidcontroller.py,sha256=PHYenOdzfyPK2pXAhyRolCxMSMRd2AFza0eVMafpPHk,520
 wolfhece/pyGui1D.py,sha256=9g7OS3YiKsqy--6y0cBD7x2gaqTTYFXWkxImpgnTA20,121937
 wolfhece/pybridges.py,sha256=bFAqjL4ColeJtwvyCPGQ8VllWoq1RbVWXxFrdfrvqm8,65954
 wolfhece/pydike.py,sha256=dRb6qGkqoTXjf107KcajcIk1F_FuMPaOZLSwixT3dgA,11196
+wolfhece/pydownloader.py,sha256=7vcxzllphhQcH0nEI2NwX-HC0bKhOVpDkODq54oFMbU,7136
 wolfhece/pylogging.py,sha256=4TI8hgBB65z-zpvU5Rfa2jkPXPhJaqXjHVPwbcdzTNc,4528
-wolfhece/pypolygons_scen.py,sha256=dG4zyJL_t5wgDqRfe-OqSH-fnxUt-su1H-tM3K3wHnc,46339
-wolfhece/pyshields.py,sha256=ymH393EQys2aZmh41ccJnWmmlF7dVa-eTY32jFgwK08,25269
+wolfhece/pypolygons_scen.py,sha256=NWaNeK0RSUeOkgukeogK9FLmQiDjGZ9yhqs9208fojM,46237
+wolfhece/pyshields.py,sha256=KMtUO5kD0lisKnJD1NsDz-qaY5DpFcmS4O3WkXtUSmo,27898
 wolfhece/pyviews.py,sha256=zuZjWUptRDm1MTE1PN4Xj_qSITnojgDMG0LlFIBH3SE,13739
 wolfhece/pywalous.py,sha256=mWB7UxlYMIbPxNUDlONQEjcOOy9VSaRU9aYWZ5IFLu8,19164
 wolfhece/rain_SPWMI.py,sha256=qCfcmF7LajloOaCwnTrrSMzyME03YyilmRUOqrPrv3U,13846
 wolfhece/textpillow.py,sha256=map7HsGYML_o5NHRdFg2s_TVQed_lDnpYNDv27MM0Vw,14130
 wolfhece/tools2d_dll.py,sha256=TfvvmyZUqEZIH0uHwUCJf0bdmCks_AiidDt23Unsp5w,13550
 wolfhece/tools_mpl.py,sha256=gQ3Jg1iuZiecmMqa5Eli2ZLSkttu68VXL8YmMDBaEYU,564
-wolfhece/wolf_array.py,sha256=15bCTr6nplKwGrkKR4vJR_NZCnhSZsoceUtV99Uy4C8,521981
+wolfhece/wolf_array.py,sha256=jin9_ntHASNcqMx0CPYFHMEIw-LaF6UnousSaQx3AxU,523441
 wolfhece/wolf_hist.py,sha256=fTEb60Q4TEwobdZsRU4CFXAId1eOKdWAqF8lnF1xEWc,3590
 wolfhece/wolf_texture.py,sha256=f4psYah1vqyeQjXz2O46d6qeKuv_Lzowk39O9Fmh_2g,20969
 wolfhece/wolf_tiles.py,sha256=v-HohqaWuMYdn75XLnA22dlloAG90iwnIqrgnB0ASQ4,10488
@@ -88,7 +89,7 @@ wolfhece/apps/curvedigitizer.py,sha256=lEJJwgAfulrrWQc-U6ij6sj59hWN3SZl4Yu1kQxVz
 wolfhece/apps/hydrometry.py,sha256=lhhJsFeb4zGL4bNQTs0co85OQ_6ssL1Oy0OUJCzhfYE,656
 wolfhece/apps/isocurrent.py,sha256=dagmGR8ja9QQ1gwz_8fU-N052hIw-W0mWGVkzLu6C7I,4247
 wolfhece/apps/splashscreen.py,sha256=EdGDN9NhudIiP7c3gVqj7dp4MWFB8ySizM_tpMnsgpE,3091
-wolfhece/apps/version.py,sha256=MsRPVPFz_Nd-g9QBhzEMZR5szCY4WxPCUofNwlSWVMA,388
+wolfhece/apps/version.py,sha256=5D9bE5dzDLfYPyBmgVoMOincHBhGAqYJzByZrRcBiy8,388
 wolfhece/apps/wolf.py,sha256=mRnjYsUu4KIsRuamdQWAINFMuwN4eJgMo9erG-hkZ70,729
 wolfhece/apps/wolf2D.py,sha256=4z_OPQ3IgaLtjexjMKX9ppvqEYyjFLt1hcfFABy3-jU,703
 wolfhece/apps/wolf_logo.bmp,sha256=ruJ4MA51CpGO_AYUp_dB4SWKHelvhOvd7Q8NrVOjDJk,3126
@@ -307,8 +308,8 @@ wolfhece/ui/wolf_multiselection_collapsiblepane.py,sha256=u4C7CXe_bUyGKx7c_Bi0x9
 wolfhece/ui/wolf_times_selection_comparison_models.py,sha256=ORy7fz4dcp691qKzaOZHrRLZ0uXNhL-LIHxmpDGL6BI,5007
 wolfhece/wintab/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wolfhece/wintab/wintab.py,sha256=8A-JNONV6ujgsgG3lM5Uw-pVgglPATwKs86oBzzljoc,7179
-wolfhece-2.2.29.dist-info/METADATA,sha256=35R9m7_Q5LYcKUXvUBBwZ8p1A-JMWrMYn5VtO4ncgNw,2729
-wolfhece-2.2.29.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-wolfhece-2.2.29.dist-info/entry_points.txt,sha256=Jr187pyvA3EeJiQLjZK9yo6mJX7IAn6ygZU9T8qF_gQ,658
-wolfhece-2.2.29.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
-wolfhece-2.2.29.dist-info/RECORD,,
+wolfhece-2.2.31.dist-info/METADATA,sha256=FCE-JySySzwE8OSrK7O7_8IIPOg9RBfBVDS8sPiXfek,2729
+wolfhece-2.2.31.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+wolfhece-2.2.31.dist-info/entry_points.txt,sha256=Jr187pyvA3EeJiQLjZK9yo6mJX7IAn6ygZU9T8qF_gQ,658
+wolfhece-2.2.31.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
+wolfhece-2.2.31.dist-info/RECORD,,