"""Proje 4 — Titreşimden hasar tespiti.

Beş katlı bir kayma binasının ilk beş doğal frekansını izliyoruz. Sıcaklık bütün katların
rijitliğini birlikte değiştirir; hasar ise tek bir katın rijitliğini düşürür. Üç görev var:
  1) Etiketsiz algılama: yalnız sağlam ölçümlerle kurulan Mahalanobis uzaklığı ve sıcaklık
     bileşenini PCA ile atan kalıntı göstergesi (Yan vd. 2005'in fikri).
  2) Konum: benzetimle üretilmiş hasar senaryolarında eğitilen Random Forest sınıflandırıcı.
  3) Şiddet: aynı özelliklerden hasar oranını tahmin eden Random Forest regresyonu.

Veri tamamen sentetiktir: kat kütlesi 300 t, kat rijitliği 585 MN/m (15 °C'de), sıcaklık
−5…35 °C, rijitliğin sıcaklık katsayısı °C başına −%0,15 (varsayım), frekans ölçüm gürültüsü
%0,2. Gerçek bir binanın ölçümü değildir.

Çalıştır:  python p4_hasar_tespiti.py
Gerekenler: numpy, scipy, scikit-learn, matplotlib  (Python 3.12+)
Çı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
from scipy.linalg import eigh
from sklearn.decomposition import PCA
from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor
from sklearn.metrics import accuracy_score, confusion_matrix

# --- 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. Model: beş katlı kayma binası
rng = np.random.default_rng(42)
KAT = 5
M_KAT = 300e3              # kg, her döşemenin kütlesi
K_KAT = 585e6              # N/m, her katın yanal rijitliği (15 °C'de); T1 ≈ 0,5 s verir
T_REF = 15.0               # °C, referans sıcaklık
BETA = 0.0015              # 1/°C: 1 °C ısınma bütün kat rijitliklerini %0,15 azaltır (VARSAYIM)
GURULTU = 0.002            # frekans ölçümünün bağıl standart sapması (%0,2)
T_ARALIK = (-5.0, 35.0)    # °C, ölçüm günlerinin sıcaklık aralığı
HASARLAR = (0.05, 0.10, 0.20, 0.30)
K_NOM, M_NOM = np.full(KAT, K_KAT), np.full(KAT, M_KAT)


def rijitlik_matrisi(k):
    """Kayma binasının K matrisi. k[j]: (j+1). katın, yani j. ve (j+1). döşeme arasının rijitliği."""
    ust = np.append(k[1:], 0.0)                  # üstteki katın rijitliği (çatıda yok)
    return np.diag(k + ust) - np.diag(k[1:], 1) - np.diag(k[1:], -1)


def frekanslar(k, m):
    """K φ = ω² M φ genelleştirilmiş özdeğer problemi → doğal frekanslar (Hz), küçükten büyüğe."""
    w2 = eigh(rijitlik_matrisi(k), np.diag(m), eigvals_only=True)
    return np.sqrt(w2) / (2 * np.pi)


def olcum(n, kat=-1, hasar=0.0, T=None, k0=K_NOM, m0=M_NOM):
    """n ölçüm üretir: o günün sıcaklığında, gürültülü ilk beş frekans.
    kat = −1 sağlam yapı; kat ∈ {0, …, 4} ise o katın rijitliği (1 − hasar) ile çarpılır."""
    T = rng.uniform(*T_ARALIK, n) if T is None else np.full(n, T)
    kat, hasar = np.broadcast_to(kat, n), np.broadcast_to(hasar, n)
    F = np.empty((n, KAT))
    for i in range(n):
        k = k0 * (1 - BETA * (T[i] - T_REF))     # sıcaklık bütün katları birlikte etkiler
        if kat[i] >= 0:
            k[kat[i]] *= 1 - hasar[i]            # hasar yalnız bir katın rijitliğini düşürür
        F[i] = frekanslar(k, m0)
    F *= 1 + GURULTU * rng.standard_normal(F.shape)   # bağıl ölçüm gürültüsü
    return F, T


def hasarli_olcumler(n_kat=200, **yapi):
    """Her hasar düzeyi için 5 kat × n_kat ölçüm: {düzey: (F, hasarlı kat, sıcaklık)}."""
    veri = {}
    for d in HASARLAR:
        kat = np.repeat(np.arange(KAT), n_kat)
        F, T = olcum(kat.size, kat, d, **yapi)
        veri[d] = (F, kat, T)
    return veri


f0 = frekanslar(K_NOM, M_NOM)
print("=== 1. Model ===")
print(f"Kat kütlesi {M_KAT/1e3:.0f} t, kat rijitliği {K_KAT/1e6:.0f} MN/m (15 °C'de), {KAT} kat; "
      f"frekans ölçüm gürültüsü %{100*GURULTU:.1f}")
print("Doğal frekanslar (Hz): " + "  ".join(f"{f:.3f}" for f in f0) + f"  →  T1 = {1/f0[0]:.3f} s")
soguk = frekanslar(K_NOM * (1 - BETA * (T_ARALIK[0] - T_REF)), M_NOM) / f0 - 1
sicak = frekanslar(K_NOM * (1 - BETA * (T_ARALIK[1] - T_REF)), M_NOM) / f0 - 1
print(f"Sıcaklıkla frekans değişimi (bütün modlarda aynı): -5 °C'de {100*soguk[0]:+.2f} %, "
      f"35 °C'de {100*sicak[0]:+.2f} %")
assert 0.49 < 1 / f0[0] < 0.51 and np.allclose(soguk, soguk[0]) and np.allclose(sicak, sicak[0])

# Gürültüsüz duyarlılık tablosu: %10 hasar her katta ayrı ayrı + karşılaştırma için 10 °C ısınma
dusus = np.empty((KAT + 1, KAT))
for j in range(KAT):
    k = K_NOM.copy()
    k[j] *= 0.90
    dusus[j] = 100 * (1 - frekanslar(k, M_NOM) / f0)
dusus[KAT] = 100 * (1 - frekanslar(K_NOM * (1 - BETA * 10), M_NOM) / f0)
print("Frekans düşüşü (%):            f1     f2     f3     f4     f5")
for j in range(KAT + 1):
    ad = f"%10 hasar, kat {j+1}" if j < KAT else "10 °C ısınma (karşılaştırma)"
    print(f"  {ad:28s}" + "".join(f"{v:7.2f}" for v in dusus[j]))

# Birinci mertebe duyarlılık: kütleye göre normalleştirilmiş modlarda λ_r = Σ_j k_j (φ_rj − φ_r,j−1)²,
# j. katın enerji payı e_rj = k_j (Δφ)² / λ_r  →  Δf_r / f_r ≈ −(d/2)·e_rj
lam0, phi = eigh(rijitlik_matrisi(K_NOM), np.diag(M_NOM))
kat_otelemesi = np.diff(np.vstack([np.zeros(KAT), phi]), axis=0)      # Δφ, satır = kat
enerji_payi = (K_NOM[:, None] * kat_otelemesi**2 / lam0).T           # e[r, j]
assert np.allclose(enerji_payi.sum(axis=1), 1)
print(f"1. modda 1. katın enerji payı e = {enerji_payi[0, 0]:.3f} → birinci mertebe: %10 hasarda "
      f"f1 -{100*0.05*enerji_payi[0, 0]:.2f} % (tam çözüm -{dusus[0, 0]:.2f} %)")

# %% 2. Ölçüm verisi (sentetik)
F_egitim, T_egitim = olcum(1000)                  # sağlam: eğitim (normal davranışı öğrenmek için)
F_dogrulama, _ = olcum(2000)                      # sağlam: eşiği seçmek için
F_saglam_test, T_saglam_test = olcum(1000)        # sağlam: yanlış alarm oranını ölçmek için
hasarli = hasarli_olcumler()                      # hasarlı test: her düzeyde 5 kat × 200 ölçüm
print("\n=== 2. Veri (sentetik) ===")
print(f"Sağlam ölçüm: eğitim {len(F_egitim)}, doğrulama {len(F_dogrulama)}, test {len(F_saglam_test)}; "
      f"hasarlı test: {len(HASARLAR)} düzey × {KAT} kat × 200 = {len(HASARLAR) * KAT * 200}")

# %% 3. Görev 1: yalnız sağlam veriyle hasar algılama
mu, sd = F_egitim.mean(axis=0), F_egitim.std(axis=0)


def standart(F):
    return (F - mu) / sd


Z = standart(F_egitim)
_, s, Vt = np.linalg.svd(Z, full_matrices=False)        # PCA = standartlaştırılmış verinin SVD'si
lam = s**2 / (len(Z) - 1)                                # bileşen varyansları
Vt[0] *= np.sign(Vt[0].sum())                            # işaret keyfi: 1. bileşen yüklerini pozitif seç
pca = PCA().fit(Z)                                       # kütüphane karşılığı
assert np.allclose(pca.explained_variance_, lam)
puan1 = Z @ Vt[0]
r_T = np.corrcoef(puan1, T_egitim)[0, 1]


def oklid(F):
    """Normalleştirme yok: standart sapma birimlerinde ortalamadan uzaklığın karesi."""
    return np.sum(standart(F)**2, axis=1)


def pca_kalinti(F, q=1):
    """İlk q bileşeni (sıcaklık) çıkar, kalıntının karesel normunu döndür (Yan vd. 2005 fikri)."""
    z = standart(F)
    return np.sum((z - z @ Vt[:q].T @ Vt[:q])**2, axis=1)


def mahalanobis_kur(F_saglam):
    """Sağlam ölçümlerden μ ve Σ'yı öğrenir; D²(f) = (f − μ)ᵀ Σ⁻¹ (f − μ) fonksiyonunu döndürür."""
    mu_s = F_saglam.mean(axis=0)
    S_ters = np.linalg.inv(np.cov(F_saglam, rowvar=False))

    def D2(F):
        fark = F - mu_s
        return np.einsum("ij,jk,ik->i", fark, S_ters, fark)
    return D2


