wolfhece 1.8.12__py3-none-any.whl → 2.0.0__py3-none-any.whl

wolfhece/multiprojects.py

@@ -6,7 +6,7 @@ from typing import Literal
 from concurrent.futures import ThreadPoolExecutor
 import logging
 
-from .PyParams import Wolf_Param
+from .PyParams import Wolf_Param, key_Param
 from .PyVertexvectors import Zones, vector, zone
 from .PyPalette import wolfpalette
 from .PyTranslate import _
@@ -88,7 +88,7 @@ class Wolf2D_Project(Project):
             if verbose:
                 print(key)
 
-            cursim = self.mysims[key] = Wolfresults_2D(join(self.wdir, val['value']), eps=epsilon, idx=key)
+            cursim = self.mysims[key] = Wolfresults_2D(join(self.wdir, val[key_Param.VALUE]), eps=epsilon, idx=key)
             cursim.plotted=True
 
         self.set_vectors()
@@ -125,10 +125,10 @@ class Wolf2D_Project(Project):
         for curkey,curvec in vec.items():
 
             filename=''
-            if exists(curvec['value']):
+            if exists(curvec[key_Param.VALUE]):
                 filename = curvec
-            elif exists(join(self.wdir,curvec['value'])):
-                filename = join(self.wdir,curvec['value'])
+            elif exists(join(self.wdir,curvec[key_Param.VALUE])):
+                filename = join(self.wdir,curvec[key_Param.VALUE])
 
             if filename!='':
                 self.mycontours[curkey] = Zones(filename)
@@ -140,8 +140,8 @@ class Wolf2D_Project(Project):
                 locvec = None
                 cursim = None
 
-                if curname['value'] in self.mycontours.keys():
-                    locvec = self.mycontours[curname['value']]
+                if curname[key_Param.VALUE] in self.mycontours.keys():
+                    locvec = self.mycontours[curname[key_Param.VALUE]]
 
                 if curid in self.mysims.keys():
                     cursim = self.mysims[curid]
@@ -160,10 +160,10 @@ class Wolf2D_Project(Project):
 
         for curid, curname in pals.items():
             filename=''
-            if exists(curname['value']):
-                filename = curname['value']
-            elif exists(join(self.wdir, curname['value'])):
-                filename=join(self.wdir, curname['value'])
+            if exists(curname[key_Param.VALUE]):
+                filename = curname[key_Param.VALUE]
+            elif exists(join(self.wdir, curname[key_Param.VALUE])):
+                filename=join(self.wdir, curname[key_Param.VALUE])
 
             if filename!='':
                 mypal = wolfpalette(None, '')
@@ -175,10 +175,10 @@ class Wolf2D_Project(Project):
         palsarrays = self.get_group('palette-array')
         if palsarrays is not None:
             for curid, curname in palsarrays.items():
-                if curname['value'] in self.set_colormap.keys():
+                if curname[key_Param.VALUE] in self.set_colormap.keys():
                     if curid in self.mysims.keys():
                         curarray = self.mysims[curid]
-                        mypal = self.mycolormaps[curname['value']]
+                        mypal = self.mycolormaps[curname[key_Param.VALUE]]
                         curarray.mypal = mypal
                         curarray.mypal.automatic = False
 

wolfhece/pylogging.py

@@ -58,7 +58,7 @@ def create_wxlogwindow(winTitle='Log') -> wx.LogWindow:
             logging.getLogger().addHandler(log_bridge_handler)
 
             # Set some logging level, just to show up.
-            logging.getLogger().setLevel(logging.DEBUG)
+            logging.getLogger().setLevel(logging.INFO)
             log_bridge_handler.setLevel(logging.INFO)
             wx.Log.SetVerbose(True)
 

wolfhece/pyshields.py

@@ -2,13 +2,15 @@ import matplotlib.pyplot as plt
 import math
 import numpy as np
 from scipy.optimize import root_scalar
+from typing import Literal
+import logging
 
 from .friction_law import f_barr_bathurst
 
-RHO_PUREWATER = 1000
-RHO_SEAWATER = 1025
-KIN_VISCOSITY = 1.e-6
-GRAVITY = 9.81
+RHO_PUREWATER = 1000. # kg/m3
+RHO_SEAWATER = 1025.  # kg/m3
+KIN_VISCOSITY = 1.e-6 # m2/s
+GRAVITY = 9.81 # m/s2
 
 BED_LOAD=1
 SUSPENDED_LOAD_50=2
