"""Ders 16 — Fizik bilgili sinir ağları (PINN).

Basit mesnetli, düzgün yayılı yüklü Euler–Bernoulli kirişi:  EI w'''' = q,  w = w'' = 0 (iki uçta).
Boyutsuz biçim: ξ = x/L, ŵ = w·EI/(qL⁴)  →  ŵ'''' = 1, ŵ(0) = ŵ(1) = 0, ŵ''(0) = ŵ''(1) = 0.
Kesin çözüm: ŵ = (ξ⁴ − 2ξ³ + ξ)/24, orta nokta 5/384.
  1) İleri problem: ağ hiç veri görmeden yalnız denklemden ve sınır koşullarından öğrenir.
     Karşılaştırma: 4 elemanlı Hermite kiriş elemanı (sonlu elemanlar) çözümü.
  2) Ters problem: 7 gürültülü sehim ölçümünden bilinmeyen eğilme rijitliği EI'yi bulmak.
     L = 6 m, q = 10 kN/m, gerçek EI = 20 000 kN·m²; ölçüm gürültüsü en büyük sehimin %1,5'i (sentetik).
     Karşılaştırma: kesin çözümün biçimini bilerek yapılan en küçük kareler uydurması.

Çalıştır:  python d16_pinn_kiris.py
Gerekenler: numpy, matplotlib, torch  (Python 3.12+)
Süre: 2 çekirdekli bir işlemcide birkaç dakika; makineye göre değişir
Çıktılar: terminale sayılar, aynı klasöre üç PNG grafiği
"""
from pathlib import Path

import numpy as np
import matplotlib
matplotlib.use("Agg")  # pencere açmadan dosyaya çiz
import matplotlib.pyplot as plt
import torch
from torch import nn

# --- Grafik stili (kurs genelinde aynı) ---
RENK = ["#2a78d6", "#eb6834", "#1baf7a", "#eda100", "#e87ba4", "#008300", "#6250d6", "#e34948"]
MUREKKEP, IKINCIL, SOLUK = "#0b0b0b", "#52514e", "#898781"
plt.rcParams.update({
    "figure.facecolor": "white", "axes.facecolor": "white", "savefig.facecolor": "white",
    "axes.edgecolor": "#c3c2b7", "axes.labelcolor": IKINCIL, "axes.titlecolor": MUREKKEP,
    "axes.titlesize": 11, "axes.titleweight": "bold", "axes.labelsize": 10,
    "xtick.color": IKINCIL, "ytick.color": IKINCIL, "font.size": 10,
    "axes.grid": True, "grid.color": "#e1e0d9", "grid.linewidth": 0.6,
    "axes.spines.top": False, "axes.spines.right": False,
    "axes.prop_cycle": plt.cycler(color=RENK), "lines.linewidth": 2, "legend.frameon": False,
})
KLASOR = Path(__file__).resolve().parent
rng = np.random.default_rng(42)
torch.manual_seed(42)
torch.set_default_dtype(torch.float64)        # dördüncü türev ve L-BFGS için çift hassasiyet


# %% 1. Ağ, türevler ve kayıp
class PINN(nn.Module):
    """ŵ(ξ) = ξ(1 − ξ)·N(ξ): ŵ(0) = ŵ(1) = 0 her ağırlık için kendiliğinden sağlanır (sert koşul)."""

    def __init__(self, gizli=32, katman=3, ters=False):
        super().__init__()
        k, n = [], 1
        for _ in range(katman):
            k += [nn.Linear(n, gizli), nn.Tanh()]
            n = gizli
        k.append(nn.Linear(n, 1))
        self.N = nn.Sequential(*k)
        self.log_ei = nn.Parameter(torch.zeros(())) if ters else None   # log(EI / EI_ref)

    def forward(self, xi):
        return xi * (1 - xi) * self.N(2 * xi - 1)                    # girdi [−1, 1] aralığına taşınır


