wolfhece 2.1.100__py3-none-any.whl → 2.1.101__py3-none-any.whl

wolfhece/mesh2d/simple_2d.py

@@ -288,7 +288,8 @@ def Euler_RK_hedge(h_t1:np.ndarray, h_t2:np.ndarray,
           dt:float, dx:float,
           CL_h:float, CL_q:float,
           n:float, u_border:np.ndarray,
-          h_center:np.ndarray, u_center:np.ndarray) -> None:
+          h_center:np.ndarray, u_center:np.ndarray,
+          theta:np.ndarray, theta_border:np.ndarray) -> None:
     """ Solve the mass and momentum equations using a explicit Euler/Runge-Kutta scheme (only 1 step)
 
     :param h_t1: Water depth at time t
@@ -311,9 +312,6 @@ def Euler_RK_hedge(h_t1:np.ndarray, h_t2:np.ndarray,
     :param u_center: Velocity at the mesh center
     """
 
-    theta = 0.2
-    slice_hedge = slice(len(h_t1) // 2-1, len(h_t1) // 2+2)
-
     g = 9.81
 
     slice_mesh = slice(1,-1)
@@ -333,6 +331,9 @@ def Euler_RK_hedge(h_t1:np.ndarray, h_t2:np.ndarray,
     z_border[slice_right_border, up] = z[1:-1]
     z_border[1,up]  = z[1]
 
+    theta_border[slice_right_border, up] = theta[1:-1]
+    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]
@@ -343,12 +344,14 @@ def Euler_RK_hedge(h_t1:np.ndarray, h_t2:np.ndarray,
     z_border[slice_left_border, do] = z[1:-1]
     z_border[-1,do] = z[-2]
 
-    u_border[1:] = q_border[1:,up]/h_border[1:,up]
+    theta_border[slice_left_border, do] = theta[1:-1]
+    theta_border[-1,do] = theta[-2]
 
-    u_border[slice_hedge] /= theta
 
-    h_center = (h_border[slice_right_border,do] + h_border[slice_left_border,do])/2.
-    u_center = q[slice_mesh]/h[slice_mesh]
+    u_border[1:] = q_border[1:,up]/(h_border[1:,up] * theta_border[1:,up])
+
+    h_center = (theta_border[slice_right_border,do] * h_border[slice_right_border,do] + theta_border[slice_left_border,do] * h_border[slice_left_border,do])/2.
+    u_center = q[slice_mesh]/(h[slice_mesh]*theta[slice_mesh])
 
     #Continuity
     h_t2[slice_mesh] = h_t1[slice_mesh] - dt/dx * (q_border[slice_right_border,up] - q_border[slice_left_border,up])
@@ -357,13 +360,13 @@ def Euler_RK_hedge(h_t1:np.ndarray, h_t2:np.ndarray,
 
     J = get_friction_slope_2D_Manning_semi_implicit(u_center, h[slice_mesh], n)
     qm_right = u_border[slice_right_border]*q_border[slice_right_border,up]
-    qm_left  = u_border[slice_left_border]*q_border[slice_left_border,up]
+    qm_left  = u_border[slice_left_border ]*q_border[slice_left_border,up]
 
-    press_right = 0.5 * g * h_border[slice_right_border,do]**2
-    press_left  = 0.5 * g * h_border[slice_left_border,do]**2
+    press_right = 0.5 * g * (theta_border[slice_right_border,do] * h_border[slice_right_border,do])**2
+    press_left  = 0.5 * g * (theta_border[slice_left_border ,do] * h_border[slice_left_border ,do])**2
 
-    bed_right = g * h_center * z_border[slice_right_border,do]
-    bed_left  = g * h_center * z_border[slice_left_border,do]
+    bed_right = g * h_center * (z_border[slice_right_border,do] + (1-theta_border[slice_right_border,do]) * h_border[slice_right_border,do])
+    bed_left  = g * h_center * (z_border[slice_left_border,do]  + (1-theta_border[slice_left_border,do])  * h_border[slice_left_border,do])
 
     q_t2[slice_mesh] = 1./(1. + dt * g *h[slice_mesh] * J) * (q_t1[slice_mesh] - dt/dx * (qm_right - qm_left + press_right - press_left + bed_right - bed_left))
 
@@ -716,6 +719,13 @@ def problem_hedge(dom:np.ndarray, z:np.ndarray, h0:float, q0:float, dx:float, CN
 
     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)
 
+    theta = np.ones_like(h)
+    theta_border = np.ones_like(h_border)
+
+    slice_hedge = slice(len(h) // 2-1, len(h) // 2+2)
+    theta_val = 0.5
+    theta[slice_hedge] = theta_val
+
     totaltime = 4*3600
     eps=1.
 
@@ -724,9 +734,9 @@ def problem_hedge(dom:np.ndarray, z:np.ndarray, h0:float, q0:float, dx:float, CN
         while eps > 1e-12:
             dt = compute_dt(dx, h, q, CN)
             # Predictor step
-            Euler_RK_hedge(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)
+            Euler_RK_hedge(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, theta, theta_border)
             # Corrector step
-            Euler_RK_hedge(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)
+            Euler_RK_hedge(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, theta, theta_border)
 
             # Update -- Mean for second order in time
             h = (h_pred + h_corr)/2.
@@ -740,7 +750,7 @@ def problem_hedge(dom:np.ndarray, z:np.ndarray, h0:float, q0:float, dx:float, CN
     print("Total time : ", t)
     print("Residual : ", eps)
 
-    return h, q
+    return h, q, theta
 
 def problem_bridge(dom:np.ndarray, z:np.ndarray, z_bridge:np.ndarray,
                    h0:float, q0:float,
@@ -1062,7 +1072,7 @@ def problem_bridge_unsteady_topo(dom:np.ndarray, z:np.ndarray,
 
     infil_exfil = None
 
-    filling_bridge = False
+    bridge_in_motion = False
     filled_bridge = False
     emptying_bridge = False
     motion_completed = True
@@ -1105,6 +1115,8 @@ def problem_bridge_unsteady_topo(dom:np.ndarray, z:np.ndarray,
         t = 0.
 
         res_time = 0.
+        update_time = 0.
+
         delta_res_time = delta_res_time_def
 
         z_roof_start = None
@@ -1220,172 +1232,181 @@ def problem_bridge_unsteady_topo(dom:np.ndarray, z:np.ndarray,
                 res.append((t, h.copy(), q.copy(), z.copy(), z_roof.copy(), infil_exfil if infil_exfil is not None else (idx_up, idx_do, 0., 0., 0., 0.)))
                 res_time += delta_res_time
 
-            if z[survey_up] + h[survey_up] > z_overflow:
-                # Overflow
+            if updating_time_interval == 0. or t> update_time:
+                update_time += updating_time_interval
+
+                if z[survey_up] + h[survey_up] > z_overflow:
+                    # Overflow
+
+                    # Convert Bridge into topography
+                    # add infiltration/exfiltration
+                    if not bridge_in_motion and motion_completed and not filled_bridge:
+
+                        # Movement must be initiated...
+
+                        # Decreasing the interval of time for the
+                        # saving to be more precise when plotting
+                        delta_res_time = delta_res_time_def / 5.
 
-                # Convert Bridge into topography
-                # add infiltration/exfiltration
-                if not filling_bridge and motion_completed and not filled_bridge:
+                        bridge_in_motion = True
+                        emptying_bridge = False
+                        motion_completed = False
 
-                    # Movement must be initiated...
+                        local_motion_time = 0.
+                        starting_time = t
 
-                    # Decreasing the interval of time for the
-                    # saving to be more precise when plotting
-                    delta_res_time = delta_res_time_def / 5.
+                        # Keeping the old values -- Can be useful when restoring
+                        old_z_roof = z_roof.copy()
+                        old_z = z.copy()
 
-                    filling_bridge = True
-                    emptying_bridge = False
-                    motion_completed = False
-                    local_motion_time = 0.
+                        # Reference section of the bridge...
+                        # Keeping the minimum distance between the bridge and the floor
+                        A_bridge = np.min(z_roof[bridge] - z[bridge])
 
-                    # Keeping the old values -- Can be useful when restoring
-                    old_z_roof = z_roof.copy()
-                    old_z = z.copy()
 
-                    # Reference section of the bridge...
-                    # Keeping the minimum distance between the bridge and the floor
-                    A_bridge = np.min(z_roof[bridge] - z[bridge])
+                        # Computing global head loss coefficient associated to the bridge and the reference section
+                        k_bridge = compute_k_mean(z[survey_up], h[survey_up], q[survey_up],
+                                                z[survey_do], h[survey_do], q[survey_do],
+                                                A_bridge)
 
+                        # Starting the motion...
+                        #   - the bridge's roof is going up
+                        #   - the bridge's floor is going up
 
-                    # Computing global head loss coefficient associated to the bridge and the reference section
-                    k_bridge = compute_k_mean(z[survey_up], h[survey_up], q[survey_up],
-                                              z[survey_do], h[survey_do], q[survey_do],
-                                              A_bridge)
+                        z_roof_start = old_z_roof[bridge]
+                        z_roof_end   = z_roof_null
+                        z_bath_start = old_z[bridge]
+                        z_bath_end   = z_deck[bridge]
 
-                    # Starting the motion...
-                    #   - the bridge's roof is going up
-                    #   - the bridge's floor is going up
+                        # Mean Flow rate under the bridge
+                        q_infil_t_current = np.mean(q[bridge])
 
-                    z_roof_start = old_z_roof[bridge]
-                    z_roof_end   = z_roof_null
-                    z_bath_start = old_z[bridge]
-                    z_bath_end   = z_deck[bridge]
+                        infil_exfil, z_roof, z, q_infil_t_current = update_top_q(z, h, q, z_roof,
+                                                                                idx_up, idx_do,
+                                                                                survey_up, survey_do,
+                                                                                A_bridge, k_bridge, q_infil_t_current,
+                                                                                dt,
+                                                                                local_motion_time, total_motion_time,
+                                                                                emptying_bridge,
+                                                                                z_roof_start, z_roof_end, z_bath_start, z_bath_end)
 
-                    # Mean Flow rate under the bridge
-                    q_infil_t_current = np.mean(q[bridge])
+                    else:
+                        if not motion_completed:
+                            # Movement is initiated but not finished...
+
+                            # Updating the local time
+                            # local_motion_time += dt
+                            local_motion_time = t - starting_time
+
+                            if local_motion_time > total_motion_time:
+                                # Total time is reached...
+                                # ... so terminate the movement
+
+                                delta_res_time = delta_res_time_def
+
+                                bridge_in_motion = False
+                                motion_completed = True
+                                filled_bridge = not filled_bridge
+
+                                infil_exfil, z_roof, z, q_infil_t_current = update_top_q(z, h, q, z_roof,
+                                                                                        idx_up, idx_do,
+                                                                                        survey_up, survey_do,
+                                                                                        A_bridge, k_bridge, q_infil_t_current, dt,
+                                                                                        local_motion_time, total_motion_time, emptying_bridge,
+                                                                                        z_roof_start, z_roof_end, z_bath_start, z_bath_end,
+                                                                                        stop_motion= True)
+
+                                local_motion_time = 0.
+                            else:
+                                # Total time is not reached...
+                                #   ... so continue the movement
+
+                                infil_exfil, z_roof, z, q_infil_t_current = update_top_q(z, h, q, z_roof,
+                                                                                        idx_up, idx_do,
+                                                                                        survey_up, survey_do,
+                                                                                        A_bridge, k_bridge, q_infil_t_current, dt,
+                                                                                        local_motion_time, total_motion_time, emptying_bridge,
+                                                                                        z_roof_start, z_roof_end, z_bath_start, z_bath_end)
+                        else:
+                            # Movement is done...
+
+                            if infil_exfil is not None:
+
+                                # Updating the infiltration discharge according to head difference
+                                infil_exfil, z_roof, z, q_infil_t_current = update_top_q(z, h, q, z_roof,
+                                                                                        idx_up, idx_do,
+                                                                                        survey_up, survey_do,
+                                                                                        A_bridge, k_bridge, q_infil_t_current, dt,
+                                                                                        local_motion_time, total_motion_time, emptying_bridge,
+                                                                                        z_roof_start, z_roof_end, z_bath_start, z_bath_end,
+                                                                                        update_top=False)
 
-                    infil_exfil, z_roof, z, q_infil_t_current = update_top_q(z, h, q, z_roof,
-                                                                             idx_up, idx_do,
-                                                                             survey_up, survey_do,
-                                                                             A_bridge, k_bridge, q_infil_t_current,
-                                                                             dt,
-                                                                             local_motion_time, total_motion_time,
-                                                                             emptying_bridge,
-                                                                             z_roof_start, z_roof_end, z_bath_start, z_bath_end)
 
                 else:
-                    if not motion_completed:
-                        # Movement is initiated but not finished...
+                    # No overflow
 
-                        # Updating the local time
-                        local_motion_time += dt
+                    if bridge_in_motion:
+                        # But movement is initiated...
+                        # local_motion_time += dt
+                        local_motion_time = t - starting_time
 
                         if local_motion_time > total_motion_time:
-                            # Total time is reached...
-                            # ... so terminate the movement
 
                             delta_res_time = delta_res_time_def
 
-                            filling_bridge = False
+                            # Total time is reached...
+                            # ... so terminate the movement
+
+                            bridge_in_motion = False
                             motion_completed = True
                             filled_bridge = not filled_bridge
 
                             infil_exfil, z_roof, z, q_infil_t_current = update_top_q(z, h, q, z_roof,
-                                                                                       idx_up, idx_do,
-                                                                                       survey_up, survey_do,
-                                                                                       A_bridge, k_bridge, q_infil_t_current, dt,
-                                                                                       local_motion_time, total_motion_time, emptying_bridge,
-                                                                                       z_roof_start, z_roof_end, z_bath_start, z_bath_end,
-                                                                                       stop_motion= True)
+                                                                                    idx_up, idx_do,
+                                                                                    survey_up, survey_do,
+                                                                                    A_bridge, k_bridge, q_infil_t_current, dt,
+                                                                                    local_motion_time, total_motion_time, emptying_bridge,
+                                                                                    z_roof_start, z_roof_end, z_bath_start, z_bath_end,
+                                                                                    stop_motion= True)
 
                             local_motion_time = 0.
+
                         else:
                             # Total time is not reached...
                             #   ... so continue the movement
 
                             infil_exfil, z_roof, z, q_infil_t_current = update_top_q(z, h, q, z_roof,
-                                                                                       idx_up, idx_do,
-                                                                                       survey_up, survey_do,
-                                                                                       A_bridge, k_bridge, q_infil_t_current, dt,
-                                                                                       local_motion_time, total_motion_time, emptying_bridge,
-                                                                                       z_roof_start, z_roof_end, z_bath_start, z_bath_end)
-                    else:
-                        # Movement is done...
-
-                        if infil_exfil is not None:
-
-                            # Updating the infiltration discharge according to head difference
-                            infil_exfil, z_roof, z, q_infil_t_current = update_top_q(z, h, q, z_roof,
-                                                                                       idx_up, idx_do,
-                                                                                       survey_up, survey_do,
-                                                                                       A_bridge, k_bridge, q_infil_t_current, dt,
-                                                                                       local_motion_time, total_motion_time, emptying_bridge,
-                                                                                       z_roof_start, z_roof_end, z_bath_start, z_bath_end,
-                                                                                       update_top=False)
-
-
-            else:
-                # No overflow
-
-                if filling_bridge:
-                    # But movement is initiated...
-                    local_motion_time += dt
-
-                    if local_motion_time > total_motion_time:
-
-                        delta_res_time = delta_res_time_def
-
-                        # Total time is reached...
-                        # ... so terminate the movement
-
-                        filling_bridge = False
-                        motion_completed = True
-                        filled_bridge = not filled_bridge
-
-                        infil_exfil, z_roof, z, q_infil_t_current = update_top_q(z, h, q, z_roof,
-                                                                                   idx_up, idx_do,
-                                                                                   survey_up, survey_do,
-                                                                                   A_bridge, k_bridge, q_infil_t_current, dt,
-                                                                                   local_motion_time, total_motion_time, emptying_bridge,
-                                                                                   z_roof_start, z_roof_end, z_bath_start, z_bath_end,
-                                                                                   stop_motion= True)
-
-                        local_motion_time = 0.
+                                                                                    idx_up, idx_do,
+                                                                                    survey_up, survey_do,
+                                                                                    A_bridge, k_bridge, q_infil_t_current, dt,
+                                                                                    local_motion_time, total_motion_time, emptying_bridge,
+                                                                                    z_roof_start, z_roof_end, z_bath_start, z_bath_end)
 
                     else:
-                        # Total time is not reached...
-                        #   ... so continue the movement
-
-                        infil_exfil, z_roof, z, q_infil_t_current = update_top_q(z, h, q, z_roof,
-                                                                                   idx_up, idx_do,
-                                                                                   survey_up, survey_do,
-                                                                                   A_bridge, k_bridge, q_infil_t_current, dt,
-                                                                                   local_motion_time, total_motion_time, emptying_bridge,
-                                                                                   z_roof_start, z_roof_end, z_bath_start, z_bath_end)
 
-                else:
+                        if infil_exfil is not None:
 
-                    if infil_exfil is not None:
+                            if motion_completed:
+                                # The bridge is not moving and the infiltration/exfiltration exists
 
-                        if motion_completed:
-                            # The bridge is not moving and the infiltration/exfiltration exists
+                                # We can start to restore the bridge as it was before the overflow...
 
-                            # We can start to restore the bridge as it was before the overflow...
+                                delta_res_time = delta_res_time_def / 5.
 
-                            delta_res_time = delta_res_time_def / 5.
+                                bridge_in_motion = True
+                                local_motion_time = 0.
+                                motion_completed = False
 
-                            filling_bridge = True
-                            local_motion_time = 0.
-                            motion_completed = False
-                            emptying_bridge = True
+                                emptying_bridge = True
+                                starting_time = t
 
-                            infil_exfil, z_roof, z, q_infil_t_current = update_top_q(z, h, q, z_roof,
-                                                                                       idx_up, idx_do,
-                                                                                       survey_up, survey_do,
-                                                                                       A_bridge, k_bridge, q_infil_t_current, dt,
-                                                                                       local_motion_time, total_motion_time, emptying_bridge,
-                                                                                       z_roof_start, z_roof_end, z_bath_start, z_bath_end,
-                                                                                        )
+                                infil_exfil, z_roof, z, q_infil_t_current = update_top_q(z, h, q, z_roof,
+                                                                                        idx_up, idx_do,
+                                                                                        survey_up, survey_do,
+                                                                                        A_bridge, k_bridge, q_infil_t_current, dt,
+                                                                                        local_motion_time, total_motion_time, emptying_bridge,
+                                                                                        z_roof_start, z_roof_end, z_bath_start, z_bath_end,
+                                                                                            )
 
             t+=dt
             pbar.update(dt)
@@ -1439,17 +1460,14 @@ def plot_bridge(ax:plt.Axes, x:np.ndarray,
 def plot_hedge(ax:plt.Axes, x:np.ndarray,
          h1:np.ndarray, h2:np.ndarray,
          q1:np.ndarray, q2:np.ndarray,
-         z:np.ndarray, hu:float):
+         z:np.ndarray, hu:float,
+         theta:np.ndarray):
 
     u1=np.zeros_like(q1)
     u2=np.zeros_like(q1)
 
-    slice_hedge = slice(len(h1) // 2-1, len(h1) // 2+2)
-    theta = 0.2
-
     u1[1:-1] = q1[1:-1]/h1[1:-1]
-    u2[1:-1] = q2[1:-1]/h2[1:-1]
-    u2[slice_hedge] /= theta
+    u2[1:-1] = q2[1:-1]/(h2[1:-1]*theta[1:-1])
 
     ax.plot(x[1:-1], z[1:-1], label = 'z')
 
@@ -1934,7 +1952,7 @@ def unsteady_without_bedmotion():
     return fig, axes
 
 
-def unteaady_with_bedmotion(problems:list[int], save_video:bool = False) -> list[animation.FuncAnimation]:
+def unsteady_with_bedmotion(problems:list[int], save_video:bool = False) -> list[animation.FuncAnimation]:
     """
     Unsteady problem with bed motion if overflowing occurs.
 
@@ -2330,6 +2348,403 @@ def unteaady_with_bedmotion(problems:list[int], save_video:bool = False) -> list
 
     return anims
 
+def unsteady_with_bedmotion_interval(problems:list[int], save_video:bool = False, update_interval:float = 0., motion_duration:float = 300.) -> list[animation.FuncAnimation]:
+    """
+    Unsteady problem with bed motion if overflowing occurs.
+
+    :param problems: list of problems to solve
+
+    Problems :
+        2 - Rectangular bridge - Length = 20 m  (will compute 21, 22 and 23)
+        6 - Rectangular bridge - Length = 60 m  (will compute 61, 62 and 63)
+        7 - V-shape bridge - Length = 20 m      (will compute 71, 72 and 73)
+        8 - U-shape bridge - Length = 20 m      (will compute 81, 82 and 83)
+        9 - Culvert - Length = 100 m            (will compute 91, 92 and 93)
+
+        21 - Rectangular bridge - Length = 20 m - Unsteady downstream bc
+        22 - Rectangular bridge - Length = 20 m - Hydrograph
+        23 - Rectangular bridge - Length = 20 m - Hydrograph 2 steps
+
+        61 - Rectangular bridge - Length = 60 m - Unsteady downstream bc
+        62 - Rectangular bridge - Length = 60 m - Hydrograph
+        63 - Rectangular bridge - Length = 60 m - Hydrograph 2 steps
+
+        71 - V-shape bridge - Length = 20 m - Unsteady downstream bc
+        72 - V-shape bridge - Length = 20 m - Hydrograph
+        73 - V-shape bridge - Length = 20 m - Hydrograph 2 steps
+
+        81 - U-shape bridge - Length = 20 m - Unsteady downstream bc
+        82 - U-shape bridge - Length = 20 m - Hydrograph
+        83 - U-shape bridge - Length = 20 m - Hydrograph 2 steps
+
+        91 - Culvert - Length = 100 m - Unsteady downstream bc
+        92 - Culvert - Length = 100 m - Hydrograph
+        93 - Culvert - Length = 100 m - Hydrograph 2 steps
+
+    """
+    length = 500.
+    dx = 1.
+    CN = 0.4
+    h0 = 4.
+    q0 = 7.
+    n  = 0.025
+    slope = 0 #1e-4
+    press_mode = 4
+
+    dom, x, z = domain(length, dx, slope)
+    x = np.array(x)
+
+    hu = uniform_waterdepth(slope, q0, n)
+
+    anims=[]
+
+    if 2 in problems or 21 in problems or 22 in problems or 23 in problems or 24 in problems:
+        # Rectangular bridge - Lenght = 20 m
+
+        CN = 0.4
+
+        if 2 in problems:
+            scenarios = ['unsteady_downstream_bc',
+                         'hydrograph',
+                         'hydrograph_2steps',
+                        #  'Gauss',
+                         ]
+        elif 21 in problems:
+            scenarios = ['unsteady_downstream_bc']
+        elif 22 in problems:
+            scenarios = ['hydrograph']
+        elif 23 in problems:
+            scenarios = ['hydrograph_2steps']
+        elif 24 in problems:
+            scenarios = ['Gauss']
+
+        for scenario in scenarios:
+
+            # UNSTEADY WITH TOPOGRAPHY ADAPTATION
+            len_bridge = 20
+            z_roof_null = 10.
+            min_overflow = 0.25
+
+            h0 = 1.5
+
+            h_under_bridge = 3.5
+            h_deck_bridge = 0.75
+
+            slice_bridge = slice(int(len(dom)//2-len_bridge//2),int(len(dom)//2+len_bridge//2))
+            slice_bridge_up = slice(int(len(dom)//2+(len_bridge//2-1)),int(len(dom)//2-(len_bridge//2+1)),-1)
+
+            z_bridge = np.ones_like(z) * z_roof_null
+            z_deck = np.ones_like(z) * z_roof_null
+
+            for idx in range(len(dom)//2-len_bridge//2,len(dom)//2+len_bridge//2):
+                z_bridge[idx] = z[idx] + h_under_bridge
+                z_deck[idx] = z_bridge[idx] + h_deck_bridge
+
+            poly_bridge_x = np.concatenate((x[slice_bridge], x[slice_bridge_up]))
+            poly_bridge_y = np.concatenate((z_bridge[slice_bridge], z_deck[slice_bridge_up]))
+
+            z_ini = z.copy()
+
+            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,
+                                               updating_time_interval=update_interval)
+
+            ani = animate_bridge_unsteady_topo(dom, poly_bridge_x, poly_bridge_y, res, x, z_ini, hu, z_roof_null, len_bridge, motion_duration=motion_duration)
+
+            if save_video:
+                update_func = lambda _i, _n: progress_bar.update(1)
+                with tqdm(total=len(res), desc='Saving video') as progress_bar:
+                    ani.save(f'bridge_L20_{scenario}.mp4',
+                        writer='ffmpeg', fps=5,
+                        progress_callback=update_func)
+
+            anims.append(ani)
+
+    if 6 in problems or 61 in problems or 62 in problems or 63 in problems or 64 in problems:
+        # Rectangular bridge - Lenght = 60 m
+
+        CN = 0.2
+
+        if 6 in problems:
+            scenarios = ['unsteady_downstream_bc',
+                         'hydrograph',
+                         'hydrograph_2steps',
+                        #  'Gauss',
+                         ]
+
+        elif 61 in problems:
+            scenarios = ['unsteady_downstream_bc']
+        elif 62 in problems:
+            scenarios = ['hydrograph']
+        elif 63 in problems:
+            scenarios = ['hydrograph_2steps']
+        elif 64 in problems:
+            scenarios = ['Gauss']
+
+        for scenario in scenarios:
+
+            # UNSTEADY WITH TOPOGRAPHY ADAPTATION
+            z_roof_null = 10.
+            min_overflow = 0.25
+
+            h_under_bridge = 3.5
+            h_deck_bridge = 0.75
+            len_bridge = 60
+            q0 = 6.
+            h0 = 1.5
+
+            slice_bridge = slice(int(len(dom)//2-len_bridge//2),int(len(dom)//2+len_bridge//2))
+            slice_bridge_up = slice(int(len(dom)//2+(len_bridge//2-1)),int(len(dom)//2-(len_bridge//2+1)),-1)
+
+            z_bridge = np.ones_like(z) * z_roof_null
+            z_deck = np.ones_like(z) * z_roof_null
+
+            for idx in range(len(dom)//2-len_bridge//2,len(dom)//2+len_bridge//2):
+                z_bridge[idx] = z[idx] + h_under_bridge
+                z_deck[idx] = z_bridge[idx] + h_deck_bridge
+
+            poly_bridge_x = np.concatenate((x[slice_bridge], x[slice_bridge_up]))
+            poly_bridge_y = np.concatenate((z_bridge[slice_bridge], z_deck[slice_bridge_up]))
+
+            z_ini = z.copy()
+
+            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,
+                                               updating_time_interval=update_interval)
+
+            ani = animate_bridge_unsteady_topo(dom, res, x, z_ini, hu, z_roof_null, len_bridge, motion_duration=motion_duration)
+
+            if save_video:
+                update_func = lambda _i, _n: progress_bar.update(1)
+                with tqdm(total=len(res), desc='Saving video') as progress_bar:
+                    ani.save(f'bridge_L60{scenario}.mp4',
+                        writer='ffmpeg', fps=5,
+                        progress_callback=update_func)
+
+            anims.append(ani)
+
+    if 9 in problems or 91 in problems or 92 in problems or 93 in problems or 94 in problems:
+        # Culvert
+
+        CN = 0.4
+
+        if 9 in problems:
+            scenarios = ['unsteady_downstream_bc_culvert',
+                         'hydrograph_culvert',
+                         'hydrograph_2steps_culvert',
+                        #  'Gauss',
+                         ]
+
+        elif 91 in problems:
+            scenarios = ['unsteady_downstream_bc_culvert']
+        elif 92 in problems:
+            scenarios = ['hydrograph_culvert']
+        elif 93 in problems:
+            scenarios = ['hydrograph_2steps_culvert']
+
+        for scenario in scenarios:
+
+            # UNSTEADY WITH TOPOGRAPHY ADAPTATION
+            z_roof_null = 10.
+            min_overflow = 0.25
+
+            h_under_bridge = 1.5
+            h_deck_bridge = 4.0
+            len_bridge = 100
+            h0 = 0.8
+            q0 = 1.
+
+            slice_bridge = slice(int(len(dom)//2-len_bridge//2),int(len(dom)//2+len_bridge//2))
+            slice_bridge_up = slice(int(len(dom)//2+(len_bridge//2-1)),int(len(dom)//2-(len_bridge//2+1)),-1)
+
+            z_bridge = np.ones_like(z) * z_roof_null
+            z_deck = np.ones_like(z) * z_roof_null
+
+            for idx in range(len(dom)//2-len_bridge//2,len(dom)//2+len_bridge//2):
+                z_bridge[idx] = z[idx] + h_under_bridge
+                z_deck[idx] = z_bridge[idx] + h_deck_bridge
+
+            poly_bridge_x = np.concatenate((x[slice_bridge], x[slice_bridge_up]))
+            poly_bridge_y = np.concatenate((z_bridge[slice_bridge], z_deck[slice_bridge_up]))
+
+            z_ini = z.copy()
+
+            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,
+                                               updating_time_interval=update_interval)
+
+            ani = animate_bridge_unsteady_topo(dom, poly_bridge_x, poly_bridge_y,  res, x, z_ini, hu, z_roof_null, len_bridge, title='Culvert', motion_duration=motion_duration)
+
+            if save_video:
+                update_func = lambda _i, _n: progress_bar.update(1)
+                with tqdm(total=len(res), desc='Saving video') as progress_bar:
+                    ani.save(f'culvert_{scenario}.mp4',
+                            writer='ffmpeg', fps=5,
+                            progress_callback=update_func)
+
+            anims.append(ani)
+
+    if 7 in problems or 71 in problems or 72 in problems or 73 in problems or 74 in problems:
+        # V-shape Bridge
+
+        CN = 0.4
+
+        if 7 in problems:
+            scenarios = ['unsteady_downstream_bc',
+                         'hydrograph',
+                         'hydrograph_2steps',
+                        #  'Gauss',
+                         ]
+        elif 71 in problems:
+            scenarios = ['unsteady_downstream_bc']
+        elif 72 in problems:
+            scenarios = ['hydrograph']
+        elif 73 in problems:
+            scenarios = ['hydrograph_2steps']
+        elif 74 in problems:
+            scenarios = ['Gauss']
+
+        for scenario in scenarios:
+
+            # UNSTEADY WITH TOPOGRAPHY ADAPTATION
+            z_roof_null = 10.
+            min_overflow = 0.25
+
+            h_under_bridge = 3.5
+            h_deck_bridge = 0.75
+            len_bridge = 20
+
+            h0 = 1.5
+
+            z_bridge = np.ones_like(z) * z_roof_null
+            z_deck   = np.ones_like(z) * z_roof_null
+
+            slice_bridge = slice(len(dom)//2-len_bridge//2,len(dom)//2+len_bridge//2)
+            slice_bridge_up = slice(len(dom)//2+(len_bridge//2-1),len(dom)//2-(len_bridge//2+1),-1)
+
+            for idx in range(len(dom)//2-len_bridge//2,len(dom)//2+len_bridge//2):
+                decal = abs(idx - (len(dom)//2))
+                z_bridge[idx] = z[idx] + h_under_bridge + 0.05 * decal
+                z_deck[idx] = h_under_bridge + h_deck_bridge
+
+            poly_bridge_x = np.concatenate((x[slice_bridge], x[slice_bridge_up]))
+            poly_bridge_y = np.concatenate((z_bridge[slice_bridge], z_deck[slice_bridge_up]))
+
+            z_ini = z.copy()
+
+            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,
+                                               updating_time_interval=update_interval)
+
+            ani = animate_bridge_unsteady_topo(dom, poly_bridge_x, poly_bridge_y,  res, x, z_ini, hu, z_roof_null, len_bridge, motion_duration=motion_duration)
+
+            if save_video:
+                update_func = lambda _i, _n: progress_bar.update(1)
+                with tqdm(total=len(res), desc='Saving video') as progress_bar:
+                    ani.save(f'bridge_Vshape{scenario}.mp4',
+                        writer='ffmpeg', fps=5,
+                        progress_callback=update_func)
+
+            anims.append(ani)
+
+    if 8 in problems or 81 in problems or 82 in problems or 83 in problems or 84 in problems:
+        # U-shape Bridge
+
+        CN = 0.4
+
+        if 8 in problems:
+            scenarios = ['unsteady_downstream_bc',
+                         'hydrograph',
+                         'hydrograph_2steps',
+                        #  'Gauss',
+                         ]
+        elif 81 in problems:
+            scenarios = ['unsteady_downstream_bc']
+        elif 82 in problems:
+            scenarios = ['hydrograph']
+        elif 83 in problems:
+            scenarios = ['hydrograph_2steps']
+        elif 84 in problems:
+            scenarios = ['Gauss']
+
+        for scenario in scenarios:
+
+            # UNSTEADY WITH TOPOGRAPHY ADAPTATION
+            z_roof_null = 10.
+            min_overflow = 0.25
+
+            h_under_bridge = 3.5
+            h_deck_bridge = 0.4
+            len_bridge = 20
+
+            h0 = 1.5
+
+            z_bridge = np.ones_like(z) * z_roof_null
+            z_deck   = np.ones_like(z) * z_roof_null
+
+            slice_bridge = slice(len(dom)//2-len_bridge//2,len(dom)//2+len_bridge//2)
+            slice_bridge_up = slice(len(dom)//2+(len_bridge//2-1),len(dom)//2-(len_bridge//2+1),-1)
+
+            z_bridge[slice_bridge] = z[slice_bridge] + h_under_bridge
+            z_deck[slice_bridge]   = z_bridge[slice_bridge] + h_deck_bridge
+
+            idx_up = len(dom)//2-len_bridge//2
+            idx_down = len(dom)//2+len_bridge//2-1
+
+            z_bridge[idx_up] -= .4
+            z_bridge[idx_up+1] -= .4
+
+            z_bridge[idx_down] -= .4
+            z_bridge[idx_down-1] -= .4
+
+            poly_bridge_x = np.concatenate((x[slice_bridge], x[slice_bridge_up]))
+            poly_bridge_y = np.concatenate((z_bridge[slice_bridge], z_deck[slice_bridge_up]))
+
+            z_ini = z.copy()
+
+            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,
+                                               updating_time_interval=update_interval)
+
+            ani = animate_bridge_unsteady_topo(dom, poly_bridge_x, poly_bridge_y,  res, x, z_ini, hu, z_roof_null, len_bridge, motion_duration=motion_duration)
+
+            if save_video:
+                update_func = lambda _i, _n: progress_bar.update(1)
+                with tqdm(total=len(res), desc='Saving video') as progress_bar:
+                    ani.save(f'bridge_Ushape{scenario}.mp4',
+                        writer='ffmpeg', fps=5,
+                        progress_callback=update_func)
+
+            anims.append(ani)
+
+    return anims
+
+
 
 def hedge():
     """ Compute Water line problems with hedge
@@ -2365,19 +2780,19 @@ def hedge():
     fig, axes = plt.subplots(3,1)
 
     h1, q1 = problem(dom, z, h0, q0, dx, CN, n)
-    h2, q2 = problem_hedge(dom, z, h0, q0, dx, CN, n)
+    h2, q2, theta = problem_hedge(dom, z, h0, q0, dx, CN, n)
 
-    plot_hedge(axes[0], x, h1, h2, q1, q2, z, hu)
+    plot_hedge(axes[0], x, h1, h2, q1, q2, z, hu, theta)
 
     h1, q1 = problem(dom, z, h0+1., q0, dx, CN, n)
-    h2, q2 = problem_hedge(dom, z, h0+1., q0, dx, CN, n)
+    h2, q2, theta = problem_hedge(dom, z, h0+1., q0, dx, CN, n)
 
-    plot_hedge(axes[1], x, h1, h2, q1, q2, z, hu)
+    plot_hedge(axes[1], x, h1, h2, q1, q2, z, hu, theta)
 
     h1, q1 = problem(dom, z, h0+2., q0, dx, CN, n)
-    h2, q2 = problem_hedge(dom, z, h0+2., q0, dx, CN, n)
+    h2, q2, theta = problem_hedge(dom, z, h0+2., q0, dx, CN, n)
 
-    plot_hedge(axes[2], x, h1, h2, q1, q2, z, hu)
+    plot_hedge(axes[2], x, h1, h2, q1, q2, z, hu, theta)
 
     fig.set_size_inches(20, 10)
     fig.tight_layout()
@@ -2386,13 +2801,16 @@ def hedge():
 
 if __name__  == '__main__':
 
-    # fig, axes = steady()
-    fig, axes = water_line()
-    # fig, axes = water_lines()
-    # fig, axes = unsteady_without_bedmotion()
-    # fig, axes = unteaady_with_bedmotion([2, 6, 7, 8, 9])
-    # fig, axes = hedge()
-    fig, axes = water_line_noloss_noslope()
+    # anim = steady()
+    # anim = water_line()
+    # anim = water_lines()
+    # anim = unsteady_without_bedmotion()
+    # anim = unteaady_with_bedmotion([2, 6, 7, 8, 9])
+    anim = hedge()
+    # anim = water_line_noloss_noslope()
+
+    # anim1 = unsteady_with_bedmotion([2])
+    # anim2 = unsteady_with_bedmotion_interval([21], update_interval=2., motion_duration=300.)
 
     plt.show()