mahalanobis = mahalanobis_kur(F_egitim)
# Tutarlılık: D² = Σ_k (bileşen puanı_k)² / varyans_k  (Mahalanobis = bütün bileşenleri ölçekleyen PCA)
z_test = standart(F_saglam_test)
assert np.allclose(mahalanobis(F_saglam_test), np.sum((z_test @ Vt.T)**2 / lam, axis=1))


def degerlendir(gosterge, F_dog, F_sag, veri):
    """Eşik = sağlam doğrulama göstergesinin %99'luk dilimi; yanlış alarm ve algılama oranları."""
    esik = np.percentile(gosterge(F_dog), 99)
    yanlis = np.mean(gosterge(F_sag) > esik)
    algi = [np.mean(gosterge(veri[d][0]) > esik) for d in HASARLAR]
    return esik, yanlis, algi


sonuc = {
    "Öklid (çevresel normalleştirme yok)": degerlendir(oklid, F_dogrulama, F_saglam_test, hasarli),
    "PCA kalıntısı (1. bileşen atıldı)": degerlendir(pca_kalinti, F_dogrulama, F_saglam_test, hasarli),
    "Mahalanobis": degerlendir(mahalanobis, F_dogrulama, F_saglam_test, hasarli),
}
# Karşılaştırma: sıcaklık hiç değişmeseydi (laboratuvar koşulu, sabit 15 °C)
F_lab_egitim, _ = olcum(1000, T=T_REF)
F_lab_dog, _ = olcum(2000, T=T_REF)
F_lab_test, _ = olcum(1000, T=T_REF)
lab_veri = hasarli_olcumler(T=T_REF)
sonuc["Sabit 15 °C (laboratuvar, Mahal.)"] = degerlendir(
    mahalanobis_kur(F_lab_egitim), F_lab_dog, F_lab_test, lab_veri)

