"""Proje 5 — Kompozit laminat için vekil model ve ters tasarım.

Simetrik, 8 tabakalı [θ1/θ2/θ3/θ4]s karbon/epoksi laminatın düzlem içi mühendislik sabitlerini
(Ex, Ey, Gxy, νxy) klasik laminasyon teorisiyle (KLT) hesaplıyor, bu hesaptan üretilen veriyle
bir sinir ağı vekil modeli eğitiyor ve hedef rijitliği veren tabaka açılarını vekil üzerinden
gradyanla arıyoruz. Veri sentetiktir: rastgele açılı laminatların KLT çözümleri. Tabaka özellikleri
ders kitaplarında sık kullanılan T300/5208 değerleridir; bir üreticinin tasarım değeri değildir.

Çalıştır:  python p5_kompozit_laminat.py
Gerekenler: numpy, matplotlib, torch  (Python 3.12+, yalnız CPU yeter)
Süre:      sıradan bir dizüstü bilgisayarda 1–3 dakika
Çıktılar:  terminale sayılar, aynı klasöre üç PNG grafiği
"""
import itertools
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

# %% 1. Tabaka rijitliği ve klasik laminasyon teorisi (KLT)
E1, E2, G12, NU12 = 181.0, 10.3, 7.17, 0.28   # GPa; T300/5208 (ders kitabı değerleri)
T_KAT, N_KAT = 0.125, 8                       # tabaka kalınlığı (mm), tabaka sayısı
H = N_KAT * T_KAT                             # laminat kalınlığı: 1 mm

nu21 = NU12 * E2 / E1
payda = 1 - NU12 * nu21
Q11, Q22, Q12, Q66 = E1 / payda, E2 / payda, NU12 * E2 / payda, G12   # indirgenmiş rijitlik
Q = np.array([[Q11, Q12, 0], [Q12, Q22, 0], [0, 0, Q66]])
# Tsai–Pagano değişmezleri: Q̄(θ), cos 2θ, cos 4θ, sin 2θ, sin 4θ'nın doğrusal birleşimidir
U1 = (3 * Q11 + 3 * Q22 + 2 * Q12 + 4 * Q66) / 8
U2 = (Q11 - Q22) / 2
U3 = (Q11 + Q22 - 2 * Q12 - 4 * Q66) / 8
U4 = (Q11 + Q22 + 6 * Q12 - 4 * Q66) / 8
U5 = (Q11 + Q22 - 2 * Q12 + 4 * Q66) / 8


def Qbar_T(teta):
    """Ders kitabı yolu: Q̄ = T⁻¹ Q T⁻ᵀ (T: gerilme dönüşüm matrisi, teta radyan)."""
    c, s = np.cos(teta), np.sin(teta)
    T = np.array([[c * c, s * s, 2 * s * c], [s * s, c * c, -2 * s * c], [-s * c, s * c, c * c - s * s]])
    Ti = np.linalg.inv(T)
    return Ti @ Q @ Ti.T


def Qbar_acik(teta):
    """Açık trigonometrik formüller; teta dizisi → (..., 3, 3)."""
    c, s = np.cos(teta), np.sin(teta)
    q11 = Q11 * c**4 + 2 * (Q12 + 2 * Q66) * s**2 * c**2 + Q22 * s**4
    q22 = Q11 * s**4 + 2 * (Q12 + 2 * Q66) * s**2 * c**2 + Q22 * c**4
    q12 = (Q11 + Q22 - 4 * Q66) * s**2 * c**2 + Q12 * (s**4 + c**4)
    q66 = (Q11 + Q22 - 2 * Q12 - 2 * Q66) * s**2 * c**2 + Q66 * (s**4 + c**4)
    q16 = (Q11 - Q12 - 2 * Q66) * s * c**3 + (Q12 - Q22 + 2 * Q66) * s**3 * c
    q26 = (Q11 - Q12 - 2 * Q66) * s**3 * c + (Q12 - Q22 + 2 * Q66) * s * c**3
    return np.stack([np.stack([q11, q12, q16], -1), np.stack([q12, q22, q26], -1),
                     np.stack([q16, q26, q66], -1)], -2)


def A_matrisi(acilar):
    """[θ1/θ2/θ3/θ4]s için A = Σ Q̄_k t_k (8 tabaka; simetrik olduğu için B = 0). acilar: (n, 4) derece."""
    return 2 * T_KAT * Qbar_acik(np.radians(acilar)).sum(axis=-3)