def turevler(model, xi):
    """[ŵ, ŵ', ŵ'', ŵ''', ŵ''''] — otomatik türevle, create_graph=True ile iç içe."""
    xi = xi.clone().requires_grad_(True)
    d = [model(xi)]
    for _ in range(4):
        d.append(torch.autograd.grad(d[-1].sum(), xi, create_graph=True)[0])
    return d


N_KOL = 64
XI = torch.cat([torch.linspace(0, 1, N_KOL + 2)[1:-1, None], torch.tensor([[0.0], [1.0]])])   # iç + uç


def fizik_kaybi(model):
    d = turevler(model, XI)
    rijitlik = torch.exp(model.log_ei) if model.log_ei is not None else 1.0
    r = rijitlik * d[4][:-2] - 1.0                  # denklem artığı: (EI/EI_ref)·ŵ'''' − 1
    m = 8 * d[2][-2:]                               # uç momentleri, qL²/8 ölçeğine göre
    return (r**2).mean(), (m**2).mean()


N_ADAM, N_LBFGS = 1500, 300


def egit(model, kayip_fn, n_adam=N_ADAM, n_lbfgs=N_LBFGS):
    """Önce Adam (kaba arama), sonra L-BFGS (ince ayar). Kayıp geçmişini döndürür."""
    gruplar = [{"params": model.N.parameters(), "lr": 1e-3}]
    if model.log_ei is not None:
        gruplar.append({"params": [model.log_ei], "lr": 1e-2})
    opt = torch.optim.Adam(gruplar)
    gecmis, ei_gecmis = [], []
    for _ in range(n_adam):
        kayip = kayip_fn(model)
        opt.zero_grad()
        kayip.backward()
        opt.step()
        gecmis.append(kayip.item())
        if model.log_ei is not None:
            ei_gecmis.append(model.log_ei.item())
    lbfgs = torch.optim.LBFGS(model.parameters(), lr=1.0, max_iter=n_lbfgs, history_size=50,
                              tolerance_grad=1e-12, tolerance_change=1e-14, line_search_fn="strong_wolfe")

    def kapanis():
        lbfgs.zero_grad()
        kayip = kayip_fn(model)
        kayip.backward()
        gecmis.append(kayip.item())
        if model.log_ei is not None:
            ei_gecmis.append(model.log_ei.item())
        return kayip

    lbfgs.step(kapanis)
    return np.array(gecmis), np.array(ei_gecmis)


def kesin(xi):
    return (xi**4 - 2 * xi**3 + xi) / 24


def kesin_egrilik(xi):
    return (xi**2 - xi) / 2                         # ŵ''; boyutsuz moment M̂ = −ŵ''


# %% 2. İleri problem: veri yok, yalnız fizik
model = PINN()
gecmis_ileri, _ = egit(model, lambda m: sum(fizik_kaybi(m)))
xi_ince = torch.linspace(0, 1, 1001)[:, None]
d = turevler(model, xi_ince)
w_p, w2_p, w4_p = (d[k].detach().numpy().ravel() for k in (0, 2, 4))
xi_n = xi_ince.numpy().ravel()
w_k, w2_k = kesin(xi_n), kesin_egrilik(xi_n)
hata_L2 = np.linalg.norm(w_p - w_k) / np.linalg.norm(w_k)
hata_orta = (w_p[500] - 5 / 384) / (5 / 384)
hata_moment = np.abs(w2_p - w2_k).max() / (1 / 8)
artik_ince = np.abs(w4_p - 1)
print("=== 1. İleri problem: ŵ'''' = 1, basit mesnet ===")
print(f"Ağ: 3 gizli katman × 32 nöron (tanh), {sum(p.numel() for p in model.N.parameters())} parametre; "
      f"{N_KOL} iç kolokasyon noktası")