@@ -78,7 +80,7 @@ Autres :
 
 """
 
-def get_sadim(d,rhom=2650,rho=RHO_PUREWATER):
+def get_sadim(d:float, rhom:float =2650., rho:float =RHO_PUREWATER) -> float:
       """
       s_adim = d**(3/2) * ((s-1) * g)**.5 / (4 * nu)
 
@@ -87,18 +89,18 @@ def get_sadim(d,rhom=2650,rho=RHO_PUREWATER):
       s=rhom/rho
       return d**(3./2.) * ((s-1) * GRAVITY)**.5 / (4 * KIN_VISCOSITY)
 
-def get_dstar(d,rhom=2650.,rho=RHO_PUREWATER):
-
+def get_dstar(d:float, rhom:float =2650., rho:float=RHO_PUREWATER) -> float:
+      """ compute d* """
       s = rhom/rho
       return d*(GRAVITY*(s-1)/KIN_VISCOSITY**2)**(1./3.) #VanRijn Formula
 
-def sadim2dstar(sadim):
+def sadim2dstar(sadim:float) -> float:
       return (4*sadim)**(2/3)
 
-def dstar2sadim(dstar):
+def dstar2sadim(dstar:float) -> float:
       return dstar**(3./2.) / 4
 
-def get_d_from_sadim(sadim,rhom=2650,rho=RHO_PUREWATER):
+def get_d_from_sadim(sadim:float, rhom:float=2650., rho:float=RHO_PUREWATER) -> float:
       """
       s_adim = d**(3/2) * ((s-1) * g)**.5 / (4 * nu)
 
@@ -107,7 +109,7 @@ def get_d_from_sadim(sadim,rhom=2650,rho=RHO_PUREWATER):
       s=rhom/rho
       return (sadim*(4*KIN_VISCOSITY)/math.sqrt((s-1)*GRAVITY))**(2/3)
 
-def get_d_from_dstar(dstar,rhom=2650,rho=RHO_PUREWATER):
+def get_d_from_dstar(dstar:float, rhom:float=2650., rho:float=RHO_PUREWATER) -> float:
       """
       d_star = d * (g * (s-1) / nu**2)**(1/3)
 
@@ -116,7 +118,7 @@ def get_d_from_dstar(dstar,rhom=2650,rho=RHO_PUREWATER):
       s=rhom/rho
       return dstar / (GRAVITY*(s-1)/KIN_VISCOSITY**2)**(1./3.)
 
-def get_psi_cr(s_adim):
+def get_psi_cr(s_adim:float) -> float:
       """
       https://nl.mathworks.com/matlabcentral/fileexchange/97447-modified-shields-diagram-and-criterion?tab=reviews
       """
@@ -130,7 +132,7 @@ def get_psi_cr(s_adim):
 
       return psicr
 
-def get_psi_cr2(dstar):
+def get_psi_cr2(dstar:float) -> float:
       """
       http://docs.opentelemac.org/doxydocs/v8p2r0/html/shields_8f_source.html
       """
@@ -146,7 +148,7 @@ def get_psi_cr2(dstar):
             psicr= 0.045
       return psicr
 
-def get_psi_cr3(dstar):
+def get_psi_cr3(dstar:float) -> float:
       """
       Fluvial Processes, IAHR 2001, pp 6-9
       """
@@ -154,81 +156,85 @@ def get_psi_cr3(dstar):
       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,taocr,S] = shieldsmodbonlay(2650,0.2E-3)
-
-       critical_shear_velocity =
-         0.012649
-       taocr =
-         0.16399
-      """
+# 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)
+#       """
 
-      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)]
+#       # % Getting the sediment-fluid parameter
+#       s = rhom/rho # [-]
+#       denom_shields= (s-1)*GRAVITY*d  # [m²/s²] en réalité denom/rho
 
-      xadim_val = funcs[which][0](d,rhom,rho)
-      psicr = funcs[which][1](xadim_val)
+#       xadim_val = funcs[which][0](d,rhom,rho)
+#       psicr = funcs[which][1](xadim_val)
 