def lam_param(acilar):
    """Laminasyon parametreleri ξ1..ξ4 = (1/h) Σ t_k [cos 2θ, sin 2θ, cos 4θ, sin 4θ]."""
    t = np.radians(acilar)
    return np.stack([np.cos(2 * t).mean(-1), np.sin(2 * t).mean(-1),
                     np.cos(4 * t).mean(-1), np.sin(4 * t).mean(-1)], -1)


def A_xi(xi):
    """Aynı A, ξ'nin doğrusal fonksiyonu olarak (Tsai–Pagano)."""
    x1, x2, x3, x4 = np.moveaxis(xi, -1, 0)
    A11, A22 = H * (U1 + U2 * x1 + U3 * x3), H * (U1 - U2 * x1 + U3 * x3)
    A12, A66 = H * (U4 - U3 * x3), H * (U5 - U3 * x3)
    A16, A26 = H * (U2 / 2 * x2 + U3 * x4), H * (U2 / 2 * x2 - U3 * x4)
    return np.stack([np.stack([A11, A12, A16], -1), np.stack([A12, A22, A26], -1),
                     np.stack([A16, A26, A66], -1)], -2)


def sabitler(acilar):
    """Düzlem içi mühendislik sabitleri, a = A⁻¹ ile:
    Ex = 1/(h a11), Ey = 1/(h a22), Gxy = 1/(h a66), νxy = −a12/a11."""
    a = np.linalg.inv(A_matrisi(np.atleast_2d(acilar)))
    return np.stack([1 / (H * a[:, 0, 0]), 1 / (H * a[:, 1, 1]), 1 / (H * a[:, 2, 2]),
                     -a[:, 0, 1] / a[:, 0, 0]], -1)


def dizilim(acilar, basamak=0):
    return "[" + "/".join(f"{a:.{basamak}f}" for a in acilar) + "]s"


print("=== 1. Tabaka ve laminat (KLT) ===")
print(f"T300/5208: Q11 = {Q11:.2f}, Q22 = {Q22:.2f}, Q12 = {Q12:.2f}, Q66 = {Q66:.2f} GPa")
print(f"Değişmezler: U1 = {U1:.2f}, U2 = {U2:.2f}, U3 = {U3:.2f}, U4 = {U4:.2f}, U5 = {U5:.2f} GPa")
tetalar = np.radians(np.arange(-90, 91, 7.5))
fark = max(np.abs(Qbar_T(t) - Qbar_acik(t)).max() for t in tetalar)
print(f"Q̄: T⁻¹QT⁻ᵀ ile açık formül arasındaki en büyük fark = {fark:.1e} GPa")
for ad, dz in [("[0]8", [0, 0, 0, 0]), ("[0/±45/90]s", [0, 45, -45, 90])]:
    Ex, Ey, Gxy, nu = sabitler(np.array(dz, float))[0]
    print(f"{ad:12s}: Ex = {Ex:6.2f}, Ey = {Ey:6.2f}, Gxy = {Gxy:5.2f} GPa, νxy = {nu:.3f}")
A_qi = A_matrisi(np.array([[0.0, 45, -45, 90]]))[0]
E_qi = (U1**2 - U4**2) / U1          # yarı-izotrop laminatın bilinen modülü
print(f"Yarı-izotrop kontrol: A11 − A22 = {A_qi[0, 0] - A_qi[1, 1]:.1e}, "
      f"A66 − (A11 − A12)/2 = {A_qi[2, 2] - (A_qi[0, 0] - A_qi[0, 1]) / 2:.1e} GPa·mm, "
      f"(U1² − U4²)/U1 = {E_qi:.2f} GPa")
assert fark < 1e-9
assert np.allclose(sabitler(np.zeros(4))[0], [E1, E2, G12, NU12])
assert np.isclose(sabitler(np.array([0.0, 45, -45, 90]))[0, 0], E_qi)

# %% 2. Laminasyon parametreleri: A, ξ'de doğrusal; açılarda değil
rng = np.random.default_rng(42)
aci_havuz = rng.uniform(-90, 90, (2048, 4))      # eğitim havuzu: düzgün dağılımlı rastgele açılar
aci_test = rng.uniform(-90, 90, (4000, 4))       # test laminatları
Y_havuz, Y_test = sabitler(aci_havuz), sabitler(aci_test)
A_havuz, A_test = A_matrisi(aci_havuz), A_matrisi(aci_test)
assert np.abs(A_xi(lam_param(aci_test)) - A_test).max() < 1e-9   # iki yol aynı A'yı veriyor