print(f"Eğitim: {N_ADAM} Adam adımı + {len(gecmis_ileri) - N_ADAM} L-BFGS değerlendirmesi")
print(f"Kayıp: Adam sonunda {gecmis_ileri[N_ADAM - 1]:.2e}, L-BFGS sonunda {gecmis_ileri[-1]:.2e}")
print(f"Bağıl L2 hatası (sehim)      : {hata_L2:.2e}")
print(f"Orta nokta: PINN {w_p[500]:.7f}, kesin 5/384 = {5 / 384:.7f}, bağıl hata {hata_orta:.1e}")
print(f"Moment (ŵ'') en büyük hatası  : {hata_moment:.2e} (qL²/8'e göre)")
print(f"Denklem artığı |ŵ'''' − 1| (1001 nokta): ortalama {artik_ince.mean():.1e}, "
      f"en büyük {artik_ince.max():.1e}")

# Sonlu elemanlarla karşılaştırma: 2 düğümlü Hermite kiriş elemanı, tutarlı yük vektörü (EI = q = L = 1)


def kiris_sey(n_el):
    le = 1 / n_el
    k = np.array([[12, 6 * le, -12, 6 * le], [6 * le, 4 * le**2, -6 * le, 2 * le**2],
                  [-12, -6 * le, 12, -6 * le], [6 * le, 2 * le**2, -6 * le, 4 * le**2]]) / le**3
    f = le * np.array([1 / 2, le / 12, 1 / 2, -le / 12])
    n_sd = 2 * (n_el + 1)
    K, F = np.zeros((n_sd, n_sd)), np.zeros(n_sd)
    for e in range(n_el):
        K[2 * e:2 * e + 4, 2 * e:2 * e + 4] += k
        F[2 * e:2 * e + 4] += f
    serbest = [i for i in range(n_sd) if i not in (0, n_sd - 2)]    # w(0) = w(1) = 0
    u = np.zeros(n_sd)
    u[serbest] = np.linalg.solve(K[np.ix_(serbest, serbest)], F[serbest])
    # eleman içinde eğrilik: Hermite şekil fonksiyonlarının ikinci türevi (eleman başına doğrusal)
    s = np.linspace(0, 1, 51)
    B = np.stack([(-6 + 12 * s) / le**2, (-4 + 6 * s) / le, (6 - 12 * s) / le**2, (-2 + 6 * s) / le], axis=1)
    egrilik = np.concatenate([B @ u[2 * e:2 * e + 4] for e in range(n_el)])
    xi_e = np.concatenate([(e + s) * le for e in range(n_el)])
    uc = k @ u[n_el - 2:n_el + 2] - f          # orta düğümün solundaki elemanın uç kuvvetleri [V, M, V, M]
    return u[0::2], egrilik, xi_e, abs(uc[3])


for n_el in (4, 8):
    w_dugum, egr, xi_e, m_uc = kiris_sey(n_el)
    print(f"SEY, {n_el} eleman ({2 * (n_el + 1)} serbestlik): orta nokta sehim hatası "
          f"{abs(w_dugum[n_el // 2] - 5 / 384) / (5 / 384):.1e}")
    print(f"   moment hatası: şekil fonksiyonu eğriliğinden (en büyük) "
          f"{np.abs(egr - kesin_egrilik(xi_e)).max() / (1 / 8):.2e}, eleman uç kuvvetinden (orta) "
          f"{abs(m_uc - 1 / 8) / (1 / 8):.1e}")
assert hata_L2 < 1e-3 and abs(hata_orta) < 1e-3

# %% 3. Ters problem: 7 ölçümden EI
L_KIRIS, Q, EI_GERCEK, EI_REF = 6.0, 10.0, 20_000.0, 10_000.0      # m, kN/m, kN·m², başlangıç tahmini
x_olc = 0.75 * np.arange(1, 8)                                    # 0,75 … 5,25 m
w_gercek = Q * x_olc * (L_KIRIS**3 - 2 * L_KIRIS * x_olc**2 + x_olc**3) / (24 * EI_GERCEK)
w_maks = 5 * Q * L_KIRIS**4 / (384 * EI_GERCEK)
s_olc = 0.015 * w_maks                                            # ölçüm gürültüsü (std)
w_olc = w_gercek + rng.normal(0, s_olc, x_olc.size)

