---
jupytext:
  formats: md:myst
  text_representation:
    extension: .md
    format_name: myst
kernelspec:
  display_name: Python 3
  language: python
  name: python3
---

(alu-joaca-te)=
# {fa}`rocket` 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.

## 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 {eq}`eq-alu-infinit`.

```{code-cell} ipython3
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]
```

```{code-cell} ipython3
:tags: [hide-input]
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})")
```

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ă.

## 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 {eq}`eq-alu-fellenius` și {eq}`eq-alu-bishop`; a doua se rezolvă prin iterații.

```{code-cell} ipython3
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
```

```{code-cell} ipython3
:tags: [hide-input]
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()
```

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 {eq}`eq-alu-fellenius`);
- pune `c = 0`: cercul critic se mută spre suprafață, ca la versantul infinit.