def dogrusal_r2(Xe, ye, Xt, yt):
    """En küçük kareler (sabit terimli); test R² ve katsayılar."""
    w, *_ = np.linalg.lstsq(np.column_stack([np.ones(len(Xe)), Xe]), ye, rcond=None)
    tahmin = np.column_stack([np.ones(len(Xt)), Xt]) @ w
    return 1 - np.sum((yt - tahmin)**2) / np.sum((yt - yt.mean())**2), w, tahmin


print("\n=== 2. Laminasyon parametreleri: A, ξ'nin doğrusal fonksiyonu ===")
bilesen = {"A11": (0, 0), "A12": (0, 1), "A66": (2, 2), "A16": (0, 2)}
satir_ham, satir_xi = [], []
for ad, (i, j) in bilesen.items():
    r2_ham, _, _ = dogrusal_r2(aci_havuz, A_havuz[:, i, j], aci_test, A_test[:, i, j])
    r2_xi, w, _ = dogrusal_r2(lam_param(aci_havuz), A_havuz[:, i, j], lam_param(aci_test), A_test[:, i, j])
    satir_ham.append(f"{ad} {r2_ham:.3f}")
    satir_xi.append(f"{ad} {r2_xi:.6f}")
    if ad == "A11":
        w_A11 = w / H
r2_A11_ham, _, A11_ham_tahmin = dogrusal_r2(aci_havuz, A_havuz[:, 0, 0], aci_test, A_test[:, 0, 0])
r2_A11_xi, _, A11_xi_tahmin = dogrusal_r2(lam_param(aci_havuz), A_havuz[:, 0, 0],
                                          lam_param(aci_test), A_test[:, 0, 0])
print("Doğrusal regresyon test R² — ham açılarla: " + ", ".join(satir_ham))
print("Doğrusal regresyon test R² — ξ ile      : " + ", ".join(satir_xi))
print("A11/h katsayıları [sabit, ξ1, ξ2, ξ3, ξ4] = [" + ", ".join(f"{v:.2f}" for v in w_A11)
      + f"]  (U1, U2, U3 = {U1:.2f}, {U2:.2f}, {U3:.2f})")
r2_Ex_xi, _, _ = dogrusal_r2(lam_param(aci_havuz), Y_havuz[:, 0], lam_param(aci_test), Y_test[:, 0])
print(f"Ex için doğrusal regresyon (ξ ile) test R² = {r2_Ex_xi:.3f}  (Ex, A⁻¹ üzerinden doğrusal değil)")
assert np.allclose(w_A11, [U1, U2, 0, U3, 0], atol=1e-8)


# %% 3. Vekil model: aynı ağ, üç girdi gösterimi
def gosterim(acilar, tur):
    t = np.radians(acilar)
    if tur == "ham":                       # açılar doğrudan (θ/90 ∈ [−1, 1))
        return acilar / 90.0
    if tur == "trig":                      # tabaka başına [cos 2θk, sin 2θk, cos 4θk, sin 4θk]: 16 özellik
        return np.concatenate([np.cos(2 * t), np.sin(2 * t), np.cos(4 * t), np.sin(4 * t)], axis=-1)
    return lam_param(acilar)               # "xi": 4 laminasyon parametresi