print("\n=== 3. Görev 1: etiketsiz algılama ===")
print("PCA varyans payları: " + "  ".join(f"{v:.3f}" for v in pca.explained_variance_ratio_))
print("1. bileşenin yükleri: " + "  ".join(f"{v:.3f}" for v in Vt[0])
      + f";  sıcaklıkla korelasyonu r = {r_T:+.3f}")
print("Gösterge                                eşik   yanlış alarm   algılama (%): %5    %10    %20    %30")
for ad, (esik, yanlis, algi) in sonuc.items():
    print(f"  {ad:36s}{esik:7.3f}{100*yanlis:9.1f} %      " + "".join(f"{100*a:7.1f}" for a in algi))
assert abs(r_T) > 0.9 and all(0 < y < 0.03 for _, y, _ in sonuc.values())

# %% 4. Görev 2: hasarlı katı bulmak (benzetimle eğitilen sınıflandırıcı)
n_egit = 4000
kat_e = rng.integers(0, KAT, n_egit)
d_e = rng.uniform(0.03, 0.35, n_egit)             # şiddet bilinmiyor: geniş bir aralıktan çek
F_e, _ = olcum(n_egit, kat_e, d_e)


def goreli(F, referans):
    """Özellik: sağlam ortalamaya göre bağıl frekans değişimi."""
    return F / referans - 1