-      # 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
+#       # 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]
+#       return [critical_shear_velocity, tau_cr,xadim_val, psicr]
 
-def _poly(x):
-    return ((0.002235*x**5)-(0.06043*x**4)+(0.20307*x**3)+ \
+def _poly(x:float) -> float:
+      return ((0.002235*x**5)-(0.06043*x**4)+(0.20307*x**3)+ \
                    (0.054252*x**2)-(0.636397*x)-1.03167)
 
-def _dpolydx(x):
-    return ((0.002235*5*x**4)-(0.06043*4*x**3)+(0.20307*3*x**2)+ \
+def _dpolydx(x:float) -> float:
+      """ derivative of _poly """
+      return ((0.002235*5*x**4)-(0.06043*4*x**3)+(0.20307*3*x**2)+ \
                    (0.054252*2*x)-(0.636397))
 
-def get_sadim_min():
-      return root_scalar(_dpolydx,method='bisect',bracket=[10, 20]).root
+def get_sadim_min() -> float:
+      return root_scalar(_dpolydx, method='bisect', bracket=[10, 20]).root
 
-def get_tau_from_psiadim(psiadim,d,rhom=2650,rho=RHO_PUREWATER):
+def get_tau_from_psiadim(psiadim, d:float, rhom:float=2650, rho:float=RHO_PUREWATER) -> float:
       s=rhom/rho
       denom_shields= (s-1)*GRAVITY*d  ## en réalité denom/rho
       return rho * denom_shields * psiadim
 
-def get_d_min(rhom=2650,rho=RHO_PUREWATER):
+def get_d_min(rhom:float=2650., rho:float=RHO_PUREWATER) -> float:
       return get_d_from_sadim(get_sadim_min(),rhom,rho)
 
-def _d_cr(x,tau_obj,rhom,rho,xadim,yadim):
-
+def _d_cr(x:float, tau_obj:float, rhom:float, rho:float, xadim:float, yadim:float) -> float:
+      """ Equation to solve to get d_cr """
       s=rhom/rho
       denom_shields= (s-1)*GRAVITY*x  ## en réalité denom/rho
       psi_obj = tau_obj/denom_shields/rho
       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=2650,rho=RHO_PUREWATER):
 
-      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])
+#       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])
 
-      return d_cr
+#       return d_cr
 
-def get_d_cr(q,h,K,rhom=2650,rho=RHO_PUREWATER,method='brenth',which=2):
+def get_d_cr(q:float, h:float, K:float, rhom:float=2650., rho:float=RHO_PUREWATER, method='brenth', which=2) -> 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)]
       """
       if q==0.:
             return 0.,0.
 
-      tau_cr = (q/K)**2 / h**(7/3) * rho  * GRAVITY
+      tau_cr = (q/K)**2 / h**(7/3) * rho  * GRAVITY # rho*g*h*J
       dminabs = 1.e-100
       dmaxabs = 20
 
-      funcs = [(get_sadim,get_psi_cr),(get_dstar,get_psi_cr2),(get_dstar,get_psi_cr3)]
+      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)
@@ -237,17 +243,28 @@ def get_d_cr(q,h,K,rhom=2650,rho=RHO_PUREWATER,method='brenth',which=2):
             izbach = izbach_d_cr(q,h,rhom,rho)
             return izbach,izbach
 
-def get_settling_vel(d,rhom=2650,rho=RHO_PUREWATER):
+def get_settling_vel(d:float, rhom:float=2650., 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]
       """
       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,q,h,K,rhom=2650,rho=RHO_PUREWATER):
+def get_Rouse(d:float, q:float, h:float, K:float, rhom:float=2650., 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]
       """
       # tau_cr = (q/K)**2 / h**(7/3) * rho  * GRAVITY
       # shear_vel = math.sqrt(tau_cr/rho)
@@ -258,9 +275,16 @@ def get_Rouse(d,q,h,K,rhom=2650,rho=RHO_PUREWATER):
 
       return ws/(k*shear_vel)
 
-def _get_Rouse(d,q,h,K,rhom=2650,rho=RHO_PUREWATER,frac=50):
+def _get_Rouse(d:float, q:float, h:float, K:float, rhom:float=2650., rho:float=RHO_PUREWATER, frac:float=50) -> float:
       """