class Vekil:
    """Standartlaştırma + 2 gizli katmanlı (64 nöron, tanh) MLP; çıktı [Ex, Ey, Gxy, νxy]."""

    def __init__(self, X, Y):
        self.xm, self.xs = X.mean(0), X.std(0)
        self.ym, self.ys = Y.mean(0), Y.std(0)
        torch.manual_seed(42)
        self.ag = nn.Sequential(nn.Linear(X.shape[1], 64), nn.Tanh(), nn.Linear(64, 64), nn.Tanh(),
                                nn.Linear(64, 4))
        self.t = {k: torch.tensor(v, dtype=torch.float32)
                  for k, v in dict(xm=self.xm, xs=self.xs, ym=self.ym, ys=self.ys).items()}

    def egit(self, X, Y, adim, ogrenme_hizi=3e-3, yigin=256):
        Xt = torch.tensor((X - self.xm) / self.xs, dtype=torch.float32)
        Yt = torch.tensor((Y - self.ym) / self.ys, dtype=torch.float32)
        opt = torch.optim.Adam(self.ag.parameters(), lr=ogrenme_hizi)
        plan = torch.optim.lr_scheduler.CosineAnnealingLR(opt, adim, eta_min=ogrenme_hizi / 100)
        uretec = torch.Generator().manual_seed(42)
        for _ in range(adim):
            idx = torch.randint(0, len(Xt), (min(yigin, len(Xt)),), generator=uretec)
            opt.zero_grad()
            kayip = ((self.ag(Xt[idx]) - Yt[idx])**2).mean()   # standartlaştırılmış MSE
            kayip.backward()
            opt.step()
            plan.step()
        return self

    def __call__(self, X_t):              # torch girdisi → fiziksel birimde çıktı (türevlenebilir)
        return self.ag((X_t - self.t["xm"]) / self.t["xs"]) * self.t["ys"] + self.t["ym"]

    def tahmin(self, X):
        with torch.no_grad():
            return self(torch.tensor(X, dtype=torch.float32)).numpy().astype(float)


def nrmse(P, Y):
    """Normalize RMSE: her çıktı için RMSE / test standart sapması, dört çıktının ortalaması."""
    return float(np.mean(np.sqrt(np.mean((P - Y)**2, 0)) / Y.std(0)))


print("\n=== 3. Vekil model: öğrenme eğrisi (test: 4000 laminat, normalize RMSE) ===")
BOYUTLAR = [64, 128, 256, 512, 1024, 2048]
TURLER = {"ham": "ham açı", "trig": "cos/sin (16)", "xi": "ξ (4)"}
egri = {tur: [] for tur in TURLER}
parite, egitim_hatasi = {}, {}
for N in BOYUTLAR:
    for tur in TURLER:
        X = gosterim(aci_havuz[:N], tur)
        model = Vekil(X, Y_havuz[:N]).egit(X, Y_havuz[:N], adim=1000)
        P = model.tahmin(gosterim(aci_test, tur))
        egri[tur].append(nrmse(P, Y_test))
        if N == 256:
            parite[tur] = P[:, 0]
        if N == BOYUTLAR[-1]:                       # az uyum mu, aşırı uyum mu? eğitim hatasına bak
            egitim_hatasi[tur] = nrmse(model.tahmin(X), Y_havuz[:N])
print("    N   " + "  ".join(f"{ad:>12s}" for ad in TURLER.values()))
for k, N in enumerate(BOYUTLAR):
    print(f"{N:5d}   " + "  ".join(f"{egri[tur][k]:12.3f}" for tur in TURLER))
print("eğitim  " + "  ".join(f"{egitim_hatasi[tur]:12.3f}" for tur in TURLER)
      + "   (N = 2048, eğitim verisinde)")

# Ters tasarımda kullanılacak vekil: ξ girdili, 2048 örnek, daha uzun eğitim
X_xi = lam_param(aci_havuz)
vekil = Vekil(X_xi, Y_havuz).egit(X_xi, Y_havuz, adim=5000, yigin=512)
P = vekil.tahmin(lam_param(aci_test))
goreli = np.abs(P[:, :3] / Y_test[:, :3] - 1).mean(0) * 100
nu_rmse = np.sqrt(np.mean((P[:, 3] - Y_test[:, 3])**2))
print(f"Son vekil (ξ, N = 2048, 5000 adım): göreli hata Ex {goreli[0]:.2f} %, Ey {goreli[1]:.2f} %, "
      f"Gxy {goreli[2]:.2f} %; νxy RMSE {nu_rmse:.4f}")
assert all(np.isfinite(v).all() for v in egri.values())
assert egri["xi"][-1] < egri["trig"][-1] < egri["ham"][-1]


# %% 4. Ters tasarım: açıları vekil üzerinden gradyanla aramak
def lam_param_t(aci):
    """lam_param'ın PyTorch karşılığı (açıya göre türevlenebilir)."""
    t = torch.deg2rad(aci)
    return torch.stack([torch.cos(2 * t).mean(-1), torch.sin(2 * t).mean(-1),
                        torch.cos(4 * t).mean(-1), torch.sin(4 * t).mean(-1)], -1)


