"""Ders 11 — Kartezyen koordinatlarda örnek çözümler: kirişler (doğrulama betiği).

Ne yapar?
  1. Ucundan yüklü konsolun Airy fonksiyonunu SymPy ile kurar: biharmonik denklemi ve bütün
     sınır koşullarını denetler, katsayıları bulur, yer değiştirmeleri integre eder.
  2. Düzgün yayılı yüklü basit kirişin 5. derece polinom çözümünü genel bir polinomdan
     (bilinmeyen katsayılarla) çözdürür ve orta nokta çökmesini bulur.
  3. Dersteki sayısal örneklerin ve alıştırmaların sayılarını hesaplar.
Koordinatlar: x kiriş ekseni, y yukarı, -c <= y <= c, birim kalınlık, I = 2c^3/3, düzlemsel gerilme.

Çalıştır:   python e11_kiris_cozumleri.py
Gerekenler: numpy, sympy   (süre: birkaç saniye)
"""
import math

import numpy as np
import sympy as sp

x, y, c, L, P, q, E, nu = sp.symbols("x y c L P q E nu", positive=True)
I = 2 * c**3 / 3
G = E / (2 * (1 + nu))


def gerilmeler(F):
    """Kütle kuvveti yokken Airy: sxx = F,yy  syy = F,xx  sxy = -F,xy"""
    return sp.diff(F, y, 2), sp.diff(F, x, 2), -sp.diff(F, x, y)


def biharmonik(F):
    return sp.simplify(sp.diff(F, x, 4) + 2 * sp.diff(F, x, 2, y, 2) + sp.diff(F, y, 4))


# %% 1. Ucundan yüklü konsol (serbest uç x=0, uç yükü P aşağı; ankastre uç x=L)
print("=== 1. Ucundan yüklü konsol ===")
A, B = sp.symbols("A B")
F = A * x * y + B * x * y**3
sxx, syy, sxy = gerilmeler(F)
kat = sp.solve([sxy.subs(y, c), sp.integrate(sxy, (y, -c, c)) - P], [A, B], dict=True)[0]
print("biharmonik:", biharmonik(F), "| A =", kat[A], "| B =", kat[B])
sxx, sxy = sp.simplify(sxx.subs(kat)), sp.simplify(sxy.subs(kat))
assert sp.simplify(sxx - P * x * y / I) == 0 and sp.simplify(sxy - P * (c**2 - y**2) / (2 * I)) == 0
print("sxx = P x y / I ; syy = 0 ; sxy = P (c^2 - y^2) / (2I)  -> doğrulandı")
print("Serbest uçta N =", sp.integrate(sxx.subs(x, 0), (y, -c, c)),
      "| M =", sp.integrate(sxx.subs(x, 0) * y, (y, -c, c)))
print("Ankastre uçta M =", sp.simplify(sp.integrate(sxx.subs(x, L) * y, (y, -c, c))), " (= P L)")

# yer değiştirmeler: u = ∫exx dx + f(y), v = ∫eyy dy + g(x); kayma koşulu f ve g'yi verir
C1, C2, u0, v0 = sp.symbols("C_1 C_2 u_0 v_0")
u = P * x**2 * y / (2 * E * I) + nu * P * y**3 / (6 * E * I) - P * y**3 / (6 * G * I) + C2 * y + u0
v = -nu * P * x * y**2 / (2 * E * I) - P * x**3 / (6 * E * I) + C1 * x + v0
kayma = sp.simplify(sp.diff(u, y) + sp.diff(v, x) - sxy / G)
assert sp.simplify(sp.diff(u, x) - sxx / E) == 0 and sp.simplify(sp.diff(v, y) + nu * sxx / E) == 0
print("kayma koşulu kalanı:", sp.simplify(kayma), " -> C1 + C2 = P c^2/(2 G I)")
u = u.subs(C2, P * c**2 / (2 * G * I) - C1)
kosullar = (("A (eksen yatay, dv/dx=0)", sp.diff(v, x).subs({x: L, y: 0})),
            ("B (kesit düşey, du/dy=0)", sp.diff(u, y).subs({x: L, y: 0})),
            ("C (ortalama dönme sıfır)", sp.integrate(u.subs(x, L) * y, (y, -c, c))))
for ad, kosul in kosullar:
    s = sp.solve([u.subs({x: L, y: 0}), v.subs({x: L, y: 0}), kosul], [u0, v0, C1], dict=True)[0]
    fark = sp.simplify(v.subs(s).subs({x: 0, y: 0}) + P * L**3 / (3 * E * I))
    print(f"Koşul {ad}: v(0,0) = -P L^3/(3EI) + ({sp.factor(fark)})")
    if fark != 0:                                   # kayma katkısını P L/(kappa G A) ile eşleştir, A = 2c
        kappa = sp.simplify(-P * L / (2 * c * G) / fark)
        print(f"    kappa = {sp.factor(kappa)}  (nu=0: {kappa.subs(nu, 0)}, nu=0,3: {float(kappa.subs(nu, 0.3)):.4f})")