-      Vitesse de chute
+      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]
       """
       # tau_cr = (q/K)**2 / h**(7/3) * rho  * GRAVITY
       # shear_vel = math.sqrt(tau_cr/rho)
@@ -279,7 +303,20 @@ def _get_Rouse(d,q,h,K,rhom=2650,rho=RHO_PUREWATER,frac=50):
       elif frac==100:
             return rouse-1.2
 
-def get_transport_mode(d,q,h,K,rhom=2650,rho=RHO_PUREWATER):
+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:
+      """
+      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]
+
+      """
 
       rouse = get_Rouse(d,q,h,K,rhom,rho)
       if rouse>=2.5:
@@ -291,9 +328,16 @@ def get_transport_mode(d,q,h,K,rhom=2650,rho=RHO_PUREWATER):
       else:
             return WASH_LOAD
 
-def get_d_cr_susp(q,h,K,rhom=2650,rho=RHO_PUREWATER,method='brenth',which=50):
+def get_d_cr_susp(q:float, h:float, K:float, rhom:float=2650., 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]
+
       """
       if q==0.:
             return 0.
@@ -306,7 +350,8 @@ def get_d_cr_susp(q,h,K,rhom=2650,rho=RHO_PUREWATER,method='brenth',which=50):
       except:
             return 0.
 
-def shieldsdia_sadim(s_psicr=None,dstar_psicr=None,rhom=2650,rho=RHO_PUREWATER,figax=None):
+def shieldsdia_sadim(s_psicr=None, dstar_psicr=None, rhom=2650., rho=RHO_PUREWATER, figax=None) -> [plt.Figure,plt.Axes]:
+      """ Plot Shields diagram with sadim"""
 
       smax = 1000
       rangoS = np.arange(0.1,smax,0.1)
