wolfhece 2.2.28__py3-none-any.whl → 2.2.30__py3-none-any.whl

wolfhece/lb7208_ntv2/be_ign_README.txt

@@ -0,0 +1,36 @@
+# be_ign_README.txt
+
+The files in this section result from the conversion of datasets originating
+from [IGN Belgium](http://www.ngi.be)
+
+## Included grids
+
+### Belgium: BD72 -> ETRS89
+
+Grid transformation from Belgium Datum 72 to ETRS89 in Belgium.
+
+*Source*: [IGN](http://www.ngi.be/Common/Lambert2008/NTv2.zip)
+*Format*: GeoTIFF converted from NTv2
+*License*: [Creative Commons Attribution 4.0](https://creativecommons.org/licenses/by/4.0/)
+*Credit*: (c)2014-2016 Grid created by Nicolas SIMON.
+
+It provides an accuracy better than 5mm in 99.6% of validation points and a
+worst case of 1.3 cm outside the border.
+Recommended to transform from Belgian Lambert 72 (EPSG:31370) to Belgian Lambert 2008 (EPSG:3812)
+Documentation in French: (http://www.ngi.be/FR/FR2-1-7.shtm)
+Documentation in Dutch:  (http://www.ngi.be/NL/NL2-1-7.shtm)
+
+* be_ign_bd72lb72_etrs89lb08.tif
+
+### Belgium vertical grid:
+
+*Source*: [IGN](https://www.ngi.be/website/wp-content/uploads/2020/07/hBG18_fr.zip)
+*Format*: GeoTIFF converted from 'XYZ ASCII Grid'
+*License*: [Creative Commons Attribution 4.0](https://creativecommons.org/licenses/by/4.0/)
+*Credit*: C. Slobbe, R. Klees, H.H. Farahani, L. Huisman, B. Alberts, P. Voet, F. De Doncker (2018). The Belgian hybrid quasi-geoid: hBG18. V. 1.0. GFZ Data Services. http://doi.org/10.5880/isg.2018.003  
+*Horizontal CRS*: EPSG:4937 (ETRS89)
+
+Vertical transformation for Geoid model hGB18. Used to make the transitions 
+from heights in vertical CRS (EPSG:5710 - Ostend height) to heights above the ellipsoid in ETRS89 (EPSG:4937).
+
+* be_ign_hBG18.tif

wolfhece/mesh2d/gpu_2d.py

@@ -88,8 +88,17 @@ class Sim_2D_GPU():
         self.magnetic_grid:header_wolf = None
 
         if (self.dir /'parameters.json').exists():
-            self._sim = SimpleSimulation.load(self.dir)
-            self.infiltration = infiltration_GPU(self)
+            try:
+                self._sim = SimpleSimulation.load(self.dir)
+            except Exception as e:
+                logging.error(_("Error loading simulation from directory {dir}: {error}").format(dir=self.dir, error=str(e)))
+                logging.error(_("Please check your files and try again."))
+                return
+
+            try:
+                self.infiltration = infiltration_GPU(self)
+            except Exception as e:
+                logging.error(_("Error initializing infiltration GPU: {error}").format(error=str(e)))
 
         # Fine arrays with type
         self.files_array={'Characteristics':[

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