# %% 2. Sayısal örnek: çelik konsol
print("\n=== 2. Sayısal örnek: çelik konsol ===")
Es, nus = 210000.0, 0.3                         # MPa
Gs = Es / (2 * (1 + nus))
Ln, cn, Pn = 1000.0, 100.0, 1000.0              # mm, mm, N/mm (20 kN / 20 mm kalınlık)
In = 2 * cn**3 / 3
print(f"I = {In:.0f} mm^4/mm, G = {Gs:.0f} MPa")
print(f"en büyük sxx (x=L, y=c)   = {Pn * Ln * cn / In:.2f} MPa")
print(f"en büyük sxy (y=0)        = {3 * Pn / (4 * cn):.3f} MPa  (ortalama {Pn / (2 * cn):.3f})")
vb = Pn * Ln**3 / (3 * Es * In)
vs = 3 * Pn * Ln / (4 * Gs * cn)
print(f"Euler-Bernoulli uç çökmesi = {vb:.4f} mm ; kayma katkısı (B) = {vs:.4f} mm ; oran = %{100 * vs / vb:.2f}")
print(f"Alıştırma: sxx(L/2, c/2) = {Pn * (Ln / 2) * (cn / 2) / In:.3f} MPa, sxy(L/2, c/2) = {Pn * (cn**2 - cn**2 / 4) / (2 * In):.4f} MPa")
print(f"Alıştırma: koşul A'da ankastre kesitin dönmesi du/dy(L,0) = {3 * Pn / (4 * Gs * cn):.3e} rad")
Nb = 500.0                                       # N/mm, serbest uçta eksenel basınç
print(f"Alıştırma: N = {Nb:.0f} N/mm basınçla ankastre kesitte sxx = 0 düzeyi y = N c^2/(3 P L) = {Nb * cn**2 / (3 * Pn * Ln):.3f} mm ; "
      f"en büyük basınç {-Pn * Ln * cn / In - Nb / (2 * cn):.2f} MPa, en büyük çekme {Pn * Ln * cn / In - Nb / (2 * cn):.2f} MPa")

# %% 3. Düzgün yayılı yüklü basit kiriş (açıklık 2L): genel 5. derece polinomdan çözüm
print("\n=== 3. Düzgün yayılı yüklü basit kiriş ===")
kats, F = [], 0
for m in range(6):
    for n in range(6 - m):
        if m + n >= 2:
            s = sp.Symbol(f"a{m}{n}"); kats.append(s); F += s * x**m * y**n
den = sp.Poly(sp.expand(sp.diff(F, x, 4) + 2 * sp.diff(F, x, 2, y, 2) + sp.diff(F, y, 4)), x, y).coeffs()
sxx, syy, sxy = gerilmeler(F)
for ifade in (syy.subs(y, c) + q, sxy.subs(y, c), syy.subs(y, -c), sxy.subs(y, -c)):
    den += sp.Poly(sp.expand(ifade), x).coeffs()
for X, V in ((L, q * L), (-L, -q * L)):
    den += [sp.integrate(sxx.subs(x, X), (y, -c, c)), sp.integrate(sxx.subs(x, X) * y, (y, -c, c)),
            sp.integrate(sxy.subs(x, X), (y, -c, c)) - V]
cozum = sp.solve(den, kats, dict=True)[0]
sxx, syy, sxy = [sp.factor(t.subs(cozum)) for t in (sxx, syy, sxy)]
print("tek çözüm, serbest katsayı sayısı:", len([s for s in kats if s not in cozum]))
print("sxx =", sxx); print("syy =", syy); print("sxy =", sxy)
oran = sp.simplify(sxx.subs({x: 0, y: c}) / (-(q * L**2 / 2) * c / I))
print("orta kesitte üst lif: kesin / kiriş teorisi =", sp.expand(oran))
print("uçta kalan sxx(L, c) =", sp.simplify(sxx.subs({x: L, y: c})), "; syy(x, 0) =", sp.simplify(syy.subs(y, 0)))
exx, eyy = (sxx - nu * syy) / E, (syy - nu * sxx) / E
u0, v0 = sp.integrate(exx, x), sp.integrate(eyy, y)
kalan = sp.expand(sxy / G - sp.diff(u0, y) - sp.diff(v0, x))     # yalnız x'e bağlı çıkar: g'(x)
g = sp.integrate(kalan, x)
d1, h1 = sp.symbols("d1 h1")
v = v0 + g + h1                                                   # simetri: u(0,0)=0, dönme(0,0)=0 -> d1=0
h_ = sp.solve(v.subs({x: L, y: 0}), h1)[0]
vort = sp.factor(v.subs(h1, h_).subs({x: 0, y: 0}))
print("orta nokta çökmesi v(0,0) =", vort)
print("kesin / kiriş teorisi =", sp.expand(sp.simplify(vort / (-5 * q * (2 * L)**4 / (384 * E * I)))))