def ters_tasarim(vekil, amac, n_baslangic=64, adim=800, tohum=7):
    """Çok başlangıçlı gradyan inişi: her satır ayrı bir laminat; kayıplar toplanınca gradyanlar ayrışır."""
    vekil.ag.requires_grad_(False)                             # ağırlıklar sabit: yalnız açılar güncellenir
    aci = torch.tensor(np.random.default_rng(tohum).uniform(-90, 90, (n_baslangic, 4)),
                       dtype=torch.float32, requires_grad=True)
    opt = torch.optim.Adam([aci], lr=2.0)                      # adım ≈ 2°, sonra küçülür
    plan = torch.optim.lr_scheduler.CosineAnnealingLR(opt, adim, eta_min=0.01)
    for _ in range(adim):
        opt.zero_grad()
        xi = lam_param_t(aci)
        kayip = amac(vekil(xi), xi)
        kayip.sum().backward()
        opt.step()
        plan.step()
    with torch.no_grad():
        xi = lam_param_t(aci)
        kayip = amac(vekil(xi), xi).numpy()
    vekil.ag.requires_grad_(True)
    aci = aci.detach().numpy().astype(float)
    return (aci + 90) % 180 - 90, kayip                      # açıyı [−90°, 90°) aralığına sar


def dengesizlik(xi):
    """Dengeli laminat (A16 = A26 = 0) ⇔ ξ2 = ξ4 = 0: fizikten bilinen kısıt, öğrenilmiyor."""
    return xi[:, 1]**2 + xi[:, 3]**2


HEDEF = np.array([70.0, 40.0])     # Ex, Ey (GPa)


def amac_hedef(P, xi):
    return (P[:, 0] / HEDEF[0] - 1)**2 + (P[:, 1] / HEDEF[1] - 1)**2 + dengesizlik(xi)


print("\n=== 4. Ters tasarım 1: Ex = 70, Ey = 40 GPa, dengeli laminat ===")
aci1, kayip1 = ters_tasarim(vekil, amac_hedef)
yakinsadi = kayip1 < 1e-4
kume = {tuple(np.sort(np.round(a).astype(int))) for a in aci1[yakinsadi]}      # sırasız açı kümesi
sirali = {tuple(np.round(a).astype(int)) for a in aci1[yakinsadi]}             # dizilim sırası önemli
klt1 = sabitler(aci1[yakinsadi])
hata1 = np.abs(klt1[:, :2] / HEDEF - 1).max(1) * 100
A1 = A_matrisi(aci1[yakinsadi])
kalan = (f"; kalanlar {kayip1[~yakinsadi].min():.1e}–{kayip1[~yakinsadi].max():.1e}"
         if (~yakinsadi).any() else "")
kume_yazi = " | ".join("{" + ", ".join(map(str, k)) + "}" for k in sorted(kume))
print(f"{yakinsadi.sum()}/64 yakınsadı (kayıp < 1e-4{kalan}); açı kümesi: {len(kume)} → "
      f"{kume_yazi}; dizilim: {len(sirali)}")
i = int(np.argmin(kayip1))
p1, k1 = vekil.tahmin(lam_param(aci1[i:i + 1]))[0], sabitler(aci1[i])[0]
d1 = np.linalg.norm(X_xi - lam_param(aci1[i]), axis=1).min()       # ξ uzayında en yakın eğitim örneği
print(f"Örnek çözüm {dizilim(aci1[i], 1)}: vekil Ex = {p1[0]:.2f}, Ey = {p1[1]:.2f} GPa; "
      f"en yakın eğitim örneği {d1:.3f} (ξ)")
print(f"   KLT doğrulaması: Ex = {k1[0]:.2f}, Ey = {k1[1]:.2f}, Gxy = {k1[2]:.2f} GPa, νxy = {k1[3]:.3f}")
k1y = sabitler(np.round(aci1[i]))[0]                               # üretimde açı tam dereceye yuvarlanır
print(f"   Açılar tam dereceye yuvarlanınca {dizilim(np.round(aci1[i]))}: "
      f"KLT Ex = {k1y[0]:.2f}, Ey = {k1y[1]:.2f} GPa")
print(f"Tüm çözümler (KLT): hata ≤ {hata1.max():.2f} %; "
      f"Gxy {klt1[:, 2].min():.2f}–{klt1[:, 2].max():.2f} GPa; "
      f"νxy {klt1[:, 3].min():.3f}–{klt1[:, 3].max():.3f}; |A16| ≤ {np.abs(A1[:, 0, 2]).max():.3f} GPa·mm")

