wolfhece 2.2.18__py3-none-any.whl → 2.2.23__py3-none-any.whl

wolfhece/mesh2d/simple_2d.py

@@ -322,6 +322,8 @@ def Euler_RK_hedge(h_t1:np.ndarray, h_t2:np.ndarray,
     do = 1
 
     # valeur à gauche du bord
+    # -----------------------
+
     q_border[slice_right_border, up] = q[1:-1]
     q_border[1,up]  = CL_q
 
@@ -335,6 +337,8 @@ def Euler_RK_hedge(h_t1:np.ndarray, h_t2:np.ndarray,
     theta_border[1,up]  = theta[1]
 
     # valeur à droite du bord
+    # ------------------------
+
     q_border[slice_left_border, do] = q[1:-1]
     q_border[-1,do] = q[-2]
 
@@ -380,6 +384,16 @@ def splitting(q_left:np.float64, q_right:np.float64,
               z_bridge_left:np.float64, z_bridge_right:np.float64) -> np.ndarray:
     """ Splitting of the unknowns at border between two nodes
     -- Based on the WOLF HECE original scheme
+
+    :param q_left: Discharge at the left-side of the border
+    :param q_right: Discharge at the right-side of the border
+    :param h_left: Water depth at the left-side of the border
+    :param h_right: Water depth at the right-side of the border
+    :param z_left: Bed elevation at the left-side of the border
+    :param z_right: Bed elevation at the right-side of the border
+    :param z_bridge_left: Bridge elevation at the left-side of the border
+    :param z_bridge_right: Bridge elevation at the right-side of the border
+    :return: Array of the unknowns according to the WOLF HECE scheme
     """
 
     prod_q = q_left * q_right
@@ -421,55 +435,86 @@ def Euler_RK_bridge(h_t1:np.ndarray, h_t2:np.ndarray,
           n:float, u_border:np.ndarray,
           h_center:np.ndarray, u_center:np.ndarray,
           z_bridge:np.ndarray, z_bridge_border:np.ndarray,
-          press_mode:int=0,
           infil_exfil=None) -> None:
     """
     Solve the mass and momentum equations using a explicit Euler/Runge-Kutta scheme (only 1 step)
     applying source terms for infiltration/exfiltration and pressure at the roof.
+
+    :param h_t1: Water depth at time t
+    :param h_t2: Water depth at time t+dt (or t_star or t_doublestar if RK)
+    :param q_t1: Discharge at time t
+    :param q_t2: Discharge at time t+dt (or t_star or t_doublestar if RK)
+    :param h:    Water depth at the mesh center
+    :param q:    Discharge at the mesh center
+    :param h_border: Water depth at the mesh border
+    :param q_border: Discharge at the mesh border
+    :param z:    Bed elevation
+    :param z_border: Bed elevation at the mesh border
+    :param dt:   Time step
+    :param dx:   Space step
+    :param CL_h: Downstream boudary condition for water depth
+    :param CL_q: Upstream boundary condition for discharge
+    :param n:    Manning coefficient
+    :param u_border: Velocity at the mesh border
+    :param h_center: Water depth at the mesh center
+    :param u_center: Velocity at the mesh center
+    :param z_bridge: Bridge elevation at the mesh center
+    :param z_bridge_border: Bridge elevation at the mesh border
+    :param infil_exfil: Infiltration/exfiltration parameters
     """
     g = 9.81
 
     slice_mesh = slice(1,-1)
-    slice_right_border = slice(2,None)
-    slice_left_border = slice(1,-1)
+
+    #    L           R      L = Left border, R = Right border
+    #   l|r         l|r     l = left value, r = right value
+    #    |     i     |      i = node indice
+    #    |           |
+    #    i          i+1     i, i+1 = associated borders
+    slice_right_border = slice(2,None) # right border - left value - slice associated to the center values
+    slice_left_border = slice(1,-1)    # left border  - right value - slice associated to the center values
 
     up = 0
     do = 1
 
-    # valeur à gauche du bord
-    z_border[slice_right_border, up] = z[1:-1]
-    z_border[1,up] = z[1]
-
+    # altitude du pont
     z_bridge_copy = z_bridge.copy()
 
-    fs_cells = np.where(h <= z_bridge - z)[0]
-    press_cells = np.where(h > z_bridge - z)[0]
+    fs_cells    = np.where(h <= z_bridge - z)[0] # mailles à surface libre
+    press_cells = np.where(h > z_bridge - z)[0]  # mailles sous-pression
 
-    z_bridge_copy[fs_cells] = z[fs_cells] + h[fs_cells]
+    z_bridge_copy[fs_cells] = z[fs_cells] + h[fs_cells] # on recopie l'altitude de SL
+
+    # valeur à gauche du bord
+    # -----------------------
+
+    # altitude du fond
+    z_border[slice_right_border, up] = z[1:-1]
+    z_border[1,up] = z[1]  # tout en amont, recopie de la valeur intérieure
 
     h_border[slice_right_border, up] = h[1:-1]
-    h_border[1,up] = h[1]
+    h_border[1,up] = h[1]  # tout en amont, recopie de la valeur intérieure
 
     q_border[slice_right_border, up] = q[1:-1]
-    q_border[1,up] = CL_q
-
-    # valeur à droite du bord
-    z_border[slice_left_border, do] = z[1:-1]
-    z_border[-1,do] = z[-2]
+    q_border[1,up] = CL_q  # condition limite de debit
 
     z_bridge_border[slice_right_border, up] = z_bridge_copy[1:-1]
     z_bridge_border[1,up] = z_bridge_copy[1]
 
-    z_bridge_border[slice_left_border, do] = z_bridge_copy[1:-1]
-    z_bridge_border[-1,do] = z_bridge_copy[-2]
+    # valeur à droite du bord
+    # ------------------------
+
+    z_border[slice_left_border, do] = z[1:-1]
+    z_border[-1,do] = z[-2] # tout en aval, recopie de la valeur intérieure
 
     h_border[slice_left_border, do] = h[1:-1]
-    h_border[-1,do] = CL_h
+    h_border[-1,do] = CL_h  # condition limite de hauteur
 
     q_border[slice_left_border, do] = q[1:-1]
-    q_border[-1,do] = q[-2]
-
+    q_border[-1,do] = q[-2] # tout en aval, recopie de la valeur intérieure
 
+    z_bridge_border[slice_left_border, do] = z_bridge_copy[1:-1]
+    z_bridge_border[-1,do] = CL_h + z_border[-1,do] # z_bridge_copy[-2]
 
     for i in range(1, len(h)-1):
 
@@ -714,7 +759,7 @@ def problem(dom:np.ndarray, z:np.ndarray, h0:float, q0:float, dx:float, CN:float
 def problem_hedge(dom:np.ndarray, z:np.ndarray, h0:float, q0:float, dx:float, CN:float, n:float):
     """ Solve the mass and momentum equations using a explicit Runge-Kutta scheme (2 steps - 2nd order)
 
-    **NO BRIDGE bur HEDGE in the middle**
+    **NO BRIDGE but HEDGE in the middle**
     """
 
     h, q, h_pred, q_pred, h_corr, q_corr, q_border, h_border, z_border, u_border, h_center, u_center = all_unk_border(dom, h0, q0)
@@ -755,7 +800,6 @@ def problem_hedge(dom:np.ndarray, z:np.ndarray, h0:float, q0:float, dx:float, CN
 def problem_bridge(dom:np.ndarray, z:np.ndarray, z_bridge:np.ndarray,
                    h0:float, q0:float,
                    dx:float, CN:float, n:float,
-                   press_mode:int = 4,
                    h_ini:np.ndarray = None, q_ini:np.ndarray = None) -> tuple[np.ndarray]:
     """ Solve the mass and momentum equations using a explicit Rung-Kutta scheme (2 steps - 2nd order)
 
@@ -778,9 +822,9 @@ def problem_bridge(dom:np.ndarray, z:np.ndarray, z_bridge:np.ndarray,
         while eps > 1e-7:
             dt = compute_dt(dx, h, q, CN)
             # Predictor step
-            Euler_RK_bridge(h, h_pred, q, q_pred, h, q, h_border, q_border, z, z_border, dt, dx, h0, q0, n, u_border, h_center, u_center, z_bridge, z_bridge_border, press_mode)
+            Euler_RK_bridge(h, h_pred, q, q_pred, h, q, h_border, q_border, z, z_border, dt, dx, h0, q0, n, u_border, h_center, u_center, z_bridge, z_bridge_border)
             # Corrector step
-            Euler_RK_bridge(h, h_corr, q, q_corr, h_pred, q_pred, h_border, q_border, z, z_border, dt, dx, h0, q0, n, u_border, h_center, u_center, z_bridge, z_bridge_border, press_mode)
+            Euler_RK_bridge(h, h_corr, q, q_corr, h_pred, q_pred, h_border, q_border, z, z_border, dt, dx, h0, q0, n, u_border, h_center, u_center, z_bridge, z_bridge_border)
 
             # Update -- Mean for second order in time
             h = (h_pred + h_corr)/2.
@@ -799,7 +843,7 @@ def problem_bridge(dom:np.ndarray, z:np.ndarray, z_bridge:np.ndarray,
 def problem_bridge_multiple_steadystates(dom:np.ndarray, z:np.ndarray, z_bridge:np.ndarray,
                                          h0:float, qmin:float, qmax:float,
                                          dx:float, CN:float, n:float,
-                                         press_mode:int = 4) -> list[tuple[float, np.ndarray, np.ndarray]]:
+                                         ) -> list[tuple[float, np.ndarray, np.ndarray]]:
     """ Solve multiple steady states for a given discharge range """
 
     all_q = np.arange(qmin, qmax+.1, (qmax-qmin)/10)
@@ -807,7 +851,7 @@ def problem_bridge_multiple_steadystates(dom:np.ndarray, z:np.ndarray, z_bridge:
     ret = []
     h = None
     for curq in all_q:
-        h, q = problem_bridge(dom, z, z_bridge, h0, curq, dx, CN, n, press_mode, h_ini=h, q_ini=None)
+        h, q = problem_bridge(dom, z, z_bridge, h0, curq, dx, CN, n, h_ini=h, q_ini=None)
         ret.append((0., h.copy(), q.copy()))
 
     return ret
@@ -815,7 +859,7 @@ def problem_bridge_multiple_steadystates(dom:np.ndarray, z:np.ndarray, z_bridge:
 def problem_bridge_unsteady(dom:np.ndarray, z:np.ndarray, z_bridge:np.ndarray,
                             h0:float, q0:float,
                             dx:float, CN:float, n:float,
-                            press_mode:int = 4):
+                            ):
     """ Solve the mass and momentum equations using a explicit Runge-Kutta scheme (2 steps - 2nd order).
 
     **WITH BRIDGE and NO OVERFLOW**
@@ -839,9 +883,9 @@ def problem_bridge_unsteady(dom:np.ndarray, z:np.ndarray, z_bridge:np.ndarray,
         while eps > 1e-7:
             dt = compute_dt(dx, h, q, CN)
             # Predictor step
-            Euler_RK_bridge(h, h_pred, q, q_pred, h, q, h_border, q_border, z, z_border, dt, dx, h0, q0, n, u_border, h_center, u_center, z_bridge, z_bridge_border, press_mode)
+            Euler_RK_bridge(h, h_pred, q, q_pred, h, q, h_border, q_border, z, z_border, dt, dx, h0, q0, n, u_border, h_center, u_center, z_bridge, z_bridge_border)
             # Corrector step
-            Euler_RK_bridge(h, h_corr, q, q_corr, h_pred, q_pred, h_border, q_border, z, z_border, dt, dx, h0, q0, n, u_border, h_center, u_center, z_bridge, z_bridge_border, press_mode)
+            Euler_RK_bridge(h, h_corr, q, q_corr, h_pred, q_pred, h_border, q_border, z, z_border, dt, dx, h0, q0, n, u_border, h_center, u_center, z_bridge, z_bridge_border)
 
             # Update -- Mean for second order in time
             h = (h_pred + h_corr)/2.
@@ -871,9 +915,9 @@ def problem_bridge_unsteady(dom:np.ndarray, z:np.ndarray, z_bridge:np.ndarray,
                 h_cl = h0 + 7. - 7. * (t - totaltime/2)/totaltime*2
 
             # Predictor step
-            Euler_RK_bridge(h, h_pred, q, q_pred, h, q, h_border, q_border, z, z_border, dt, dx, h_cl, q0, n, u_border, h_center, u_center, z_bridge, z_bridge_border, press_mode)
+            Euler_RK_bridge(h, h_pred, q, q_pred, h, q, h_border, q_border, z, z_border, dt, dx, h_cl, q0, n, u_border, h_center, u_center, z_bridge, z_bridge_border)
             # Corrector step
-            Euler_RK_bridge(h, h_corr, q, q_corr, h_pred, q_pred, h_border, q_border, z, z_border, dt, dx, h_cl, q0, n, u_border, h_center, u_center, z_bridge, z_bridge_border, press_mode)
+            Euler_RK_bridge(h, h_corr, q, q_corr, h_pred, q_pred, h_border, q_border, z, z_border, dt, dx, h_cl, q0, n, u_border, h_center, u_center, z_bridge, z_bridge_border)
 
             # Update -- Mean for second order in time
             h = (h_pred + h_corr)/2.
@@ -893,7 +937,6 @@ def problem_bridge_unsteady_topo(dom:np.ndarray, z:np.ndarray,
                                  z_roof:np.ndarray, z_deck:np.ndarray, z_roof_null:float,
                                  h0:float, q0:float,
                                  dx:float, CN:float, n:float,
-                                 press_mode:int = 0,
                                  motion_duration:float = 300.,
                                  scenario_bc:Literal['unsteady_downstream_bc',
                                                      'hydrograph',
@@ -919,9 +962,9 @@ def problem_bridge_unsteady_topo(dom:np.ndarray, z:np.ndarray,
         while eps > 1e-7:
             dt = compute_dt(dx, h, q, CN)
             # Predictor step
-            Euler_RK_bridge(h, h_pred, q, q_pred, h, q, h_border, q_border, z, z_border, dt, dx, h0, q0, n, u_border, h_center, u_center, z_roof, z_roof_border, press_mode)
+            Euler_RK_bridge(h, h_pred, q, q_pred, h, q, h_border, q_border, z, z_border, dt, dx, h0, q0, n, u_border, h_center, u_center, z_roof, z_roof_border)
             # Corrector step
-            Euler_RK_bridge(h, h_corr, q, q_corr, h_pred, q_pred, h_border, q_border, z, z_border, dt, dx, h0, q0, n, u_border, h_center, u_center, z_roof, z_roof_border, press_mode)
+            Euler_RK_bridge(h, h_corr, q, q_corr, h_pred, q_pred, h_border, q_border, z, z_border, dt, dx, h0, q0, n, u_border, h_center, u_center, z_roof, z_roof_border)
 
             # Update -- Mean for second order in time
             h = (h_pred + h_corr)/2.
@@ -1216,13 +1259,13 @@ def problem_bridge_unsteady_topo(dom:np.ndarray, z:np.ndarray,
             Euler_RK_bridge(h, h_pred, q, q_pred, h, q, h_border, q_border, z, z_border,
                             dt, dx, h_cl, q_cl,
                             n, u_border, h_center, u_center, z_roof, z_roof_border,
-                            press_mode, infil_exfil)
+                            infil_exfil)
 
             # Corrector step
             Euler_RK_bridge(h, h_corr, q, q_corr, h_pred, q_pred, h_border, q_border, z, z_border,
                             dt, dx, h_cl, q_cl,
                             n, u_border, h_center, u_center, z_roof, z_roof_border,
-                            press_mode, infil_exfil)
+                            infil_exfil)
 
             # Update -- Mean for second order in time
             h = (h_pred + h_corr)/2.
@@ -1603,7 +1646,6 @@ def lake_at_rest():
     q0 = 0. # Initial discharge
     n  = 0.025
     slope = 0 #1e-4
-    press_mode = 4
 
     hu = 0
 
@@ -1619,7 +1661,7 @@ def lake_at_rest():
     # free surface flow
     h1, q1 = problem(dom, z, h0, q0, dx, CN, n)
     # partially pressurized flow
-    h2, q2 = problem_bridge(dom, z, z_bridge, h0, q0, dx, CN, n, press_mode=press_mode)
+    h2, q2 = problem_bridge(dom, z, z_bridge, h0, q0, dx, CN, n)
 
     assert np.allclose(h1[1:-1], h0), 'Free surface flow is not steady state'
     assert np.allclose(q1[1:-1], q0), 'Free surface flow is not steady state'
@@ -1634,7 +1676,7 @@ def lake_at_rest():
     # free surface flow
     h1, q1 = problem(dom, z, h0+1., q0, dx, CN, n)
     # partially pressurized flow
-    h2, q2 = problem_bridge(dom, z, z_bridge, h0, q0, dx, CN, n, press_mode=press_mode)
+    h2, q2 = problem_bridge(dom, z, z_bridge, h0, q0, dx, CN, n)
 
     assert np.allclose(h1[1:-1], h0+1.), 'Free surface flow is not steady state'
     assert np.allclose(q1[1:-1], q0), 'Free surface flow is not steady state'
@@ -1649,7 +1691,7 @@ def lake_at_rest():
     # free surface flow
     h1, q1 = problem(dom, z, h0+2., q0, dx, CN, n)
     # partially pressurized flow
-    h2, q2 = problem_bridge(dom, z, z_bridge, h0, q0, dx, CN, n, press_mode=press_mode)
+    h2, q2 = problem_bridge(dom, z, z_bridge, h0, q0, dx, CN, n)
 
     assert np.allclose(h1[1:-1], h0+2.), 'Free surface flow is not steady state'
     assert np.allclose(q1[1:-1], q0), 'Free surface flow is not steady state'
@@ -1683,7 +1725,6 @@ def water_line():
     q0 = 7.
     n  = 0.025
     slope = 1e-4
-    press_mode = 4
 
     dom, x, z = domain(length, dx, slope)
     x = np.array(x)
@@ -1699,17 +1740,17 @@ def water_line():
     fig, axes = plt.subplots(3,1)
 
     h1, q1 = problem(dom, z, h0, q0, dx, CN, n)
-    h2, q2 = problem_bridge(dom, z, z_bridge, h0, q0, dx, CN, n, press_mode=press_mode)
+    h2, q2 = problem_bridge(dom, z, z_bridge, h0, q0, dx, CN, n)
 
     plot_bridge(axes[0], x, h1, h2, q1, q2, z, z_bridge, hu)
 
     h1, q1 = problem(dom, z, h0+1., q0, dx, CN, n)
-    h2, q2 = problem_bridge(dom, z, z_bridge, h0+1., q0, dx, CN, n, press_mode=press_mode)
+    h2, q2 = problem_bridge(dom, z, z_bridge, h0+1., q0, dx, CN, n)
 
     plot_bridge(axes[1], x, h1, h2, q1, q2, z, z_bridge, hu)
 
     h1, q1 = problem(dom, z, h0+2., q0, dx, CN, n)
-    h2, q2 = problem_bridge(dom, z, z_bridge, h0+2., q0, dx, CN, n, press_mode=press_mode)
+    h2, q2 = problem_bridge(dom, z, z_bridge, h0+2., q0, dx, CN, n)
 
     plot_bridge(axes[2], x, h1, h2, q1, q2, z, z_bridge, hu)
 
@@ -1737,7 +1778,6 @@ def water_line_noloss_noslope():
     q0 = 7.
     n  = 0.
     slope = 0.
-    press_mode = 4
 
     dom, x, z = domain(length, dx, slope)
     x = np.array(x)
@@ -1753,17 +1793,17 @@ def water_line_noloss_noslope():
     fig, axes = plt.subplots(3,1)
 
     h1, q1 = problem(dom, z, h0, q0, dx, CN, n)
-    h2, q2 = problem_bridge(dom, z, z_bridge, h0, q0, dx, CN, n, press_mode=press_mode)
+    h2, q2 = problem_bridge(dom, z, z_bridge, h0, q0, dx, CN, n)
 
     plot_bridge(axes[0], x, h1, h2, q1, q2, z, z_bridge, hu)
 
     h1, q1 = problem(dom, z, h0+1., q0, dx, CN, n)
-    h2, q2 = problem_bridge(dom, z, z_bridge, h0+1., q0, dx, CN, n, press_mode=press_mode)
+    h2, q2 = problem_bridge(dom, z, z_bridge, h0+1., q0, dx, CN, n)
 
     plot_bridge(axes[1], x, h1, h2, q1, q2, z, z_bridge, hu)
 
     h1, q1 = problem(dom, z, h0+2., q0, dx, CN, n)
-    h2, q2 = problem_bridge(dom, z, z_bridge, h0+2., q0, dx, CN, n, press_mode=press_mode)
+    h2, q2 = problem_bridge(dom, z, z_bridge, h0+2., q0, dx, CN, n)
 
     plot_bridge(axes[2], x, h1, h2, q1, q2, z, z_bridge, hu)
 
@@ -1786,7 +1826,6 @@ def water_lines():
     q0 = 7.
     n  = 0. #0.025
     slope = 0 #1e-4
-    press_mode = 4
 
     dom, x, z = domain(length, dx, slope)
     x = np.array(x)
@@ -1803,7 +1842,7 @@ def water_lines():
     idx_bridge = len(dom)//2
 
     h0 = 4.5
-    res = problem_bridge_multiple_steadystates(dom, z, z_bridge, h0, 3.5, 20., dx, CN, n, press_mode=press_mode)
+    res = problem_bridge_multiple_steadystates(dom, z, z_bridge, h0, 3.5, 20., dx, CN, n)
 
     fig, axes = plt.subplots(2,1)
 
@@ -1880,7 +1919,6 @@ def unsteady_without_bedmotion():
     q0 = 7.
     n  = 0. #0.025
     slope = 0 #1e-4
-    press_mode = 4
 
     dom, x, z = domain(length, dx, slope)
     x = np.array(x)
@@ -1897,7 +1935,7 @@ def unsteady_without_bedmotion():
     idx_bridge = len(dom)//2
 
     h0 = 1.5
-    res = problem_bridge_unsteady(dom, z, z_bridge, h0, q0, dx, CN, n, press_mode=press_mode)
+    res = problem_bridge_unsteady(dom, z, z_bridge, h0, q0, dx, CN, n)
 
     fig, axes = plt.subplots(2,1)
 
@@ -1993,7 +2031,6 @@ def unsteady_with_bedmotion(problems:list[int], save_video:bool = False) -> list
     q0 = 7.
     n  = 0.025
     slope = 0 #1e-4
-    press_mode = 4
 
     dom, x, z = domain(length, dx, slope)
     x = np.array(x)
@@ -2053,7 +2090,6 @@ def unsteady_with_bedmotion(problems:list[int], save_video:bool = False) -> list
             res = problem_bridge_unsteady_topo(dom, z,
                                                z_bridge, z_deck, z_roof_null,
                                                h0, q0, dx, CN, n,
-                                               press_mode= press_mode,
                                                motion_duration= motion_duration,
                                                scenario_bc= scenario,
                                                min_overflow= min_overflow)
@@ -2121,7 +2157,6 @@ def unsteady_with_bedmotion(problems:list[int], save_video:bool = False) -> list
             res = problem_bridge_unsteady_topo(dom, z, z_bridge,
                                                z_deck, z_roof_null,
                                                h0, q0, dx, CN, n,
-                                               press_mode=press_mode,
                                                motion_duration=motion_duration,
                                                scenario_bc=scenario,
                                                min_overflow=min_overflow)
@@ -2187,7 +2222,6 @@ def unsteady_with_bedmotion(problems:list[int], save_video:bool = False) -> list
             res = problem_bridge_unsteady_topo(dom, z, z_bridge,
                                                z_deck, z_roof_null,
                                                h0, q0, dx, CN, n,
-                                               press_mode=press_mode,
                                                motion_duration=motion_duration,
                                                scenario_bc=scenario,
                                                min_overflow=min_overflow)
@@ -2255,7 +2289,6 @@ def unsteady_with_bedmotion(problems:list[int], save_video:bool = False) -> list
             res = problem_bridge_unsteady_topo(dom, z,
                                                z_bridge, z_deck, z_roof_null,
                                                h0, q0, dx, CN, n,
-                                               press_mode=press_mode,
                                                motion_duration=motion_duration,
                                                scenario_bc=scenario,
                                                min_overflow= min_overflow)
@@ -2330,7 +2363,6 @@ def unsteady_with_bedmotion(problems:list[int], save_video:bool = False) -> list
             res = problem_bridge_unsteady_topo(dom, z,
                                                z_bridge, z_deck, z_roof_null,
                                                h0, q0, dx, CN, n,
-                                               press_mode=press_mode,
                                                motion_duration=motion_duration,
                                                scenario_bc=scenario,
                                                min_overflow= min_overflow)
@@ -2389,7 +2421,6 @@ def unsteady_with_bedmotion_interval(problems:list[int], save_video:bool = False
     q0 = 7.
     n  = 0.025
     slope = 0 #1e-4
-    press_mode = 4
 
     dom, x, z = domain(length, dx, slope)
     x = np.array(x)
@@ -2448,7 +2479,6 @@ def unsteady_with_bedmotion_interval(problems:list[int], save_video:bool = False
             res = problem_bridge_unsteady_topo(dom, z,
                                                z_bridge, z_deck, z_roof_null,
                                                h0, q0, dx, CN, n,
-                                               press_mode= press_mode,
                                                motion_duration= motion_duration,
                                                scenario_bc= scenario,
                                                min_overflow= min_overflow,
@@ -2516,7 +2546,6 @@ def unsteady_with_bedmotion_interval(problems:list[int], save_video:bool = False
             res = problem_bridge_unsteady_topo(dom, z, z_bridge,
                                                z_deck, z_roof_null,
                                                h0, q0, dx, CN, n,
-                                               press_mode=press_mode,
                                                motion_duration=motion_duration,
                                                scenario_bc=scenario,
                                                min_overflow=min_overflow,
@@ -2582,7 +2611,6 @@ def unsteady_with_bedmotion_interval(problems:list[int], save_video:bool = False
             res = problem_bridge_unsteady_topo(dom, z, z_bridge,
                                                z_deck, z_roof_null,
                                                h0, q0, dx, CN, n,
-                                               press_mode=press_mode,
                                                motion_duration=motion_duration,
                                                scenario_bc=scenario,
                                                min_overflow=min_overflow,
@@ -2650,7 +2678,6 @@ def unsteady_with_bedmotion_interval(problems:list[int], save_video:bool = False
             res = problem_bridge_unsteady_topo(dom, z,
                                                z_bridge, z_deck, z_roof_null,
                                                h0, q0, dx, CN, n,
-                                               press_mode=press_mode,
                                                motion_duration=motion_duration,
                                                scenario_bc=scenario,
                                                min_overflow= min_overflow,
@@ -2725,7 +2752,6 @@ def unsteady_with_bedmotion_interval(problems:list[int], save_video:bool = False
             res = problem_bridge_unsteady_topo(dom, z,
                                                z_bridge, z_deck, z_roof_null,
                                                h0, q0, dx, CN, n,
-                                               press_mode=press_mode,
                                                motion_duration=motion_duration,
                                                scenario_bc=scenario,
                                                min_overflow= min_overflow,
@@ -2745,7 +2771,6 @@ def unsteady_with_bedmotion_interval(problems:list[int], save_video:bool = False
     return anims
 
 
-
 def hedge():
     """ Compute Water line problems with hedge
 
@@ -2801,12 +2826,12 @@ def hedge():
 
 if __name__  == '__main__':
 
-    # anim = steady()
-    # anim = water_line()
+    # anim = lake_at_rest()
+    anim = water_line()
     # anim = water_lines()
     # anim = unsteady_without_bedmotion()
     # anim = unteaady_with_bedmotion([2, 6, 7, 8, 9])
-    anim = hedge()
+    # anim = hedge()
     # anim = water_line_noloss_noslope()
 
     # anim1 = unsteady_with_bedmotion([2])

wolfhece/report/pdf.py

@@ -0,0 +1,55 @@
+""" WX Frame displaying a PDF file """
+import wx
+import wx.lib.sized_controls as sc
+from wx.lib.pdfviewer import pdfViewer, pdfButtonPanel
+
+from pathlib import Path
+
+class PDFViewer(sc.SizedFrame):
+
+    def __init__(self, parent, **kwargs):
+        """ Initialize the PDF Viewer Frame """
+        super(PDFViewer, self).__init__(parent, **kwargs)
+
+        paneCont = self.GetContentsPane()
+        self.buttonpanel = pdfButtonPanel(paneCont, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, 0)
+        self.buttonpanel.SetSizerProps(expand=True)
+
+        self.viewer:pdfViewer
+        self.viewer = pdfViewer(paneCont, wx.ID_ANY, wx.DefaultPosition,
+                                wx.DefaultSize,
+                                wx.HSCROLL|wx.VSCROLL|wx.SUNKEN_BORDER)
+
+        self.viewer.SetSizerProps(expand=True, proportion=1)
+
+        # introduce buttonpanel and viewer to each other
+        self.buttonpanel.viewer = self.viewer
+        self.viewer.buttonpanel = self.buttonpanel
+
+        icon = wx.Icon()
+        icon_path = Path(__file__).parent.parent / "apps/wolf_logo2.bmp"
+        icon.CopyFromBitmap(wx.Bitmap(str(icon_path), wx.BITMAP_TYPE_ANY))
+        self.SetIcon(icon)
+
+
+    def load_pdf(self, pdf_path:str):
+        """ Load a PDF file into the viewer """
+
+        if not Path(pdf_path).exists():
+            wx.MessageBox("PDF file does not exist.", "Error", wx.OK | wx.ICON_ERROR)
+            return
+
+        try:
+            self.viewer.LoadFile(str(pdf_path))
+        except Exception as e:
+            wx.MessageBox("Failed to load PDF file.", "Error", wx.OK | wx.ICON_ERROR)
+
+if __name__ == '__main__':
+    import wx.lib.mixins.inspection as WIT
+    app = WIT.InspectableApp(redirect=False)
+
+    pdfV = PDFViewer(None)
+    pdfV.load_pdf(Path(__file__).parent.parent.parent /'tests' / 'data' / 'pdf' / "dummy.pdf")  # Change to your PDF file path
+    pdfV.Show()
+
+    app.MainLoop()