@@ -361,7 +406,8 @@ def shieldsdia_sadim(s_psicr=None,dstar_psicr=None,rhom=2650,rho=RHO_PUREWATER,f
 
       return fig,ax
 
-def shieldsdia_dstar(s_psicr=None,dstar_psicr=None,rhom=2650,rho=RHO_PUREWATER,figax=None):
+def shieldsdia_dstar(s_psicr=None, dstar_psicr=None, rhom=2650., rho=RHO_PUREWATER, figax=None) -> [plt.Figure,plt.Axes]:
+      """ Plot Shields diagram with dstar"""
 
       smax = 1000
       d_stars = np.arange(0.1,smax,0.1)
@@ -419,7 +465,9 @@ def shieldsdia_dstar(s_psicr=None,dstar_psicr=None,rhom=2650,rho=RHO_PUREWATER,f
 
       return fig,ax
 
-def shieldsdia_dim(figax=None):
+def shieldsdia_dim(figax=None) -> [plt.Figure,plt.Axes]:
+      """ Plot Shields diagram with dimensional values"""
+
       smax=1e6
       rangoS = np.concatenate([np.arange(0.1,300,0.1),np.arange(300.,smax,5.)])
       psicri = np.asarray([get_psi_cr(curx) for curx in rangoS])
@@ -455,85 +503,25 @@ def shieldsdia_dim(figax=None):
 
       return fig,ax
 
-def get_Shields_2D_pw(s, d, q_abs, h, k_rough, which_law = 'Manning'):
+def get_Shields_2D_Manning(s:float, d:float, q:float, h:float, K:float) -> float:
       """
+      Compute Shields dimensionless parameter for 2D flow with Manning 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]
       """
       # calcul de terme de pente de frottement
-      if which_law == 'Manning':
-            j = (q_abs/h/k_rough)**2.0 / h**(7./3.)
-      elif which_law == 'Barr_Bathurst':
-            k_sur_h = k_rough/(4.0*h)
-            Reynolds = 4.0 * q_abs /KIN_VISCOSITY # u*4h/nu == 4q/nu
-            j = f_barr_bathurst(k_sur_h,Reynolds)/(4.0*h) * (q_abs/h)**2.0/2.0/GRAVITY
 
-      shields = j*h / (d*(s-1))
+      j = (q/h)**2.0 / K**2. / h**(4./3.)
 
-      # shields = f/4 * u**2 /2 /g /(d * (rho_s-rho_w) / rho_w)
-      # shields = tau / (rho_s - rho_w) /g /d
-      # tau = f/8 * rho_w * u**2
+      shields = j*h / (d*(s-1))
 
       return shields
 
-def get_effective_d_2D(s,theta_cr,q_abs,h,k_rough):
-      """
-      Calcul du diamètre de grain emporté par une approche basée sur une tension efficace
-
-      Portage du code de calcul de WOLF2D
-      @authors : Pierre Archambeau (2022)
-      """
-
-      #if which_friction_law#=rough_Barr_Bathurst:
-       ##les autres lois de frottement ne sont pas implémentées mais aucune difficulté particulière
-      ##ne devraient empêcher cela
-
-      my_exp = [0.0, 0.10, 0.20, 0.30, 0.40, 0.420, 0.440, 0.460, 0.480,
-                0.50, 0.52, 0.54, 0.56, 0.58,
-                0.6, 0.62, 0.64, 0.66, 0.68,
-                0.7, 0.71, 0.72, 0.73, 0.74, 0.75]
-
-      ##calcul du coefficient de frottement (point de vue de l'écoulement)
-      u_abs = q_abs/h
-      Reynolds = q_abs * 4 / KIN_VISCOSITY
-      k_sur_h = k_rough/(4*h)
-      f_flow = f_barr_bathurst(k_sur_h,Reynolds)
-
-      #valeur initiale (pas de tension efficace)
-      exp = my_exp[0]
-      d = f_flow**(1-exp)*u_abs**2/(8*(s-1)*GRAVITY*theta_cr)
-      #boucle pour approcher les exposants requis
-      for cur_exponent in range(1,25):
-            exp = my_exp[cur_exponent]
-            #partie constante du rapport d = lamda'^(3/4)*lambda^(1/4)*U^2/8/(s-1)/g/theta_cr
-            cst = f_flow**(1-exp)*u_abs**2/(8*(s-1)*GRAVITY*theta_cr)
-            #boucle pour converger sur un diamètre qui respecte l'égalité
-            k_sur_h = d/(4*h)
-            f_grain = f_barr_bathurst(k_sur_h,Reynolds)
-            f_obj = d-f_grain**exp*cst
-            nb_ite = 0
-            while abs(f_obj) > 1.e-6 and nb_ite < 20:
-                  #calcul de la dérivée numérique
-                  k_sur_h = (d+1.e-6)/(4*h)
-                  f_pert1 = f_barr_bathurst(k_sur_h,Reynolds)
-                  k_sur_h = (d-1.e-6)/(4*h)
-                  f_pert2 = f_barr_bathurst(k_sur_h,Reynolds)
-                  dfdd = 1-cst*exp*f_grain**(exp-1)*(f_pert1-f_pert2)/2.e-6
-                  frac = f_obj/dfdd
-                  #modifiation de d
-                  if abs(frac) > 0.5*d:
-                        if frac>0:
-                              frac = 0.5*d
-                        else:
-                              frac = -0.5*d
-                  d = d - frac
-                  #calcul de la nouvelle donction objectif
-                  k_sur_h = d/(4*h)
-                  f_grain = f_barr_bathurst(k_sur_h,Reynolds)
-                  f_obj = d-f_grain**exp*cst
-                  nb_ite = nb_ite + 1
-
-      return d
-
-def izbach_d_cr(q,h,rhom=2650,rho=RHO_PUREWATER,method='ridder'):
+def izbach_d_cr(q:float, h:float, rhom:float=2650, rho:float=RHO_PUREWATER, method='ridder') -> float:
       """
       https://en.wikipedia.org/wiki/Izbash_formula
 
@@ -546,9 +534,98 @@ def izbach_d_cr(q,h,rhom=2650,rho=RHO_PUREWATER,method='ridder'):
       --> d = u_c**2 / (s * g) / 1.7**2
 
       --> d = (0.85 * q/h)**2 / (s * 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')
       """
       s = rhom/rho
-      # return (0.85 * q/h)**2. / ((s-1.) * GRAVITY) / 1.7**2.
-      # return 0.7 * (0.85*q/h)**2. / (2 * GRAVITY) / (s-1.)
-      # return (q/h)**2. / (2 * GRAVITY) / (s-1.) / .86**2
+      #      (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
+
+
+## Portage de WOLF2D - Fortran pour Barr-Bathurst
+
+# def get_Shields_2D_pw(s:float, d:float, q_abs:float, h:float, k_rough:float, which_law = 'Manning'):
+#       """
+#       """
+#       # calcul de terme de pente de frottement
+#       if which_law == 'Manning':
+
+#             j = (q_abs/h)**2.0 / k_rough**2. / h**(4./3.)
+
+#       elif which_law == 'Barr_Bathurst':
+#             k_sur_h = k_rough/(4.0*h)
+#             Reynolds = 4.0 * q_abs /KIN_VISCOSITY # u*4h/nu == 4q/nu
+#             j = f_barr_bathurst(k_sur_h,Reynolds)/(4.0*h) * (q_abs/h)**2.0/2.0/GRAVITY
+
+#       shields = j*h / (d*(s-1))
+
+#       # shields = f/4 * u**2 /2 /g /(d * (rho_s-rho_w) / rho_w)
+#       # shields = tau / (rho_s - rho_w) /g /d
+#       # tau = f/8 * rho_w * u**2
+
+#       return shields
+
+# def get_effective_d_2D(s:float, theta_cr:float, q_abs:float, h:float, k_rough:float):
+#       """
+#       Calcul du diamètre de grain emporté par une approche basée sur une tension efficace
+
+#       Portage du code de calcul de WOLF2D
+#       @authors : Pierre Archambeau (2022)
+#       """
+
+#       #if which_friction_law#=rough_Barr_Bathurst:
+#        ##les autres lois de frottement ne sont pas implémentées mais aucune difficulté particulière
+#       ##ne devraient empêcher cela
+
+#       my_exp = [0.0, 0.10, 0.20, 0.30, 0.40, 0.420, 0.440, 0.460, 0.480,
+#                 0.50, 0.52, 0.54, 0.56, 0.58,
+#                 0.6, 0.62, 0.64, 0.66, 0.68,
+#                 0.7, 0.71, 0.72, 0.73, 0.74, 0.75]
+
+#       ##calcul du coefficient de frottement (point de vue de l'écoulement)
+#       u_abs = q_abs/h
+#       Reynolds = q_abs * 4 / KIN_VISCOSITY
+#       k_sur_h = k_rough/(4*h)
+#       f_flow = f_barr_bathurst(k_sur_h,Reynolds)
+
+#       #valeur initiale (pas de tension efficace)
+#       exp = my_exp[0]
+#       d = f_flow**(1-exp)*u_abs**2/(8*(s-1)*GRAVITY*theta_cr)
+#       #boucle pour approcher les exposants requis
+#       for cur_exponent in range(1,25):
+#             exp = my_exp[cur_exponent]
+#             #partie constante du rapport d = lamda'^(3/4)*lambda^(1/4)*U^2/8/(s-1)/g/theta_cr
+#             cst = f_flow**(1-exp)*u_abs**2/(8*(s-1)*GRAVITY*theta_cr)
+#             #boucle pour converger sur un diamètre qui respecte l'égalité
+#             k_sur_h = d/(4*h)
+#             f_grain = f_barr_bathurst(k_sur_h,Reynolds)
+#             f_obj = d-f_grain**exp*cst
+#             nb_ite = 0
+#             while abs(f_obj) > 1.e-6 and nb_ite < 20:
+#                   #calcul de la dérivée numérique
+#                   k_sur_h = (d+1.e-6)/(4*h)
+#                   f_pert1 = f_barr_bathurst(k_sur_h,Reynolds)
+#                   k_sur_h = (d-1.e-6)/(4*h)
+#                   f_pert2 = f_barr_bathurst(k_sur_h,Reynolds)
+#                   dfdd = 1-cst*exp*f_grain**(exp-1)*(f_pert1-f_pert2)/2.e-6
+#                   frac = f_obj/dfdd
+#                   #modifiation de d
+#                   if abs(frac) > 0.5*d:
+#                         if frac>0:
+#                               frac = 0.5*d
+#                         else:
+#                               frac = -0.5*d
+#                   d = d - frac
+#                   #calcul de la nouvelle donction objectif
+#                   k_sur_h = d/(4*h)
+#                   f_grain = f_barr_bathurst(k_sur_h,Reynolds)
+#                   f_obj = d-f_grain**exp*cst
+#                   nb_ite = nb_ite + 1
+
+#       return d