siniflandirici = RandomForestClassifier(n_estimators=200, random_state=42, n_jobs=1)
siniflandirici.fit(goreli(F_e, mu), kat_e)
siniflandirici_ham = RandomForestClassifier(n_estimators=200, random_state=42, n_jobs=1)
siniflandirici_ham.fit(F_e, kat_e)                # karşılaştırma: ham frekanslarla (Hz)

dogruluk_model = [accuracy_score(hasarli[d][1], siniflandirici.predict(goreli(hasarli[d][0], mu)))
                  for d in HASARLAR]
KM_5 = confusion_matrix(hasarli[0.05][1], siniflandirici.predict(goreli(hasarli[0.05][0], mu)))

# "Gerçek" yapı: kat rijitlikleri ve kütleleri modelden biraz farklı (modelin bilmediği sapmalar)
K_GERCEK = K_KAT * np.array([1.08, 0.94, 1.05, 0.92, 1.06])
M_GERCEK = M_KAT * np.array([1.03, 0.98, 1.04, 0.97, 0.90])
F_g_saglam, _ = olcum(1000, k0=K_GERCEK, m0=M_GERCEK)   # izlemenin ilk dönemi: sağlam ölçümler
mu_g = F_g_saglam.mean(axis=0)
gercek = hasarli_olcumler(k0=K_GERCEK, m0=M_GERCEK)
dogruluk_goreli = [accuracy_score(gercek[d][1], siniflandirici.predict(goreli(gercek[d][0], mu_g)))
                   for d in HASARLAR]
dogruluk_ham = [accuracy_score(gercek[d][1], siniflandirici_ham.predict(gercek[d][0])) for d in HASARLAR]

print("\n=== 4. Görev 2: hasarlı kat ===")
print(f"Eğitim: {n_egit} benzetim (kat 1–5, hasar %3–35, rastgele sıcaklık); Random Forest, 200 ağaç")
print("Gerçek yapının sağlam frekanslarının modelden farkı (%): "
      + "  ".join(f"{100*(g/m - 1):+.2f}" for g, m in zip(mu_g, mu)))
print("Doğruluk (%)                          %5    %10    %20    %30")
for ad, dog in [("Model = yapı (göreli özellik)", dogruluk_model),
                ("Gerçek yapı, göreli özellik", dogruluk_goreli),
                ("Gerçek yapı, ham frekans (Hz)", dogruluk_ham)]:
    print(f"  {ad:34s}" + "".join(f"{100*a:7.1f}" for a in dog))
print("Karışıklık matrisi, %5 hasar, model = yapı (satır: gerçek kat, sütun: tahmin edilen kat):")
for j in range(KAT):
    print(f"  kat {j+1}:" + "".join(f"{v:5d}" for v in KM_5[j]))