# Kapsamlı arama: üretim dostu açılar {0, ±45, 90}, 4^4 = 256 dizilim, kesin KLT
ayrik = np.array(list(itertools.product([0, 45, -45, 90], repeat=4)), float)
klt_ayrik = sabitler(ayrik)
dengeli = np.abs(lam_param(ayrik)[:, [1, 3]]).max(1) < 1e-12
hata_ayrik = np.abs(klt_ayrik[:, :2] / HEDEF - 1).max(1) * 100
n_A = len(np.unique(np.round(A_matrisi(ayrik).reshape(len(ayrik), -1), 6), axis=0))   # sıra önemsiz
n_farkli = len(np.unique(np.round(klt_ayrik, 6), axis=0))      # +45 ↔ −45: yalnız A16, A26 işaret değiştirir
print(f"Ayrık arama: 256 dizilim → {n_A} farklı A, {n_farkli} farklı (Ex, Ey, Gxy, νxy); "
      f"{dengeli.sum()} dengeli dizilim")
for ad, maske in [("dengeli", dengeli), ("dengesiz serbest", np.ones_like(dengeli))]:
    j = np.where(maske)[0][np.argmin(hata_ayrik[maske])]
    print(f"   en iyi ({ad}): {dizilim(ayrik[j])} → Ex = {klt_ayrik[j, 0]:.2f}, "
          f"Ey = {klt_ayrik[j, 1]:.2f} GPa, hata {hata_ayrik[j]:.1f} %")
assert hata1.max() < 3

# %% 5. Ters tasarım 2: Ex ≥ 50 GPa koşuluyla en büyük Gxy
EX_MIN = 50.0


def amac_kayma(P, xi):
    return -P[:, 2] / 40 + 100 * torch.relu(1 - P[:, 0] / EX_MIN)**2 + dengesizlik(xi)


def en_iyi(aci, kayip):
    i = int(np.argmin(kayip))
    return aci[i], vekil.tahmin(lam_param(aci[i:i + 1]))[0], sabitler(aci[i])[0]


print("\n=== 5. Ters tasarım 2: en büyük Gxy, Ex ≥ 50 GPa, dengeli ===")
aci2, kayip2 = ters_tasarim(vekil, amac_kayma)
a2, p2, k2 = en_iyi(aci2, kayip2)
print(f"Vekil optimumu {dizilim(a2)}: vekil Ex {p2[0]:.2f}, Gxy {p2[2]:.2f} | "
      f"KLT Ex {k2[0]:.2f}, Gxy {k2[2]:.2f} GPa")
d2 = np.linalg.norm(X_xi - lam_param(a2), axis=1).min()
print(f"Eğitim verisi burada seyrek: ξ3 ≤ −0.7 olan {np.sum(X_xi[:, 2] <= -0.7)}/{len(X_xi)} laminat; "
      f"en yakın eğitim örneği {d2:.3f} (ξ)")

# İyileştirme turu: bulunan tasarımların çevresinde KLT ile yeni örnek üret, vekili yeniden eğit
yeni = np.concatenate([aci2] + [aci2 + rng.normal(0, 3, aci2.shape) for _ in range(3)])
X_ek = np.concatenate([X_xi, lam_param(yeni)])
Y_ek = np.concatenate([Y_havuz, sabitler(yeni)])
vekil.egit(X_ek, Y_ek, adim=1500, ogrenme_hizi=1e-3, yigin=512)   # mevcut ağırlıklardan devam
aci3, kayip3 = ters_tasarim(vekil, amac_kayma)
a3, p3, k3 = en_iyi(aci3, kayip3)
print(f"+{len(yeni)} KLT örneğiyle yeniden eğitim → {dizilim(a3)}: vekil Ex {p3[0]:.2f}, Gxy {p3[2]:.2f} | "
      f"KLT Ex {k3[0]:.2f}, Gxy {k3[2]:.2f} GPa")
xi_3, A_3 = lam_param(a3), A_matrisi(a3[None])[0]
print(f"   ξ1 = {xi_3[0]:.3f}, ξ3 = {xi_3[2]:.3f}, A12/A22 = {A_3[0, 1] / A_3[1, 1]:.3f}; "
      f"parabol 2ξ1² − 1 = {2 * xi_3[0]**2 - 1:.3f} → optimum iç noktada")
