Calculează tu: apa și factorul de siguranță

8.7. Calculează tu: apa și factorul de siguranță#

Două calcule din acest capitol, pe care le poți rula și modifica: versantul infinit, la care se vede cel mai limpede ce face apa, și metoda fâșiilor (Fellenius și Bishop) pe un taluz simplu.

8.7.1. Versantul infinit: cât costă un metru de apă#

Un strat de pământ de grosime \(z\) pe o pantă \(\beta\), cu apa curgând paralel cu panta, la înălțimea \(h_w\) deasupra suprafeței de alunecare. Pentru \(c' = 0\) și \(h_w = z\) se regăsește relația (8.3).

beta  = 20.0    # panta versantului [grade]
z     = 4.0     # adâncimea suprafeței de alunecare [m]
gamma = 19.0    # greutatea volumică a pământului [kN/m3]
c     = 0.0     # coeziunea efectivă c' [kPa]
phi   = 30.0    # unghiul de frecare efectiv [grade]

Hide code cell source

 
import numpy as np
import matplotlib.pyplot as plt

gw = 9.81
b, f = np.radians(beta), np.radians(phi)

def F_infinit(hw):
    sigma = gamma * z * np.cos(b) ** 2          # efort normal total pe plan
    u = gw * hw * np.cos(b) ** 2                # presiunea apei din pori
    tau = gamma * z * np.sin(b) * np.cos(b)     # efort tangențial mobilizat
    return (c + (sigma - u) * np.tan(f)) / tau

hw = np.linspace(0, z, 50)
plt.figure(figsize=(6, 3.4))
plt.plot(hw, F_infinit(hw), lw=2)
plt.axhline(1, color="tab:red", ls="--", lw=1)
plt.xlabel("înălțimea apei deasupra suprafeței de alunecare, $h_w$ [m]")
plt.ylabel("factor de siguranță F"); plt.grid(alpha=0.3)
plt.show()
print(f"versant uscat:   F = {F_infinit(0):.2f}")
print(f"versant saturat: F = {F_infinit(z):.2f}   (raport {F_infinit(z) / F_infinit(0):.2f})")
../_images/59b0acd87e830891a970bf35477f355901a7fdb242ddd4c34c1d6b2937fb8e22.png 
versant uscat:   F = 1.59
versant saturat: F = 0.77   (raport 0.48)

Cu valorile inițiale, versantul uscat are o rezervă de aproape 60 %, iar cel saturat a cedat deja. Nimic nu s-a schimbat în afară de apă.

8.7.2. Metoda fâșiilor: Fellenius și Bishop#

Un taluz omogen de înălțime \(H\), o suprafață de alunecare circulară care trece prin piciorul taluzului și presiunea apei din pori dată prin coeficientul \(r_u = u/(\gamma h)\). Relațiile sunt (8.5) și (8.6); a doua se rezolvă prin iterații.

H, panta = 10.0, 26.6        # înălțimea [m] și unghiul taluzului [grade]
gamma    = 19.0              # [kN/m3]
c, phi   = 10.0, 25.0        # c' [kPa], φ' [grade]
ru       = 0.20              # coeficientul presiunii apei din pori
xc, yc   = 6.0, 22.0         # centrul cercului [m]; originea este în piciorul taluzului

Hide code cell source

 
tb, tf = np.tan(np.radians(panta)), np.tan(np.radians(phi))
L = H / tb

def teren(x):
    return np.clip(x * tb, 0, H)

def fasii(xc, yc, n=40):
    R = np.hypot(xc, yc)                               # cercul trece prin picior (0, 0)
    if R <= abs(H - yc):
        return None
    x_sus = xc + np.sqrt(R ** 2 - (H - yc) ** 2)        # ieșirea pe platforma de sus
    if x_sus <= L or xc < 0:
        return None
    margini = np.linspace(0, x_sus, n + 1)
    x = 0.5 * (margini[1:] + margini[:-1]); bw = np.diff(margini)
    yb = yc - np.sqrt(R ** 2 - (x - xc) ** 2)
    h = teren(x) - yb
    if np.any(h <= 0):
        return None
    alfa = np.arctan((x - xc) / np.sqrt(R ** 2 - (x - xc) ** 2))
    W = gamma * h * bw
    return dict(R=R, x=x, b=bw, h=h, alfa=alfa, W=W, u=ru * gamma * h, x_sus=x_sus)

def fellenius(s):
    l = s["b"] / np.cos(s["alfa"])
    return np.sum(c * l + (s["W"] * np.cos(s["alfa"]) - s["u"] * l) * tf) / np.sum(s["W"] * np.sin(s["alfa"]))

def bishop(s, F=1.5, afiseaza=False):
    for it in range(1, 51):
        m = np.cos(s["alfa"]) * (1 + np.tan(s["alfa"]) * tf / F)
        Fn = np.sum((c * s["b"] + (s["W"] - s["u"] * s["b"]) * tf) / m) / np.sum(s["W"] * np.sin(s["alfa"]))
        if afiseaza:
            print(f"   iterația {it}: F = {Fn:.4f}")
        if abs(Fn - F) < 1e-4:
            return Fn
        F = Fn
    return F

s = fasii(xc, yc)
print(f"Fellenius: F = {fellenius(s):.3f}")
print("Bishop simplificat:")
Fb = bishop(s, afiseaza=True)

# căutarea cercului critic pe o rețea de centre
best = (9e9, None)
for X in np.arange(0, 16.1, 1.0):
    for Y in np.arange(12, 40.1, 1.0):
        t = fasii(X, Y)
        if t is not None:
            Ft = bishop(t)
            if Ft < best[0]:
                best = (Ft, (X, Y))
print(f"cercul critic (dintre cele încercate): centru ({best[1][0]:.0f}, {best[1][1]:.0f}), F = {best[0]:.3f}")

fig, ax = plt.subplots(figsize=(7, 3.8))
xs = np.array([-6, 0, L, s["x_sus"] + 8]); ax.plot(xs, teren(xs), "k", lw=1.5)
for (X, Y), stil, et in (((xc, yc), "tab:blue", "cercul ales"), (best[1], "tab:red", "cercul critic")):
    t = fasii(X, Y); xx = np.linspace(0, t["x_sus"], 100)
    ax.plot(xx, Y - np.sqrt(t["R"] ** 2 - (xx - X) ** 2), color=stil, lw=2, label=et)
ax.set_aspect("equal"); ax.legend(frameon=False); ax.set_xlabel("x [m]"); ax.set_ylabel("y [m]")
plt.show()

Fellenius: F = 1.323
Bishop simplificat:
   iterația 1: F = 1.4464
   iterația 2: F = 1.4407
   iterația 3: F = 1.4401
   iterația 4: F = 1.4400
cercul critic (dintre cele încercate): centru (3, 23), F = 1.374
../_images/27dc765b4e9c6c80e214381af7fb2d5e3d10affc7276e6d2f8b3bd2f15ed9472.png

De încercat:

  • pune ru = 0 și apoi ru = 0.4: cât pierde factorul de siguranță când urcă apa?

  • compară Fellenius cu Bishop: care este mai mic și cu cât? (vezi comentariul de sub relația (8.5));

  • pune c = 0: cercul critic se mută spre suprafață, ca la versantul infinit.

Cuprins