assert KM_5.sum() == KAT * 200 and np.isclose(np.trace(KM_5) / KM_5.sum(), dogruluk_model[0])

# %% 5. Görev 3: hasar şiddeti (regresyon)
regresor = RandomForestRegressor(n_estimators=200, random_state=42, n_jobs=1)
regresor.fit(goreli(F_e, mu), 100 * d_e)
mae_model = [np.mean(np.abs(regresor.predict(goreli(hasarli[d][0], mu)) - 100 * d)) for d in HASARLAR]
mae_gercek = [np.mean(np.abs(regresor.predict(goreli(gercek[d][0], mu_g)) - 100 * d)) for d in HASARLAR]
print("\n=== 5. Görev 3: hasar şiddeti ===")
print("Ortalama mutlak hata (yüzde puan)     %5    %10    %20    %30")
print("  Model = yapı                      " + "".join(f"{m:7.2f}" for m in mae_model))
print("  Gerçek yapı (göreli özellik)      " + "".join(f"{m:7.2f}" for m in mae_gercek))
assert np.all(np.isfinite(mae_model)) and np.all(np.isfinite(mae_gercek))

# %% 6. Grafikler
modlar = [f"f{r+1}" for r in range(KAT)]
fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
F10, kat10, T10 = hasarli[0.10]
ax[0].scatter(T_egitim, F_egitim[:, 0], s=8, color=SOLUK, alpha=.6, label="Sağlam")
secim = kat10 == 0
ax[0].scatter(T10[secim], F10[secim, 0], s=10, color=RENK[0], alpha=.8, label="%10 hasar, 1. kat")
ax[0].set(xlabel="Sıcaklık (°C)", ylabel="1. doğal frekans f1 (Hz)",
          title="f1 tek başına: soğukta hasarlı ≈ sıcakta sağlam")
ax[0].legend(loc="upper right")
im = ax[1].imshow(dusus, cmap="Blues", vmin=0, aspect="auto")
for (i, j), v in np.ndenumerate(dusus):
    ax[1].text(j, i, f"{v:.2f}", ha="center", va="center", fontsize=9,
               color="white" if v > 0.6 * dusus.max() else MUREKKEP)
ax[1].set_xticks(range(KAT), modlar)
ax[1].set_yticks(range(KAT + 1), [f"Kat {j+1}, %10" for j in range(KAT)] + ["10 °C ısınma"])
ax[1].grid(False)
ax[1].set_title("Frekans düşüşü (%): hasar deseni ve sıcaklık")
fig.colorbar(im, ax=ax[1], label="Frekans düşüşü (%)")
fig.savefig(KLASOR / "p4_hasar_tespiti_1.png", dpi=160)
plt.close(fig)

fig, ax = plt.subplots(2, 2, figsize=(10, 7.5), layout="constrained")
# Renk her panelde göstergeyi belirtir (turuncu: Öklid, mavi: PCA kalıntısı);
# üst panellerde çizgi biçimi hasar düzeyini (kesikli %5, düz %10)
for a, (ad, gosterge, renk) in zip(ax[0], [("Öklid (çevresel normalleştirme yok)", oklid, RENK[1]),
                                           ("PCA kalıntısı (1. bileşen atıldı)", pca_kalinti, RENK[0])]):
    esik = sonuc[ad][0]
    degerler = [gosterge(F_saglam_test), gosterge(hasarli[0.05][0]), gosterge(hasarli[0.10][0])]
    kutular = np.geomspace(min(v.min() for v in degerler), max(v.max() for v in degerler), 45)
    a.hist(degerler[0], bins=kutular, color=SOLUK, alpha=.6, label="Sağlam")
    a.hist(degerler[1], bins=kutular, histtype="step", lw=1.6, ls=(0, (4, 2)), color=renk, label="%5 hasar")
    a.hist(degerler[2], bins=kutular, histtype="step", lw=1.9, color=renk, label="%10 hasar")
    a.axvline(esik, color=MUREKKEP, ls="--", lw=1.2, label="Eşik (%99)")
    a.set_xscale("log")
    a.set(xlabel="Hasar göstergesi (log ölçek)", ylabel="Ölçüm sayısı", title=ad)
    a.legend(loc="upper left")