# Karşılaştırma: ulaşılabilir bölgenin sınırındaki [±θ]2s laminatı (ξ3 = 2ξ1² − 1); Ex, θ ile azalır
alt, ust = 20.0, 45.0
for _ in range(50):                                            # ikiye bölme: Ex(θ) = 50 GPa
    orta = (alt + ust) / 2
    if sabitler(np.array([orta, -orta, orta, -orta]))[0, 0] > EX_MIN:
        alt = orta
    else:
        ust = orta
k_sinir = sabitler(np.array([alt, -alt, alt, -alt]))[0]
print(f"Sınırdaki [±{alt:.1f}]2s laminatı (ξ3 = 2ξ1² − 1): Ex = {k_sinir[0]:.2f}, Gxy = {k_sinir[2]:.2f} GPa")
print(f"KLT ile kısıt payı Ex − 50: önce {k2[0] - EX_MIN:+.3f}, sonra {k3[0] - EX_MIN:+.3f} GPa")
uygun = dengeli & (klt_ayrik[:, 0] >= EX_MIN)
j = np.where(uygun)[0][np.argmax(klt_ayrik[uygun, 2])]
print(f"Ayrık {{0, ±45, 90}} en iyi (dengeli): {dizilim(ayrik[j])} → Ex = {klt_ayrik[j, 0]:.2f}, "
      f"Gxy = {klt_ayrik[j, 2]:.2f} GPa (= U5, çünkü ξ3 = {lam_param(ayrik[j])[2]:.0f})")
assert np.isfinite([p2, k2, p3, k3]).all()

# %% 6. Grafikler
fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
t_deg = np.linspace(-180, 180, 721)
Qb = Qbar_acik(np.radians(t_deg))
ax[0].axvspan(-90, 90, color="#f1f0ea", zorder=0)
for k, (ad, (i, j)) in enumerate([("$\\bar Q_{11}$", (0, 0)), ("$\\bar Q_{22}$", (1, 1)),
                                  ("$\\bar Q_{66}$", (2, 2)), ("$\\bar Q_{16}$", (0, 2))]):
    ax[0].plot(t_deg, Qb[:, i, j], color=RENK[k], label=ad)
ax[0].set(xlabel="Tabaka açısı θ (°)", ylabel="Rijitlik (GPa)", title="Q̄(θ): 180° periyotlu",
          xticks=np.arange(-180, 181, 45), ylim=(-65, 250))
ax[0].text(0, 196, "örnekleme aralığı [−90°, 90°)", ha="center", fontsize=8.5, color=IKINCIL)
ax[0].legend(loc="upper center", ncols=4, fontsize=9.5, handlelength=1.5, columnspacing=1.2)
g = slice(0, 1500)                                   # grafikte ilk 1500 test laminatı yeter
ax[1].scatter(A_test[g, 0, 0], A11_ham_tahmin[g], s=6, color=RENK[1], alpha=.35, linewidths=0,
              label=f"Ham açılarla: R² = {r2_A11_ham:.3f}")
ax[1].scatter(A_test[g, 0, 0], A11_xi_tahmin[g], s=6, color=RENK[0], alpha=.5, linewidths=0,
              label=f"ξ ile: R² = {r2_A11_xi:.6f}")
lim = [A_test[:, 0, 0].min(), A_test[:, 0, 0].max()]
ax[1].plot(lim, lim, color=MUREKKEP, ls="--", lw=1.2, label="Kesin (KLT)")
ax[1].set(xlabel="KLT ile A11 (GPa·mm)", ylabel="Doğrusal regresyon tahmini (GPa·mm)",
          title="A11 için doğrusal model: gösterim farkı")
ax[1].legend(loc="upper left", markerscale=2.5)
fig.savefig(KLASOR / "p5_kompozit_laminat_1.png", dpi=160)
plt.close(fig)

fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
for k, (tur, ad) in enumerate([("ham", "Ham açılar (4)"), ("trig", "Tabaka başına cos/sin (16)"),
                               ("xi", "Laminasyon parametreleri ξ (4)")]):
    ax[0].loglog(BOYUTLAR, egri[tur], "-o", ms=5, color=RENK[[1, 2, 0][k]], label=ad)
