"""Ders 09 — İki boyutlu elastisite: düzlemsel gerilme ve düzlemsel şekil değiştirme.

Bu betik dersteki bağıntıları SymPy ile türetir/denetler ve çözümlü örneklerin sayılarını hesaplar:
  1. Düzlemsel şekil değiştirmede Hooke yasası ve iki hâl arasındaki sabit dönüşümü
  2. Beltrami–Michell denkleminin iki hâl için (ısıl terimle) türetilmesi
  3. Örnek 1: aynı düzlem içi gerilmeler, düzlemsel şekil değiştirme / düzlemsel gerilme
  4. Örnek 2: iki gerilme alanının "elastisite çözümü olabilir mi?" denetimi
  5. Örnek 3: sabit gerilme hâlinden yer değiştirme alanı (alüminyum levha)
  6. Örnek 4: üçgen ağırlık barajı, doğrusal gerilme alanı (yarı ters yöntem)
  7. Alıştırmaların sayısal sonuçları

Çalıştır:  python e09_iki_boyutlu.py
Gerekenler: numpy, sympy
"""
import numpy as np
import sympy as sp

x, y = sp.symbols("x y", real=True)
E, nu, alpha, G = sp.symbols("E nu alpha G", positive=True)
sxx, syy, sxy, dT = sp.symbols("sigma_xx sigma_yy sigma_xy DeltaT")

# %% 1. Düzlemsel şekil değiştirme: ε_zz = 0 koşulundan Hooke yasası
szz = sp.symbols("sigma_zz")
exx3 = (sxx - nu * (syy + szz)) / E          # 3B izotropik Hooke (ters biçim)
ezz3 = (szz - nu * (sxx + syy)) / E
szz_ds = sp.solve(sp.Eq(ezz3, 0), szz)[0]
exx_ds = sp.factor(exx3.subs(szz, szz_ds))
print("=== 1. Düzlemsel şekil değiştirme ===")
print("ε_zz = 0  →  σ_zz =", szz_ds)
print("ε_xx =", exx_ds)
# Dönüşüm: düzlemsel gerilme formülünde E→E/(1-ν²), ν→ν/(1-ν)
Es, nus = E / (1 - nu**2), nu / (1 - nu)
exx_ps_donusmus = (sxx - nus * syy) / Es
assert sp.simplify(exx_ps_donusmus - exx_ds) == 0
assert sp.simplify((1 + nus) / Es - (1 + nu) / E) == 0          # kayma terimi de tutarlı
# Ters dönüşüm geri götürür mü?
Eg, nug = E * (1 + 2 * nu) / (1 + nu)**2, nu / (1 + nu)
assert sp.simplify(Eg.subs(nu, nus).subs(E, Es) - E) == 0 and sp.simplify(nug.subs(nu, nus) - nu) == 0
print("Dönüşüm denetimi: E→E/(1-ν²), ν→ν/(1-ν) ve tersi  ✓")

# %% 2. Beltrami–Michell (2B), ısıl terimle
fx, fy, T = sp.Function("f_x")(x, y), sp.Function("f_y")(x, y), sp.Function("T")(x, y)
Sxx, Syy, Sxy = [sp.Function(n)(x, y) for n in ("S_xx", "S_yy", "S_xy")]


def bm(hal):
    if hal == "gerilme":
        exx = (Sxx - nu * Syy) / E + alpha * T
        eyy = (Syy - nu * Sxx) / E + alpha * T
    else:  # düzlemsel şekil değiştirme
        exx = (1 + nu) / E * ((1 - nu) * Sxx - nu * Syy) + (1 + nu) * alpha * T
        eyy = (1 + nu) / E * ((1 - nu) * Syy - nu * Sxx) + (1 + nu) * alpha * T
    exy = (1 + nu) / E * Sxy
    uyg = sp.diff(exx, y, 2) + sp.diff(eyy, x, 2) - 2 * sp.diff(exy, x, y)
    # dengeden: 2 σ_xy,xy = -(σ_xx,xx + σ_yy,yy + f_x,x + f_y,y)
    iki_sxy = -(sp.diff(Sxx, x, 2) + sp.diff(Syy, y, 2) + sp.diff(fx, x) + sp.diff(fy, y))
    uyg = uyg.subs(sp.Derivative(Sxy, x, y), iki_sxy / 2)
    return sp.expand(uyg)