# Referans: biçimi bilinen tek parametreli en küçük kareler, w(x) = φ(x)/EI
phi = Q * x_olc * (L_KIRIS**3 - 2 * L_KIRIS * x_olc**2 + x_olc**3) / 24
EI_ekk = (phi @ phi) / (phi @ w_olc)
tekrar = w_gercek + rng.normal(0, s_olc, (2000, x_olc.size))       # aynı deneyi 2000 kez tekrarlasak
EI_tekrar = (phi @ phi) / (tekrar @ phi)

OLCEK = Q * L_KIRIS**4 / EI_REF                                    # w = OLCEK · ŵ
xi_olc = torch.tensor(x_olc / L_KIRIS)[:, None]
d_olc = torch.tensor(w_olc / OLCEK)[:, None]


def ters_kayip(model):
    r2, m2 = fizik_kaybi(model)
    v2 = (((model(xi_olc) - d_olc) / d_olc.abs().max())**2).mean()   # ölçümlerin büyüklüğüne göre
    return v2 + r2 + m2


model_t = PINN(ters=True)
gecmis_ters, ei_gecmis = egit(model_t, ters_kayip)
EI_pinn = EI_REF * np.exp(model_t.log_ei.item())
with torch.no_grad():
    w_pinn_olc = model_t(xi_olc).numpy().ravel() * OLCEK
print("\n=== 2. Ters problem: 7 sehim ölçümünden EI ===")
print(f"L = {L_KIRIS} m, q = {Q} kN/m, gerçek EI = {EI_GERCEK:.0f} kN·m²; en büyük sehim {w_maks * 1000:.3f} mm, "
      f"gürültü std {s_olc * 1000:.3f} mm")
print(f"Başlangıç tahmini EI = {EI_REF:.0f} kN·m²")
print(f"PINN            : EI = {EI_pinn:.0f} kN·m² (hata {(EI_pinn / EI_GERCEK - 1) * 100:+.2f}%), "
      f"ölçümlere RMS uyum {np.sqrt(np.mean((w_pinn_olc - w_olc)**2)) * 1000:.3f} mm")
print(f"En küçük kareler: EI = {EI_ekk:.0f} kN·m² (hata {(EI_ekk / EI_GERCEK - 1) * 100:+.2f}%)")
print(f"Gürültünün etkisi (2000 tekrar, EKK): EI'nin standart sapması {EI_tekrar.std():.0f} kN·m² "
      f"(%{EI_tekrar.std() / EI_GERCEK * 100:.2f})")
print(f"PINN ile EKK arasındaki fark: %{abs(EI_pinn / EI_ekk - 1) * 100:.2f}")
assert abs(EI_pinn / EI_GERCEK - 1) < 0.05 and np.isfinite(gecmis_ters).all()

# %% 4. Grafikler
fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
xi_s = np.linspace(0, 1, 15)
ax[0].plot(xi_n, w_p * 1e3, color=RENK[0], label="PINN")
ax[0].plot(xi_n, w_k * 1e3, color=MUREKKEP, ls="--", lw=1.4, label="Kesin çözüm")
ax[0].plot(XI[:-2].numpy().ravel(), np.zeros(N_KOL), "|", color=SOLUK, ms=8, label="Kolokasyon noktaları")
ax[0].invert_yaxis()
ax[0].set(xlabel="ξ = x/L", ylabel="Boyutsuz sehim ŵ (×10⁻³)", title="Sehim (aşağı yönlü)")
ax[0].legend(loc="center")
ax[1].plot(xi_n, -w2_p, color=RENK[0], label="PINN")
ax[1].plot(xi_n, -w2_k, color=MUREKKEP, ls="--", lw=1.4, label="Kesin: ξ(1−ξ)/2")
ax[1].set(xlabel="ξ = x/L", ylabel="Boyutsuz moment M̂ = −ŵ''", title="Eğilme momenti")
ax[1].legend(loc="lower center")
fig.savefig(KLASOR / "d16_pinn_kiris_1.png", dpi=160)
plt.close(fig)

fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
ax[0].semilogy(np.arange(1, len(gecmis_ileri) + 1), gecmis_ileri, color=RENK[0], lw=1.2)
ax[0].axvline(N_ADAM, color=MUREKKEP, ls=":", lw=1.2)
ax[0].text(N_ADAM * 0.5, gecmis_ileri.max() * 0.3, "Adam", ha="center", color=IKINCIL)
ax[0].text(N_ADAM + (len(gecmis_ileri) - N_ADAM) * 0.5, gecmis_ileri.max() * 0.3, "L-BFGS",
           ha="center", color=IKINCIL)
ax[0].set(xlabel="Adam adımı / L-BFGS değerlendirmesi", ylabel="Toplam kayıp",
          title="Kayıp geçmişi (ileri problem)")
ax[1].semilogy(xi_n, artik_ince, color=RENK[0], lw=1.2, label="|ŵ'''' − 1|, 1001 nokta")
ax[1].plot(XI[:-2].numpy().ravel(), np.full(N_KOL, artik_ince.min()), "|", color=SOLUK, ms=8,
           label="Kolokasyon noktaları")
ax[1].set(xlabel="ξ = x/L", ylabel="Denklem artığı", title="Denklem artığı: en büyük değer uçlarda")
ax[1].legend(loc="upper center")
fig.savefig(KLASOR / "d16_pinn_kiris_2.png", dpi=160)
plt.close(fig)

fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
x_ince = xi_n * L_KIRIS
with torch.no_grad():
    w_pinn_ince = model_t(xi_ince).numpy().ravel() * OLCEK
ax[0].plot(x_ince, Q * x_ince * (L_KIRIS**3 - 2 * L_KIRIS * x_ince**2 + x_ince**3) / (24 * EI_GERCEK) * 1000,
           color=MUREKKEP, ls="--", lw=1.4, label=f"Gerçek (EI = {EI_GERCEK:.0f} kN·m²)")
ax[0].plot(x_ince, w_pinn_ince * 1000, color=RENK[0], label=f"PINN (EI = {EI_pinn:.0f} kN·m²)")
ax[0].errorbar(x_olc, w_olc * 1000, yerr=s_olc * 1000, fmt="o", color=SOLUK, ms=5, capsize=3,
               label="Ölçüm ± 1 std (sentetik)")
ax[0].invert_yaxis()
ax[0].set(xlabel="x (m)", ylabel="Sehim w (mm)", title="7 sensörden ters problem")
ax[0].legend(loc="center", fontsize=9)
ax[1].plot(np.arange(1, len(ei_gecmis) + 1), EI_REF * np.exp(ei_gecmis), color=RENK[0], label="PINN tahmini")
ax[1].axhline(EI_GERCEK, color=MUREKKEP, ls="--", lw=1.2, label="Gerçek EI")
ax[1].axhline(EI_ekk, color=RENK[1], ls=":", lw=1.6, label="En küçük kareler")
ax[1].axvline(N_ADAM, color=SOLUK, ls=":", lw=1)
ax[1].set(xlabel="Adam adımı / L-BFGS değerlendirmesi", ylabel="EI (kN·m²)", title="EI tahmininin yakınsaması")
ax[1].legend(loc="lower right")
fig.savefig(KLASOR / "d16_pinn_kiris_3.png", dpi=160)
plt.close(fig)
print("\nGrafikler kaydedildi: d16_pinn_kiris_1.png, _2.png, _3.png")