# %% 4. Sayısal örnek: derin beton kiriş
print("\n=== 4. Sayısal örnek: derin kiriş (beton, E=30 GPa, nu=0,2) ===")
Eb, nub, qn, Lb, cb = 30000.0, 0.2, 0.4, 1500.0, 500.0
Ib = 2 * cb**3 / 3
sk = (qn * Lb**2 / 2) * cb / Ib
print(f"kiriş teorisi en büyük sxx = {sk:.4f} MPa ; kesin = {sk * (1 + 4 / 15 * (cb / Lb)**2):.4f} MPa")
vk = 5 * qn * (2 * Lb)**4 / (384 * Eb * Ib)
vk_kesin = vk * (1 + (48 + 30 * nub) / 25 * (cb / Lb)**2)
print(f"kesin gerilme kiriş teorisinden %{100 * 4 / 15 * (cb / Lb)**2:.2f} büyük")
print(f"kiriş teorisi çökme = {vk:.5f} mm ; kesin = {vk_kesin:.5f} mm")
print(f"kesin çökme kiriş teorisininkinden %{100 * (vk_kesin / vk - 1):.1f} büyük ; "
      f"kiriş teorisi kesin değeri %{100 * (1 - vk / vk_kesin):.1f} eksik tahmin eder")
xn, yn = Lb / 2, -cb / 2                         # açıklığın dörtte biri, alt yarı
k2 = 3 * qn / (4 * cb**3)                        # q/(2I)
s_xx = -k2 * (Lb**2 - xn**2) * yn + k2 * (2 * cb**2 * yn / 5 - 2 * yn**3 / 3)
s_yy = -k2 * (2 * cb**3 / 3 + cb**2 * yn - yn**3 / 3)
s_xy = k2 * xn * (cb**2 - yn**2)
w, vv = np.linalg.eigh(np.array([[s_xx, s_xy], [s_xy, s_yy]]))
aci = (np.degrees(np.arctan2(vv[1, 1], vv[0, 1])) + 90) % 180 - 90   # doğrultu: -90..90 derece
print(f"(L/2, -c/2): sxx = {s_xx:.4f}, syy = {s_yy:.4f}, sxy = {s_xy:.4f} MPa")
print(f"asal: s1 = {w[1]:.4f}, s2 = {w[0]:.4f} MPa ; s1 doğrultusu x ekseninden {aci:.1f} derece")

print("\nkiriş teorisine göre fark (%), nu = 0,3:   l/h   konsol çökme(B)   basit çökme   basit sxx")
for lh in (2, 5, 10):
    ck, cb_ = 1 / (2 * lh), 1 / lh                 # konsol: c/L = h/(2l) ; basit (açıklık 2L): c/L = h/l
    print(f"{lh:42d}   {100 * 3 * 1.3 * ck**2:12.2f}   {100 * (48 + 9) / 25 * cb_**2:11.2f}   {100 * 4 / 15 * cb_**2:8.2f}")

# %% 5. Sinüs yüklü basit kiriş: F = sin(lambda x) f(y)
print("\n=== 5. Sinüs yükü: orta kesitte üst lif, kesin / kiriş teorisi ===")
lam, q0 = sp.symbols("lambda q_0", positive=True)
A_, B_, C_, D_ = sp.symbols("A B C D")
f = (A_ + B_ * lam * y) * sp.cosh(lam * y) + (C_ + D_ * lam * y) * sp.sinh(lam * y)
F = sp.sin(lam * x) * f
assert sp.simplify(sp.diff(F, x, 4) + 2 * sp.diff(F, x, 2, y, 2) + sp.diff(F, y, 4)) == 0
sxx, syy, sxy = gerilmeler(F)
den = [sp.simplify(syy.subs(y, c) / sp.sin(lam * x)) + q0, sp.simplify(syy.subs(y, -c) / sp.sin(lam * x)),
       sp.simplify(sxy.subs(y, c) / sp.cos(lam * x)), sp.simplify(sxy.subs(y, -c) / sp.cos(lam * x))]
