"""Ders 14 — Prizmatik çubukların burulması: Prandtl gerilme fonksiyonu.

Derste türetilen çözümleri denetler ve çözümlü örneklerin sayılarını hesaplar:
  1. Daire, elips, eşkenar üçgen: ∇²φ = -2Gα, sınırda φ = 0, J_t ve τ_max (SymPy)
  2. Elipste çarpılma fonksiyonu ψ: ∇²ψ = 0 ve sınır koşulu
  3. Dikdörtgen kesit (b × t, b ≥ t): Fourier serisinden k1, k2 tablosu
  4. Aynı alanda biçim karşılaştırması (J_t/A²)
  5. Kare kesit için sonlu farklarla bağımsız denetim
  6. Sayısal örnekler: dikdörtgen çubuk, elips mil, ince cidarlı açık/kapalı boru

Çalıştır:  python e14_burulma.py
Gerekenler: numpy, scipy, sympy  (Python 3.10+)
"""
import numpy as np
import sympy as sp
from scipy.sparse import diags, kron, identity
from scipy.sparse.linalg import spsolve

x, y = sp.symbols("x y", real=True)
G, al = sp.symbols("G alpha", positive=True)


def lap(f):
    return sp.simplify(sp.diff(f, x, 2) + sp.diff(f, y, 2))


# %% 1. Kapalı çözümler
print("=== 1. Daire, elips, eşkenar üçgen ===")
a, b, R, h = sp.symbols("a b R h", positive=True)
th = sp.Symbol("theta", real=True)

# Elips: φ = K (x²/a² + y²/b² - 1)
K = sp.Symbol("K")
phi_e = K * (x**2 / a**2 + y**2 / b**2 - 1)
Ke = sp.solve(sp.Eq(lap(phi_e), -2 * G * al), K)[0]
phi_e = phi_e.subs(K, Ke)
# M_t = 2∫φ dA  (x = a ρ cosθ, y = b ρ sinθ, dA = a b ρ dρ dθ)
rho = sp.Symbol("rho", positive=True)
Mt_e = sp.simplify(2 * sp.integrate(sp.integrate(
    phi_e.subs({x: a * rho * sp.cos(th), y: b * rho * sp.sin(th)}) * a * b * rho, (rho, 0, 1)), (th, 0, 2 * sp.pi)))
J_e = sp.simplify(Mt_e / (G * al))
print("Elips: K =", sp.factor(Ke), "| J_t =", sp.factor(J_e))
tau_b = sp.simplify(sp.Abs(sp.diff(phi_e, y)).subs({x: 0, y: b}))      # küçük eksen ucunda (b < a)
print("Elips: küçük eksen ucunda τ =", sp.factor(tau_b), "= 2 M_t/(π a b²) ?",
      sp.simplify(tau_b - 2 * Mt_e / (sp.pi * a * b**2)) == 0)
J_c = sp.simplify(J_e.subs({a: R, b: R}))
print("Daire (a = b = R): J_t =", J_c, "(kutupsal atalet momenti πR⁴/2)")

# Elipste çarpılma: ψ = -(a²-b²)/(a²+b²) x y
psi = -(a**2 - b**2) / (a**2 + b**2) * x * y
print("Elips çarpılma ψ: ∇²ψ =", lap(psi))
# sınır koşulu: (ψ,x - y) n_x + (ψ,y + x) n_y = 0, n ∝ (x/a², y/b²)
sk = sp.simplify(((sp.diff(psi, x) - y) * x / a**2 + (sp.diff(psi, y) + x) * y / b**2))
print("Elips sınır koşulu kalanı:", sk)
# gerilme fonksiyonuyla tutarlılık: σxz = Gα(ψ,x - y) = φ,y
print("σxz uyumu:", sp.simplify(G * al * (sp.diff(psi, x) - y) - sp.diff(phi_e, y)))

# Eşkenar üçgen: yükseklik h, ağırlık merkezi başlangıçta, bir köşe +x üzerinde
phi_t = K * (x + h / 3) * (x + sp.sqrt(3) * y - 2 * h / 3) * (x - sp.sqrt(3) * y - 2 * h / 3)
Kt = sp.solve(sp.Eq(lap(phi_t), -2 * G * al), K)[0]
phi_t = sp.expand(phi_t.subs(K, Kt))
print("Üçgen: K =", Kt, "| ∇²φ =", lap(phi_t))
s = 2 * h / sp.sqrt(3)  # kenar uzunluğu
ust = (2 * h / 3 - x) / sp.sqrt(3)   # y'nin üst sınırı
Mt_t = sp.simplify(2 * sp.integrate(sp.integrate(phi_t, (y, -ust, ust)), (x, -h / 3, 2 * h / 3)))
J_t = sp.simplify(Mt_t / (G * al))
sx = sp.Symbol("s", positive=True)
print("Üçgen: J_t =", sp.simplify(J_t.subs(h, sp.sqrt(3) * sx / 2)), "(s: kenar)")
tau_kenar = sp.simplify(sp.diff(phi_t, x).subs(x, -h / 3))   # x = -h/3 kenarında |φ,x|
tmax = sp.simplify(sp.Abs(tau_kenar.subs(y, 0)))
print("Üçgen: kenar ortasında τ =", tmax, "| τ_max·s³/M_t =",
      sp.nsimplify(sp.simplify((tmax / (Mt_t / sx**3)).subs(h, sp.sqrt(3) * sx / 2))))