ax[0].set(xlabel="Eğitim örneği sayısı N", ylabel="Test normalize RMSE (4 çıktı ort.)",
          title="Öğrenme eğrisi: aynı ağ, farklı gösterim")
ax[0].set_xticks(BOYUTLAR, [str(n) for n in BOYUTLAR])
ax[0].legend(loc="upper right")
ax[1].scatter(Y_test[g, 0], parite["ham"][g], s=5, color=RENK[1], alpha=.35, linewidths=0,
              label="Ham açılar, N = 256")
ax[1].scatter(Y_test[g, 0], parite["xi"][g], s=5, color=RENK[0], alpha=.5, linewidths=0, label="ξ, N = 256")
ax[1].plot([10, 181], [10, 181], color=MUREKKEP, ls="--", lw=1.2, label="Kesin (KLT)")
ax[1].set(xlabel="KLT ile Ex (GPa)", ylabel="Vekil tahmini Ex (GPa)", title="Ex: test laminatları, N = 256")
ax[1].legend(loc="upper left", markerscale=2.5)
fig.savefig(KLASOR / "p5_kompozit_laminat_2.png", dpi=160)
plt.close(fig)

fig, ax = plt.subplots(1, 2, figsize=(10, 5.0), layout="constrained")
ax[0].scatter(Y_test[:2000, 0], Y_test[:2000, 1], s=4, color=SOLUK, alpha=.3, linewidths=0,
              label="Rastgele laminatlar (KLT)")
ax[0].scatter(klt_ayrik[~dengeli, 0], klt_ayrik[~dengeli, 1], s=36, marker="s", facecolors="white",
              edgecolors=RENK[1], label="{0, ±45, 90}, dengesiz")
ax[0].scatter(klt_ayrik[dengeli, 0], klt_ayrik[dengeli, 1], s=36, marker="s", color=RENK[1],
              label="{0, ±45, 90}, dengeli")
ax[0].axvline(HEDEF[0], color=MUREKKEP, ls="--", lw=1)
ax[0].axhline(HEDEF[1], color=MUREKKEP, ls="--", lw=1, label="Hedef: Ex = 70, Ey = 40 GPa")
ax[0].scatter(klt1[:, 0], klt1[:, 1], s=40, color=RENK[0], edgecolors="white", linewidths=1, zorder=5,
              label="Vekil + gradyan (KLT ile)")
ax[0].set(xlabel="Ex (GPa)", ylabel="Ey (GPa)", title="Hedef rijitlik: sürekli ve ayrık açılar")
ax[0].legend(loc="upper center", bbox_to_anchor=(0.5, -0.16), ncols=2, fontsize=8.5)
alfa, beta = rng.uniform(0, 90, (2, 1500))
den_ornek = sabitler(np.column_stack([alfa, -alfa, beta, -beta]))
yakin = ax[1].inset_axes([0.64, 0.56, 0.34, 0.40])               # optimum çevresine yakından bakış
for a in (ax[1], yakin):
    a.scatter(den_ornek[:, 0], den_ornek[:, 2], s=4, color=SOLUK, alpha=.3, linewidths=0,
              label="Dengeli [±α/±β]s (KLT)")
    a.axvline(EX_MIN, color=MUREKKEP, ls=":", lw=1.2, label="Kısıt: Ex = 50 GPa")
    a.scatter(klt_ayrik[dengeli, 0], klt_ayrik[dengeli, 2], s=36, marker="s", color=RENK[1],
              label="{0, ±45, 90}, dengeli")
    a.plot(k2[0], k2[2], marker="^", ms=9, color=RENK[2], ls="none", label="İlk vekil optimumu (KLT)")
    a.plot(k3[0], k3[2], marker="o", ms=8, color=RENK[0], ls="none", label="İyileştirme sonrası (KLT)")
yakin.set(xlim=(46, 54), ylim=(39.5, 42.5))
yakin.tick_params(labelsize=8)
ax[1].set(xlabel="Ex (GPa)", ylabel="Gxy (GPa)", title="Ex ≥ 50 GPa iken en büyük Gxy")
ax[1].legend(loc="upper center", bbox_to_anchor=(0.5, -0.16), ncols=2, fontsize=8.5)
fig.savefig(KLASOR / "p5_kompozit_laminat_3.png", dpi=160)
plt.close(fig)
print("\nGrafikler kaydedildi: p5_kompozit_laminat_1.png, _2.png, _3.png")