kat = sp.solve(den, [A_, B_, C_, D_], dict=True)[0]
ust = sxx.subs(kat).subs(x, sp.pi / (2 * lam)).subs(y, c)
oran = sp.simplify(ust / (-(q0 / lam**2) * c / I))          # kiriş teorisi: M = q0/lambda^2, sigma = -M c / I
t = sp.Symbol("t", positive=True)                            # t = lambda c
kapali = sp.Rational(2, 3) * t**2 * (4 * t**2 + sp.sinh(2 * t)**2) / (sp.sinh(2 * t)**2 - 4 * t**2)
oran_t = oran.subs(lam, t / c)
for tt in (0.3, 1.1, 2.0):
    assert abs(float(oran_t.subs(t, tt)) - float(kapali.subs(t, tt))) < 1e-10
print("kapalı biçim: oran = (2t^2/3)(4t^2 + sinh^2 2t)/(sinh^2 2t - 4t^2), t = lambda c  -> doğrulandı")
for lh in (1, 2, 4, 8):
    tt = math.pi / (2 * lh)                         # açıklık l = pi/lambda, h = 2c  ->  t = pi/(2 l/h)
    print(f"l/h = {lh}:  oran = {float(kapali.subs(t, tt)):.4f}   (yaklaşık 1 + (2/15) t^2 = {1 + 2 / 15 * tt**2:.4f})")

# %% 6. Alıştırma: üst yüzünde düzgün yayılı q taşıyan konsol (serbest uç x=0, ankastre x=L)
print("\n=== 6. Düzgün yayılı yüklü konsol (alıştırma) ===")
kats, F = [], 0
for m in range(6):
    for n in range(6 - m):
        if m + n >= 2:
            s = sp.Symbol(f"b{m}{n}"); kats.append(s); F += s * x**m * y**n
den = sp.Poly(sp.expand(sp.diff(F, x, 4) + 2 * sp.diff(F, x, 2, y, 2) + sp.diff(F, y, 4)), x, y).coeffs()
sxx, syy, sxy = gerilmeler(F)
for ifade in (syy.subs(y, c) + q, sxy.subs(y, c), syy.subs(y, -c), sxy.subs(y, -c)):
    den += sp.Poly(sp.expand(ifade), x).coeffs()
den += [sp.integrate(t, (y, -c, c)) for t in (sxx.subs(x, 0), sxx.subs(x, 0) * y, sxy.subs(x, 0))]
cozum = sp.solve(den, kats, dict=True)[0]
sxx = sp.factor(sxx.subs(cozum))
print("sxx =", sxx)
print("ankastre uçta üst lif: kesin / kiriş teorisi =",
      sp.expand(sp.simplify(sxx.subs({x: L, y: c}) / ((q * L**2 / 2) * c / I))))

# %% 7. Kendi ağırlığıyla yüklü basit kiriş: kütle kuvveti potansiyeli V = rho_g*y (f_y = -rho_g)
print("\n=== 7. Kendi ağırlığı (rho_g = birim hacim ağırlığı), açıklık 2L ===")
gam = sp.Symbol("rho_g", positive=True)
kats, F = [], 0
for m in range(6):
    for n in range(6 - m):
        if m + n >= 2:
            s = sp.Symbol(f"g{m}{n}"); kats.append(s); F += s * x**m * y**n
V = gam * y                                      # düzlemsel gerilmede nabla^4 F = -(1-nu) nabla^2 V = 0
den = sp.Poly(sp.expand(sp.diff(F, x, 4) + 2 * sp.diff(F, x, 2, y, 2) + sp.diff(F, y, 4)), x, y).coeffs()
sxx, syy, sxy = sp.diff(F, y, 2) + V, sp.diff(F, x, 2) + V, -sp.diff(F, x, y)
for ifade in (syy.subs(y, c), sxy.subs(y, c), syy.subs(y, -c), sxy.subs(y, -c)):
    den += sp.Poly(sp.expand(ifade), x).coeffs()
W = 2 * c * gam * L
for X, Vx in ((L, W), (-L, -W)):
    den += [sp.integrate(sxx.subs(x, X), (y, -c, c)), sp.integrate(sxx.subs(x, X) * y, (y, -c, c)),
            sp.integrate(sxy.subs(x, X), (y, -c, c)) - Vx]
cozum = sp.solve(den, kats, dict=True)[0]
sxx, syy, sxy = [sp.factor(t.subs(cozum)) for t in (sxx, syy, sxy)]
print("sxx =", sxx); print("syy =", syy); print("sxy =", sxy)
print("denge:", sp.simplify(sp.diff(sxx, x) + sp.diff(sxy, y)), sp.simplify(sp.diff(sxy, x) + sp.diff(syy, y) - gam))
qe = 2 * c * gam                                 # birim uzunluk başına ağırlık
print("sxx - (üstten yüklü kirişin sxx'i, q = 2c*rho_g) =",
      sp.simplify(sxx - qe * y * (-15 * L**2 + 6 * c**2 + 15 * x**2 - 10 * y**2) / (20 * c**3)))