# %% 2. Dikdörtgen: Fourier serisi
print("\n=== 2. Dikdörtgen kesit b × t (b ≥ t): k1, k2 ===")


def k1k2(oran, N=200):
    n = np.arange(1, 2 * N, 2)
    arg = n * np.pi * oran / 2
    k1 = (1 - 192 / np.pi**5 / oran * np.sum(np.tanh(arg) / n**5)) / 3
    with np.errstate(over="ignore"):
        tau = 1 - 8 / np.pi**2 * np.sum(1 / (n**2 * np.cosh(arg)))   # τ_max / (G α t)
    return k1, k1 / tau


print(" b/t      k1       k2")
for oran in (1, 1.5, 2, 2.5, 3, 4, 5, 6, 10, 20):
    k1, k2 = k1k2(oran)
    print(f"{oran:4g}   {k1:.4f}   {k2:.4f}")
print(" ∞      0.3333   0.3333")
k1, k2 = k1k2(1.0)
assert abs(k1 - 0.1406) < 5e-4 and abs(k2 - 0.208) < 1e-3

# %% 3. Aynı alanda hangi kesit daha rijit? (J_t / A²)
print("\n=== 3. Biçim karşılaştırması: J_t / A² ===")
oranlar = {
    "daire": 1 / (2 * np.pi),
    "kare": k1k2(1.0)[0],
    "elips a = 2b": 2 / (5 * np.pi),
    "eşkenar üçgen": (np.sqrt(3) / 80) / (3 / 16),
    "dikdörtgen 2:1": k1k2(2.0)[0] * 2 / 4,
    "dikdörtgen 10:1": k1k2(10.0)[0] * 10 / 100,
}
for ad, deger in oranlar.items():
    print(f"   {ad:16s} J_t/A² = {deger:.4f}  (dairenin {deger / oranlar['daire'] * 100:5.1f}%'i)")

# %% 4. Sonlu farklarla kare kesit denetimi
print("\n=== 4. Kare kesit, sonlu farklar (∇²φ = -2, Gα = 1, t = b = 1) ===")
for N in (40, 80, 160):
    hh = 1.0 / N
    m = N - 1
    D = diags([1.0, -2.0, 1.0], [-1, 0, 1], shape=(m, m)) / hh**2
    A = kron(identity(m), D) + kron(D, identity(m))
    phi = spsolve(A.tocsc(), -2 * np.ones(m * m))
    J = 2 * phi.sum() * hh**2
    print(f"N = {N:3d}: k1 ≈ {J:.5f}")

# %% 5. Sayısal örnekler
print("\n=== 5. Sayısal örnekler (çelik, G = 80,77 GPa) ===")
Gs = 80770.0  # MPa = N/mm²
# Dikdörtgen çubuk 60 × 20 mm, M_t = 500 N·m
bb, tt, Mt = 60.0, 20.0, 500e3
k1, k2 = k1k2(bb / tt)
J = k1 * bb * tt**3
print(f"Dikdörtgen 60×20 mm, M_t = 0,5 kN·m: k1 = {k1:.4f}, k2 = {k2:.4f}, J_t = {J:.0f} mm⁴, "
      f"τ_max = {Mt / (k2 * bb * tt**2):.1f} MPa, α = {Mt / (Gs * J) * 1000 * 180 / np.pi:.3f} °/m")
# Elips mil a = 30, b = 20 mm, M_t = 400 N·m; aynı alanlı daire
ae, be, Mt = 30.0, 20.0, 400e3
Je = np.pi * ae**3 * be**3 / (ae**2 + be**2)
print(f"Elips 2a×2b = 60×40 mm, M_t = 0,4 kN·m: J_t = {Je:.0f} mm⁴, τ_max = {2 * Mt / (np.pi * ae * be**2):.1f} MPa "
      f"(küçük eksen ucunda), α = {Mt / (Gs * Je) * 1000 * 180 / np.pi:.3f} °/m")
Rc = np.sqrt(ae * be)
Jc = np.pi * Rc**4 / 2
print(f"   aynı alanlı daire R = {Rc:.2f} mm: J_t = {Jc:.0f} mm⁴, τ_max = {2 * Mt / (np.pi * Rc**3):.1f} MPa; "
      f"elipsin J_t/I_p = {Je / (np.pi * ae * be * (ae**2 + be**2) / 4):.3f}")
# İnce cidarlı boru: ortalama yarıçap 50 mm, t = 3 mm
Rm, tw = 50.0, 3.0
Am = np.pi * Rm**2
J_kapali = 4 * Am**2 / (2 * np.pi * Rm / tw)
J_acik = 2 * np.pi * Rm * tw**3 / 3
print(f"Boru R_m = 50 mm, t = 3 mm: J_kapalı = {J_kapali:.4g} mm⁴, J_açık (yarıklı) = {J_acik:.4g} mm⁴, "
      f"oran = {J_kapali / J_acik:.0f}")
tau_izin = 100.0
M_kap = 2 * Am * tw * tau_izin
M_ac = tau_izin * J_acik / tw
print(f"   τ = 100 MPa için taşınan moment: kapalı {M_kap / 1e6:.2f} kN·m, açık {M_ac / 1e3:.1f} N·m, oran = {M_kap / M_ac:.0f}")
Mt = 1e6
print(f"   M_t = 1 kN·m: kapalı τ = {Mt / (2 * Am * tw):.2f} MPa, α = {Mt / (Gs * J_kapali) * 1000 * 180 / np.pi:.3f} °/m")