ilk = slice(0, 500)                               # okunaklılık için sağlam testin ilk 500 ölçümü
ax[1, 0].scatter(T_saglam_test[ilk],
                 oklid(F_saglam_test[ilk]) / sonuc["Öklid (çevresel normalleştirme yok)"][0],
                 s=7, color=RENK[1], label="Öklid")
ax[1, 0].scatter(T_saglam_test[ilk],
                 pca_kalinti(F_saglam_test[ilk]) / sonuc["PCA kalıntısı (1. bileşen atıldı)"][0],
                 s=7, color=RENK[0], label="PCA kalıntısı")
ax[1, 0].axhline(1, color=MUREKKEP, ls="--", lw=1.2, label="Eşik")
ax[1, 0].set(xlabel="Sıcaklık (°C)", ylabel="Gösterge / eşik", title="Sağlam yapıda gösterge ve sıcaklık",
              ylim=(0, 1.6))
ax[1, 0].legend(loc="upper center", ncols=3)
duzey = [100 * d for d in HASARLAR]
cizim = [("Öklid (çevresel normalleştirme yok)", RENK[1], "-", "o"),
         ("PCA kalıntısı (1. bileşen atıldı)", RENK[0], "-", "o"),
         ("Mahalanobis", RENK[2], "--", "s"),
         ("Sabit 15 °C (laboratuvar, Mahal.)", MUREKKEP, ":", "^")]
for ad, renk, cizgi, isaret in cizim:
    ax[1, 1].plot(duzey, [100 * a for a in sonuc[ad][2]], cizgi, marker=isaret, ms=6, color=renk, label=ad)
ax[1, 1].set(xlabel="Hasar düzeyi (% rijitlik kaybı, tek kat)", ylabel="Algılama oranı (%)",
             title="Yanlış alarm ≈ %1'de algılama", xticks=duzey, ylim=(0, 105))
ax[1, 1].legend(loc="lower right", fontsize=8.5)
fig.savefig(KLASOR / "p4_hasar_tespiti_2.png", dpi=160)
plt.close(fig)

fig, ax = plt.subplots(1, 2, figsize=(10, 4.2), layout="constrained")
ax[0].imshow(KM_5, cmap="Blues")
for (i, j), v in np.ndenumerate(KM_5):
    ax[0].text(j, i, str(v), ha="center", va="center", fontsize=10,
               color="white" if v > 0.5 * KM_5.max() else MUREKKEP)
ax[0].set_xticks(range(KAT), [str(j + 1) for j in range(KAT)])
ax[0].set_yticks(range(KAT), [str(j + 1) for j in range(KAT)])
ax[0].grid(False)
ax[0].set(xlabel="Tahmin edilen kat", ylabel="Gerçek hasarlı kat", title="Karışıklık matrisi, %5 hasar")
for (ad, dog), renk in zip([("Model = yapı (göreli özellik)", dogruluk_model),
                            ("Gerçek yapı, göreli özellik", dogruluk_goreli),
                            ("Gerçek yapı, ham frekans", dogruluk_ham)], RENK[:3]):
    ax[1].plot(duzey, [100 * a for a in dog], marker="o", color=renk, label=ad)
ax[1].axhline(100 / KAT, color=MUREKKEP, ls=":", lw=1.2, label="Rastgele tahmin (%20)")
ax[1].set(xlabel="Hasar düzeyi (% rijitlik kaybı)", ylabel="Doğru kat oranı (%)",
          title="Konum doğruluğu ve model hatası", xticks=duzey, ylim=(0, 105))
ax[1].legend(loc="center right", bbox_to_anchor=(1, 0.5))
fig.savefig(KLASOR / "p4_hasar_tespiti_3.png", dpi=160)
plt.close(fig)
print("\nGrafikler kaydedildi: p4_hasar_tespiti_1.png, _2.png, _3.png")