lap = lambda f: sp.diff(f, x, 2) + sp.diff(f, y, 2)
div_f = sp.diff(fx, x) + sp.diff(fy, y)
hedef_g = lap(Sxx + Syy) + E * alpha * lap(T) + (1 + nu) * div_f
hedef_s = lap(Sxx + Syy) + E * alpha / (1 - nu) * lap(T) + div_f / (1 - nu)
print("\n=== 2. Beltrami–Michell (2B) ===")
print("düzlemsel gerilme   : ∇²(σxx+σyy) + Eα∇²ΔT = −(1+ν)(fx,x+fy,y)",
      "✓" if sp.simplify(bm("gerilme") * E - hedef_g) == 0 else "✗")
print("düzl. şekil değişt. : ∇²(σxx+σyy) + Eα/(1−ν)∇²ΔT = −(fx,x+fy,y)/(1−ν)",
      "✓" if sp.simplify(bm("sekil") * E / ((1 + nu) * (1 - nu)) - hedef_s) == 0 else "✗")

# %% 3. Aynı düzlem içi gerilmeler, iki hâl (çelik)
Ec, nuc = 210_000.0, 0.3                     # MPa
s = dict(xx=-80.0, yy=-30.0, xy=20.0)        # MPa
szz_c = nuc * (s["xx"] + s["yy"])
e_ds = [(1 + nuc) / Ec * ((1 - nuc) * s["xx"] - nuc * s["yy"]), (1 + nuc) / Ec * ((1 - nuc) * s["yy"] - nuc * s["xx"])]
e_dg = [(s["xx"] - nuc * s["yy"]) / Ec, (s["yy"] - nuc * s["xx"]) / Ec]
ezz_dg = -nuc / Ec * (s["xx"] + s["yy"])
exy = (1 + nuc) / Ec * s["xy"]


def von_mises(a, b, c, t):
    return np.sqrt(0.5 * ((a - b)**2 + (b - c)**2 + (c - a)**2) + 3 * t**2)


print("\n=== 3. Örnek 1: σxx=-80, σyy=-30, σxy=20 MPa, çelik ===")
print(f"düzl. şekil değişt.: σzz = {szz_c:.1f} MPa, εxx = {e_ds[0]*1e6:.1f}e-6, εyy = {e_ds[1]*1e6:.1f}e-6, εzz = 0")
print(f"düzlemsel gerilme : σzz = 0, εxx = {e_dg[0]*1e6:.1f}e-6, εyy = {e_dg[1]*1e6:.1f}e-6, εzz = {ezz_dg*1e6:.1f}e-6")
print(f"her iki hâlde εxy = {exy*1e6:.1f}e-6 (γxy = {2*exy*1e6:.1f}e-6)")
print(f"von Mises: şekil değişt. {von_mises(s['xx'], s['yy'], szz_c, s['xy']):.1f} MPa, "
      f"gerilme {von_mises(s['xx'], s['yy'], 0.0, s['xy']):.1f} MPa")

# %% 4. Gerilme alanı denetimi (kütle kuvveti yok, düzlemsel gerilme)
A = sp.symbols("A")
print("\n=== 4. Örnek 2: iki aday gerilme alanı ===")
for ad, (a, b, c) in {"(a) σxx=Ay², σyy=Ax²": (A * y**2, A * x**2, 0),
                      "(b) σxx=-Ay², σyy=Ax²": (-A * y**2, A * x**2, 0)}.items():
    d1 = sp.diff(a, x) + sp.diff(c, y)
    d2 = sp.diff(c, x) + sp.diff(b, y)
    bmk = sp.simplify(lap(a + b))
    print(f"{ad}: denge = ({d1}, {d2}), ∇²(σxx+σyy) = {bmk}")

# %% 5. Sabit gerilme hâlinden yer değiştirmeler (alüminyum levha 200×100×5 mm)
Ea, nua = 70_000.0, 0.33
p, q, t = 60.0, -20.0, 25.0
exx_a, eyy_a, exy_a = (p - nua * q) / Ea, (q - nua * p) / Ea, (1 + nua) / Ea * t
u = lambda X, Y: exx_a * X + exy_a * Y               # u(0)=v(0)=0, ω(0)=0
v = lambda X, Y: exy_a * X + eyy_a * Y
ezz_a = -nua / Ea * (p + q)
print("\n=== 5. Örnek 3: alüminyum levha, σxx=60, σyy=-20, σxy=25 MPa ===")
print(f"εxx = {exx_a*1e6:.1f}e-6, εyy = {eyy_a*1e6:.1f}e-6, εxy = {exy_a*1e6:.1f}e-6, εzz = {ezz_a*1e6:.1f}e-6")
for X, Y in [(200, 0), (0, 100), (200, 100)]:
    print(f"köşe ({X:3d},{Y:3d}) mm: u = {u(X, Y):.4f} mm, v = {v(X, Y):.4f} mm")
print(f"kalınlık değişimi Δh = εzz·5 = {ezz_a*5*1e3:.3f} µm")

