"""Ders 12 — Kutupsal koordinatlarda elastisite: eksenel simetrik problemler (doğrulama betiği).

Ne yapar?
  1. Kutupsal Airy formüllerinin denge denklemlerini özdeş olarak sağladığını ve Kartezyen
     dönüşümle aynı gerilmeleri verdiğini SymPy ile gösterir.
  2. Eksenel simetrik biharmonik denklemi çözer, genel çözümün gerilme ve yer değiştirmelerini
     bulur (B teriminin çok değerli u_theta ürettiğini gösterir).
  3. Lamé (kalın boru), sıkı geçme ve dönen disk sayısal örneklerini ve alıştırmaları hesaplar.
Birimler: mm, N, MPa. Çelik: E = 210 GPa, nu = 0,3, rho = 7850 kg/m^3 = 7,85e-9 t/mm^3.

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

r, th, E, nu = sp.symbols("r theta E nu", positive=True)

# %% 1. Airy fonksiyonu ve denge (kütle kuvveti yok)
print("=== 1. Kutupsal Airy formülleri ===")
F = sp.Function("F")(r, th)
srr = sp.diff(F, r) / r + sp.diff(F, th, 2) / r**2
stt = sp.diff(F, r, 2)
srt = -sp.diff(sp.diff(F, th) / r, r)
d1 = sp.simplify(sp.diff(srr, r) + sp.diff(srt, th) / r + (srr - stt) / r)
d2 = sp.simplify(sp.diff(srt, r) + sp.diff(stt, th) / r + 2 * srt / r)
print("1. denge denklemi:", d1, "| 2. denge denklemi:", d2)
x, y = sp.symbols("x y")
Fk = x**3 * y - 2 * x * y**3 + x**2 * y**2                     # rastgele bir Kartezyen fonksiyon
sxx, syy, sxy = sp.diff(Fk, y, 2), sp.diff(Fk, x, 2), -sp.diff(Fk, x, y)
yer = {x: r * sp.cos(th), y: r * sp.sin(th)}
Fp = Fk.subs(yer)
srr_d = (sxx * sp.cos(th)**2 + syy * sp.sin(th)**2 + 2 * sxy * sp.sin(th) * sp.cos(th)).subs(yer)
srt_d = ((syy - sxx) * sp.sin(th) * sp.cos(th) + sxy * (sp.cos(th)**2 - sp.sin(th)**2)).subs(yer)
fark1 = sp.simplify(srr_d - (sp.diff(Fp, r) / r + sp.diff(Fp, th, 2) / r**2))
fark2 = sp.simplify(srt_d + sp.diff(sp.diff(Fp, th) / r, r))
print("Kartezyen dönüşümle fark (srr, srt):", fark1, fark2)

# %% 2. Eksenel simetrik genel çözüm
print("\n=== 2. Eksenel simetrik genel çözüm ===")
f = sp.Function("f")
lap = lambda g: sp.diff(g, r, 2) + sp.diff(g, r) / r
print(sp.dsolve(sp.Eq(lap(lap(f(r))), 0)))
A, B, C = sp.symbols("A B C")
Fa = A * sp.log(r) + B * r**2 * sp.log(r) + C * r**2
srr, stt = sp.simplify(sp.diff(Fa, r) / r), sp.simplify(sp.diff(Fa, r, 2))
print("srr =", srr, "| stt =", stt)
K1, K2, K3 = sp.symbols("K1 K2 K3")
ur = (-(1 + nu) * A / r + 2 * (1 - nu) * B * r * sp.log(r) - (1 + nu) * B * r + 2 * (1 - nu) * C * r) / E \
     + K1 * sp.sin(th) + K2 * sp.cos(th)
ut = 4 * B * r * th / E + K1 * sp.cos(th) - K2 * sp.sin(th) + K3 * r
err = sp.diff(ur, r); ett = ur / r + sp.diff(ut, th) / r
ert = (sp.diff(ur, th) / r + sp.diff(ut, r) - ut / r) / 2
kontrol = [sp.simplify(err - (srr - nu * stt) / E), sp.simplify(ett - (stt - nu * srr) / E), sp.simplify(ert)]
print("düzlemsel gerilme Hooke kontrolü (0 olmalı):", kontrol)
assert all(k == 0 for k in kontrol)
print("theta=2*pi'de u_theta sıçraması =", sp.simplify(ut.subs(th, 2 * sp.pi) - ut.subs(th, 0)))
# Adım adım integrasyon: u_r = ∫eps_rr dr + f(theta); du_theta/dtheta = r*eps_tt - u_r
ur0 = sp.integrate(sp.expand((srr - nu * stt) / E), r)
dut = sp.simplify(sp.expand(r * (stt - nu * srr) / E - ur0))
print("integrasyon: r*eps_tt - ∫eps_rr dr =", dut, "(A ve C'li terimler sadeleşir)")
assert sp.simplify(dut - 4 * B * r / E) == 0

# %% 3. Lamé: kalın cidarlı boru
print("\n=== 3. Lamé: a=100 mm, b=150 mm, p_i=50 MPa ===")
a, b, pi_, po = sp.symbols("a b p_i p_o", positive=True)
lame = sp.solve([(A / r**2 + 2 * C).subs(r, a) + pi_, (A / r**2 + 2 * C).subs(r, b) + po], [A, C], dict=True)[0]
print("A =", sp.factor(lame[A]), "| 2C =", sp.factor(2 * lame[C]))
Es, nus = 210000.0, 0.3
an, bn, pn = 100.0, 150.0, 50.0
An = float(lame[A].subs({a: an, b: bn, pi_: pn, po: 0}))
Cn2 = float(2 * lame[C].subs({a: an, b: bn, pi_: pn, po: 0}))
sr = lambda rr: An / rr**2 + Cn2
st = lambda rr: -An / rr**2 + Cn2
print(f"A = {An:.0f} MPa*mm^2, 2C = {Cn2:.2f} MPa")
print(f"sigma_rr(a) = {sr(an):.2f}, sigma_tt(a) = {st(an):.2f}, sigma_tt(b) = {st(bn):.2f} MPa")
print(f"tau_max(a) = {(st(an) - sr(an)) / 2:.2f} MPa ; sigma_rr + sigma_tt = {sr(an) + st(an):.2f} MPa (sabit)")
print(f"düzlemsel şekil değiştirme sigma_zz = {nus * Cn2 * 2:.2f} MPa ; kapalı uç sigma_zz = {Cn2:.2f} MPa")
ur_dg = ((1 - nus) * Cn2 * an - (1 + nus) * An / an) / Es
ur_dsd = (1 + nus) / Es * ((1 - 2 * nus) * Cn2 * an - An / an)
ur_kap = an * (st(an) - nus * (sr(an) + Cn2)) / Es
print(f"u_r(a): düzlemsel gerilme {ur_dg:.5f} mm, düzlemsel ş.d. {ur_dsd:.5f} mm, kapalı uçlu boru {ur_kap:.5f} mm")
def vm(s1, s2, s3):
    return np.sqrt(0.5 * ((s1 - s2)**2 + (s2 - s3)**2 + (s3 - s1)**2))
print(f"iç yüzde von Mises: sigma_zz=0 için {vm(st(an), sr(an), 0):.2f} MPa, kapalı uçlu boru için {vm(st(an), sr(an), Cn2):.2f} MPa")
Rm, t = (an + bn) / 2, bn - an
print(f"ince cidar: p R_m / t = {pn * Rm / t:.2f} MPa, p a / t = {pn * an / t:.2f} MPa")
for ta in (0.1, 0.5):
    be = 1 + ta
    lm, io, ii = (be**2 + 1) / (be**2 - 1), (be + 1) / (2 * (be - 1)), 1 / (be - 1)
    print(f"t/a = {ta}: Lamé {lm:.3f} p, pR_m/t {io:.3f} p (eksik %{100 * (lm - io) / lm:.1f}), "
          f"pa/t {ii:.3f} p (eksik %{100 * (lm - ii) / lm:.1f})")
bo = 2.0
print(f"Alıştırma: yalnız dış basınç, b/a=2, p_o=10 MPa -> sigma_tt(a) = {-2 * 10 * bo**2 / (bo**2 - 1):.2f} MPa")

# tasarım: hidrolik silindir, a = 40 mm, p = 25 MPa, izin verilen gerilme 120 MPa
ad_, pd_, si = 40.0, 25.0, 120.0
b_tr = ad_ * np.sqrt((si / 2 / pd_) / (si / 2 / pd_ - 1))          # Tresca: p b^2/(b^2-a^2) <= si/2
b_ce = ad_ * np.sqrt((si / pd_ + 1) / (si / pd_ - 1))              # çevresel gerilme <= si
print(f"Tasarım: Tresca ile b >= {b_tr:.2f} mm ; çevresel gerilme ölçütüyle b >= {b_ce:.2f} mm")

# %% 4. Sıkı geçme
print("\n=== 4. Sıkı geçme (çelik, yarıçapta girişim delta) ===")
def temas(delta, c, b, a=0.0, E=Es, n=nus):
    gobek = ((b**2 + c**2) / (b**2 - c**2) + n) / E
    mil = ((c**2 + a**2) / (c**2 - a**2) - n) / E
    return delta / (c * (gobek + mil))
cn, bn2, dl = 50.0, 100.0, 0.03
p = temas(dl, cn, bn2)
print(f"dolu mil: p = {p:.2f} MPa ; göbek sigma_tt(c) = {p * (bn2**2 + cn**2) / (bn2**2 - cn**2):.2f} MPa, "
      f"sigma_tt(b) = {2 * p * cn**2 / (bn2**2 - cn**2):.2f} MPa ; mil sigma = {-p:.2f} MPa")
print(f"göbeği sıcak geçirmek için gereken en az sıcaklık farkı (alfa = 12e-6 1/C): {dl / (12e-6 * cn):.1f} C")
ph = temas(dl, cn, bn2, a=20.0)
print(f"Alıştırma: içi boş mil (a=20 mm): p = {ph:.2f} MPa ; mil iç yüzü sigma_tt = {-2 * ph * cn**2 / (cn**2 - 20.0**2):.2f} MPa")
# hedef temas basıncı için gereken girişim: rijit mil ve elastik dolu mil (düzlemsel gerilme)
ph_ = 60.0
d_rijit = cn * ph_ / Es * ((bn2**2 + cn**2) / (bn2**2 - cn**2) + nus)
d_elastik = 2 * cn * bn2**2 * ph_ / (Es * (bn2**2 - cn**2))
print(f"Alıştırma: p = {ph_:.0f} MPa için gereken girişim: rijit mil {d_rijit:.4f} mm, elastik dolu çelik mil {d_elastik:.4f} mm")
print(f"  rijit mil varsayımı girişimi %{100 * (1 - d_rijit / d_elastik):.1f} küçük tahmin eder")

# %% 5. Dönen disk
print("\n=== 5. Dönen disk (düzlemsel gerilme) ===")
rho, w = sp.symbols("rho omega", positive=True)
u = sp.Function("u")
ode = sp.Eq(sp.diff(sp.diff(r * u(r), r) / r, r), -(1 - nu**2) * rho * w**2 * r / E)
print(sp.dsolve(ode))
# Airy yoluyla kontrol: V = -rho w^2 r^2/2, sigma_rr = F'/r + V, sigma_tt = F'' + V; düzlemsel gerilmede
# nabla^4 F = -(1-nu) nabla^2 V = 2(1-nu) rho w^2 olmalı (dolu disk çözümüyle)
V = -rho * w**2 * r**2 / 2
bb = sp.Symbol("b", positive=True)
srr_d = (3 + nu) / 8 * rho * w**2 * (bb**2 - r**2)
stt_d = rho * w**2 / 8 * ((3 + nu) * bb**2 - (1 + 3 * nu) * r**2)
Fp = r * (srr_d - V)                                   # F'
lapF = sp.diff(Fp, r) + Fp / r                         # nabla^2 F = F'' + F'/r
print("F'' = sigma_tt - V ?", sp.simplify(sp.diff(Fp, r) - (stt_d - V)) == 0,
      "| nabla^4 F =", sp.factor(sp.simplify(sp.diff(lapF, r, 2) + sp.diff(lapF, r) / r)))
rhon = 7.85e-9                      # t/mm^3  (N s^2/mm^4)
bd, n_dev = 250.0, 6000.0
om = 2 * np.pi * n_dev / 60
k = rhon * om**2 * bd**2
print(f"omega = {om:.2f} rad/s ; rho*omega^2*b^2 = {k:.2f} MPa")
print(f"dolu disk merkez: {(3 + nus) / 8 * k:.2f} MPa ; dış kenar sigma_tt = {(3 + nus - 1 - 3 * nus) / 8 * k:.2f} MPa")
al = 0.1
sa = ((3 + nus) / 8 * (2 + al**2) - (1 + 3 * nus) / 8 * al**2)
print(f"delikli disk (a/b=0,1) delik kenarı sigma_tt = {sa * k:.2f} MPa ; dolu merkeze oranı = {sa / ((3 + nus) / 8):.3f}")
om_max = np.sqrt(150.0 / ((3 + nus) / 8 * rhon * bd**2))
print(f"Alıştırma: dolu disk, sigma_izin = 150 MPa -> omega_max = {om_max:.1f} rad/s = {om_max * 60 / (2 * np.pi):.0f} dev/dk")