# %% 6. Üçgen baraj: x yatay (mansap yönü), y aşağı, f_y = γc; memba yüzü x=0, mansap yüzü x = y·t
gw, gc, tt = sp.symbols("gamma_w gamma_c t", positive=True)
a1, b1, a2, b2, a3, b3 = sp.symbols("a1 b1 a2 b2 a3 b3")
Sx, Sy, Sxy_ = a1 * x + b1 * y, a2 * x + b2 * y, a3 * x + b3 * y
denk = [sp.diff(Sx, x) + sp.diff(Sxy_, y),                       # denge x
        sp.diff(Sxy_, x) + sp.diff(Sy, y) + gc,                  # denge y
        (Sx + gw * y).subs(x, 0), Sxy_.subs(x, 0),               # memba: σxx=-γw y, σxy=0
        sp.expand((Sx - tt * Sxy_).subs(x, tt * y)),             # mansap: serbest yüz, n ∝ (1, -t)
        sp.expand((Sxy_ - tt * Sy).subs(x, tt * y))]
cozum = sp.solve([sp.Poly(d, y).coeffs()[0] if d.has(y) else d for d in denk], [a1, b1, a2, b2, a3, b3], dict=True)[0]
print("\n=== 6. Örnek 4: üçgen ağırlık barajı (doğrusal gerilme alanı) ===")
for k in (a1, b1, a2, b2, a3, b3):
    print(f"{k} = {sp.simplify(cozum[k])}")
sayi = {gw: 9.81, gc: 24.0, tt: 0.8}
H = 30.0
for ad, X in (("topuk (memba, x=0)", 0.0), ("burun (mansap, x=tH)", 0.8 * H)):
    vals = [float(e.subs(cozum).subs(sayi).subs({x: X, y: H})) / 1000 for e in (Sx, Sy, Sxy_)]
    print(f"taban y={H:.0f} m, {ad}: σxx = {vals[0]:.3f}, σyy = {vals[1]:.3f}, σxy = {vals[2]:.3f} MPa")
t_min = sp.sqrt(gw / gc).subs(sayi)
print(f"topukta çekme olmaması için t = tanβ ≥ √(γw/γc) = {float(t_min):.3f}")

# %% 7. Alıştırmaların sayısal sonuçları
print("\n=== 7. Alıştırmalar ===")
# Alıştırma 2: alüminyum, σxx = 40, σyy = 10 MPa
sx, sy = 40.0, 10.0
print(f"Alıştırma 2 (DŞD): σzz = {nua*(sx+sy):.1f} MPa, εxx = {(1+nua)/Ea*((1-nua)*sx-nua*sy)*1e6:.1f}e-6, "
      f"εyy = {(1+nua)/Ea*((1-nua)*sy-nua*sx)*1e6:.1f}e-6")
print(f"Alıştırma 2 (DG) : εxx = {(sx-nua*sy)/Ea*1e6:.1f}e-6, εyy = {(sy-nua*sx)/Ea*1e6:.1f}e-6, "
      f"εzz = {-nua*(sx+sy)/Ea*1e6:.1f}e-6")
# Alıştırma 4: çelik levha, saf kayma τ = 50 MPa, H = 100 mm
Gc = Ec / (2 * (1 + nuc))
print(f"Alıştırma 4: G = {Gc:.0f} MPa, ω = τ/(2G) = {50/(2*Gc):.3e} rad, u(0,H) = {50/Gc*100:.4f} mm")
# Alıştırma 7: yanları tutulu dolgu, E = 50 MPa, ν = 0.3, ρg = 20 kN/m³, H = 10 m
Ed, nud, rg, Hd = 50.0, 0.3, 0.020, 10.0          # MPa, -, MN/m³, m
l2m = Ed * (1 - nud) / ((1 + nud) * (1 - 2 * nud))
print(f"Alıştırma 7: λ+2μ = {l2m:.1f} MPa, tabanda σyy = {-rg*Hd*1000:.1f} kPa, σxx = {-rg*Hd*1000*nud/(1-nud):.1f} kPa, "
      f"K0 = {nud/(1-nud):.3f}, oturma v(H) = {-rg*Hd**2/(2*l2m)*1000:.1f} mm")
# Alıştırma 8: baraj topuğu
for tv in (0.7, 0.6):
    print(f"Alıştırma 8: t = {tv}: topukta σyy = {(9.81/tv**2 - 24.0)*30.0:.1f} kPa")
print(f"Alıştırma 8: t_min = {np.sqrt(9.81/24.0):.3f}, en küçük taban genişliği = {np.sqrt(9.81/24.0)*30.0:.1f} m")
