Update src/streamlit_app.py

added code for machine vibration analysis

src/streamlit_app.py

@@ -1,40 +1,662 @@
-import altair as alt
-import numpy as np
-import pandas as pd
 import streamlit as st
+import pandas as pd
+import numpy as np
+import json
+import plotly.graph_objects as go
+from datetime import datetime
+import re
+from typing import Tuple, Optional, Dict, List
+
+# --------------------------------------------------
+# Page setup
+# --------------------------------------------------
+st.set_page_config(page_title="Machine Vibration Analysis App", layout="wide")
+
+# Title and description
+st.title("Machine Vibration Analysis App")
+st.markdown(
+    "Upload a JSON file to see variables with clear descriptions and per-channel plots.  \n"
+    "**Memory (natural text)** now explains the tool-break result using *key frequencies* and their amplitudes.  \n"
+    "**ML Training (Key‑freq only)** exports features built strictly from key frequencies (fr, ft, k·ft and sidebands) to predict tool breakage.  \n"
+    "Key Frequencies tab shows spindle (fr), tooth‑passing (ft), TPF harmonics, and once‑per‑rev sidebands (± n·fr) with amplitude markers."
+)
+
+# --------------------------------------------------
+# Sidebar: upload and settings
+# --------------------------------------------------
+st.sidebar.header("Settings")
+uploaded_file = st.sidebar.file_uploader("Upload JSON file", type="json")
+
+harmonics_count = st.sidebar.number_input(
+    "Number of harmonics to compute (for RPM-based analysis)", min_value=1, max_value=200, value=10, step=1
+)
+
+top_n = st.sidebar.number_input(
+    "Top-N harmonics to list (for text)", min_value=1, max_value=int(harmonics_count), value=min(5, int(harmonics_count)), step=1
+)
+
+first_harmonic_threshold = st.sidebar.number_input(
+    "List Top-N only if 1st harm. amplitude ≥", min_value=0.0, value=1000.0, step=100.0
+)
+
+# (this still governs how many TPF harmonics to consider in Key Frequencies)
+k_tpf = st.sidebar.number_input(
+    "TPF harmonics K (for Key Frequencies)", min_value=1, max_value=200, value=10, step=1
+)
+include_sidebands = st.sidebar.checkbox(
+    "Add once-per-rev sidebands (± n·fr) around TPF harmonics", value=True
+)
+max_sideband_order = st.sidebar.number_input(
+    "Max sideband order n (0 = none)", min_value=0, max_value=10, value=1, step=1
+)
+annotate_amplitudes = st.sidebar.checkbox("Annotate amplitudes at key frequencies", value=True)
+annotation_min_amp = st.sidebar.number_input(
+    "Annotation min amplitude (hide labels below)", min_value=0.0, value=0.0, step=1.0
+)
+apply_hann = st.sidebar.checkbox("Apply Hann window before FFT (recommended)", value=True)
+
+# --------------------------------------------------
+# Variable descriptions
+# --------------------------------------------------
+VAR_DESCRIPTIONS = {
+    "d": "Tool diameter [mm]",
+    "z": "Number of teeth [-]",
+    "ap": "Axial depth of cut [mm]",
+    "ae": "Radial depth of cut [mm]",
+    "n": "Turning speed [rpm]",
+    "f": "Feed per tooth [mm/z]",
+    "type": "Type of machining (down=in accordance, up=in opposition)",
+    "break": "Tool breakage (true=broken, false=intact)",
+    "sample_frequency": "Sampling frequency [Hz]",
+    "acel_x": "Accelerometer X-axis [m/s^2]",
+    "acel_y": "Accelerometer Y-axis [m/s^2]",
+}
+
+def describe_key(k):
+    return VAR_DESCRIPTIONS.get(k, k.replace("_", " ").capitalize())
+
+
+def slug(s: str) -> str:
+    """Safe feature name component."""
+    return re.sub(r"[^A-Za-z0-9]+", "_", str(s)).strip("_").lower()
+
+
+# --------------------------------------------------
+# Utility helpers
+# --------------------------------------------------
+
+def nearest_bin_amplitude(xf: np.ndarray, amp: np.ndarray, freq: float) -> Tuple[float, float]:
+    """Return (bin_freq, amplitude) nearest to freq. If out of range, (nan, nan)."""
+    if freq is None or freq <= 0 or len(xf) == 0 or np.isnan(freq) or freq > xf[-1]:
+        return (float("nan"), float("nan"))
+    idx = int(np.argmin(np.abs(xf - freq)))
+    return (float(xf[idx]), float(amp[idx]))
+
+
+def fmt_float(x, sig=4):
+    try:
+        if x is None or (isinstance(x, float) and not np.isfinite(x)):
+            return "n/a"
+        if isinstance(x, (int, np.integer)) or (isinstance(x, float) and x.is_integer()):
+            return f"{int(x)}"
+        return f"{x:.{sig}g}"
+    except Exception:
+        return str(x)
+
+
+@st.cache_data(show_spinner=False)
+def compute_fft(signal: np.ndarray, fs: float, apply_hann: bool = True) -> Tuple[np.ndarray, np.ndarray]:
+    """Compute single-sided FFT amplitude spectrum."""
+    if signal.size == 0 or fs <= 0:
+        return np.array([]), np.array([])
+    sig = signal.astype(float)
+    if apply_hann:
+        w = np.hanning(sig.size)
+        sig = sig * w
+    yf = np.fft.rfft(sig)
+    xf = np.fft.rfftfreq(sig.size, 1.0 / fs)
+    amp = np.abs(yf)
+    return xf, amp
+
+
+# --------------------------------------------------
+# File upload and processing
+# --------------------------------------------------
+if uploaded_file:
+    data = json.load(uploaded_file)
+
+    # ---- Normalize channels ---------------------------------------------------
+    channels = [k for k in data.keys() if k.startswith("Channel_")]
+    axis_keys = [k for k in data.keys() if k.lower() in ("acel_x", "acel_y")]
+    if axis_keys and not channels:
+        for k in axis_keys:
+            v = data.get(k, [])
+            data[f"Channel_{k.upper()}"] = {
+                "SignalName": describe_key(k),
+                "Signal": v,
+                "Unit": "m/s^2",
+            }
+        channels = [k for k in data.keys() if k.startswith("Channel_")]
+
+    selected_channels = st.sidebar.multiselect(
+        "Select Channels to Display (default: all)", channels, default=channels
+    )
+
+    # ---- Breakage flag --------------------------------------------------------
+    broke = bool(data.get("break", False))
+    st.sidebar.error("Tool Breakage: Yes" if broke else "Tool Breakage: No")
+
+    # ---- Variables & Header ---------------------------------------------------
+    blacklist = {"__header__", "__version__", "__globals__", "File_Header"}
+    root_scalars = {
+        k: v
+        for k, v in data.items()
+        if not isinstance(v, dict)
+        and k not in blacklist
+        and not isinstance(v, (list, tuple))
+    }
+    file_header = data.get("File_Header", {})
+
+    col1, col2 = st.columns(2)
+    with col1:
+        st.subheader("File Variables")
+        if root_scalars:
+            df_vars = (
+                pd.DataFrame({"Key": list(root_scalars.keys()), "Value": list(root_scalars.values())})
+                .assign(Description=lambda d: d["Key"].map(describe_key))
+                .set_index("Key")
+            )
+            st.table(df_vars[["Description", "Value"]])
+        else:
+            st.caption("No scalar variables found in the root of the JSON.")
+    with col2:
+        st.subheader("File Header")
+        if file_header:
+            df_header = pd.DataFrame(file_header, index=[0]).T.rename(columns={0: "Value"})
+            st.table(df_header)
+        else:
+            st.caption("No 'File_Header' found.")
+
+    # ---- Sample frequency & fundamental --------------------------------------
+    fs = float(data.get("sample_frequency") or file_header.get("SampleFrequency", 1.0) or 1.0)
+
+    f_fund, n_rpm = None, None
+    if isinstance(data.get("n"), (int, float)) and data["n"] != 0:
+        n_rpm = float(data["n"])
+        f_fund = n_rpm / 60.0
+    else:
+        st.warning("Fundamental frequency not found: expected numeric key 'n' (RPM).")
+
+    # ---- Teeth / TPF ----------------------------------------------------------
+    z_teeth: Optional[int] = None
+    if isinstance(data.get("z"), (int, float)) and data["z"] > 0:
+        z_teeth = int(data["z"])  # number of flutes/teeth
+
+    fr = f_fund if f_fund else None  # spindle rotational frequency
+    ft = (z_teeth * fr) if (z_teeth and fr) else None  # tooth-passing frequency
+
+    # --------------------------------------------------
+    # Pre-pass: compute harmonics & quick stats (RPM-based)
+    # --------------------------------------------------
+    harmonic_tables: Dict[str, Tuple[str, str, Optional[pd.DataFrame]]] = {}
+    bin_res_by_ch: Dict[str, float] = {}
+    stats_by_ch: Dict[str, Dict[str, float]] = {}
+    dom_by_ch: Dict[str, str] = {}
+
+    for ch in selected_channels:
+        ch_data = data.get(ch, {})
+        label = ch_data.get("SignalName", ch)
+        signal = np.asarray(ch_data.get("Signal", []), dtype=float)
+        unit = ch_data.get("Unit", "")
+
+        if signal.size == 0 or fs <= 0:
+            harmonic_tables[ch] = (label, unit, None)
+            continue
+
+        xf, amp = compute_fft(signal, fs, apply_hann)
+        bin_res = xf[1] - xf[0] if len(xf) > 1 else float("nan")
+        bin_res_by_ch[ch] = bin_res
+
+        # stats
+        rms = float(np.sqrt(np.mean(signal ** 2))) if signal.size > 0 else np.nan
+        peak = float(np.max(np.abs(signal))) if signal.size > 0 else np.nan
+        stats_by_ch[ch] = {"rms": rms, "peak": peak, "unit": unit}
+
+        df_h = None
+        dom_text = "n/a"
+
+        if f_fund and np.isfinite(f_fund) and len(xf) > 0:
+            harmonics_idx = np.arange(1, int(harmonics_count) + 1)
+            harmonics_freqs = harmonics_idx * f_fund
+
+            harm_amps, bin_freqs = [], []
+            for f_h in harmonics_freqs:
+                bfreq, a = nearest_bin_amplitude(xf, amp, f_h)
+                harm_amps.append(a)
+                bin_freqs.append(bfreq)
+
+            df_h = pd.DataFrame(
+                {
+                    "Harmonic #": harmonics_idx,
+                    "Target f [Hz]": np.round(harmonics_freqs, 6),
+                    "Bin f [Hz]": np.round(bin_freqs, 6),
+                    "Amplitude": harm_amps,
+                }
+            )
+
+            if np.isfinite(df_h["Amplitude"]).any():
+                idx_dom = df_h["Amplitude"].astype(float).idxmax()
+                dom_row = df_h.loc[idx_dom]
+                dom_text = (
+                    f"{int(dom_row['Harmonic #'])}× @ {dom_row['Bin f [Hz]']:.2f} Hz (amp {dom_row['Amplitude']:.3g}{(' ' + unit) if unit else ''})"
+                )
+
+        harmonic_tables[ch] = (label, unit, df_h)
+        dom_by_ch[ch] = dom_text
+
+    # --------------------------------------------------
+    # Helper: compute per‑channel key‑frequency amplitudes & sidebands
+    # --------------------------------------------------
+    def compute_keyfreqs_for_channel(xf, amp, fr, ft, k_tpf: int, include_sb: bool, sb_orders: int):
+        """Return dict with fr amplitude, list of k*ft amplitudes, and primary sideband ratios (n=1) per k."""
+        out = {
+            "fr": {"target_hz": fr, "bin_hz": float("nan"), "amp": float("nan")},
+            "tpf": [],  # list of {k, target_hz, bin_hz, amp, sbr_n1}
+        }
+        if xf is None or len(xf) == 0:
+            return out
+        # spindle
+        if fr:
+            bfreq_fr, a_fr = nearest_bin_amplitude(xf, amp, fr)
+            out["fr"] = {"target_hz": fr, "bin_hz": bfreq_fr, "amp": a_fr}
+        # TPF harmonics
+        if ft:
+            fmax = xf[-1]
+            for k in range(1, int(k_tpf) + 1):
+                target = k * ft
+                if target > fmax:
+                    break
+                bfreq_k, a_k = nearest_bin_amplitude(xf, amp, target)
+                sbr = float("nan")
+                if include_sb and fr and sb_orders >= 1 and np.isfinite(a_k) and a_k > 0:
+                    # n=1 sidebands only for SBR metric
+                    _, a_m = nearest_bin_amplitude(xf, amp, max(0.0, target - fr))
+                    _, a_p = nearest_bin_amplitude(xf, amp, target + fr)
+                    if np.isfinite(a_m) and np.isfinite(a_p):
+                        sbr = (a_m + a_p) / a_k if a_k else float("nan")
+                out["tpf"].append({"k": k, "target_hz": target, "bin_hz": bfreq_k, "amp": a_k, "sbr_n1": sbr})
+        return out
+
+    # spectra cache for key‑freq computations
+    spectra_cache: Dict[str, Tuple[np.ndarray, np.ndarray]] = {}
+    for ch in selected_channels:
+        ch_data = data.get(ch, {})
+        signal = np.asarray(ch_data.get("Signal", []), dtype=float)
+        if signal.size > 0 and fs > 0:
+            xf, amp = compute_fft(signal, fs, apply_hann)
+            spectra_cache[ch] = (xf, amp)
+        else:
+            spectra_cache[ch] = (np.array([]), np.array([]))
+
+    keyfreq_by_channel: Dict[str, dict] = {}
+    for ch in selected_channels:
+        label = data.get(ch, {}).get("SignalName", ch)
+        xf, amp = spectra_cache.get(ch, (np.array([]), np.array([])))
+        keyfreq_by_channel[label] = compute_keyfreqs_for_channel(
+            xf, amp, fr, ft, int(k_tpf), bool(include_sidebands), int(max_sideband_order)
+        )
+
+    # --------------------------------------------------
+    # Memory (natural language) – EXPLANATION based on key frequencies
+    # --------------------------------------------------
+    st.subheader("Memory (natural text)")
+
+    header_context_text = "; ".join([f"{k}={file_header[k]}" for k in file_header]) or "no header context"
+    n_text = f"{fmt_float(n_rpm)} RPM" if n_rpm else "n/a"
+    f0_text = f"{fmt_float(f_fund)} Hz" if f_fund else "n/a"
+    fs_text = f"{fmt_float(fs)} Hz" if np.isfinite(fs) else "n/a"
+    break_text = "YES" if broke else "NO"
+
+    # Build channel-specific interpretations from key‑frequency amplitudes
+    channel_summaries: List[str] = []
+    for ch in selected_channels:
+        label, unit, _ = harmonic_tables[ch]
+        s = stats_by_ch.get(ch, {})
+        rms = s.get("rms", np.nan)
+        kf = keyfreq_by_channel.get(label, {})
+        fr_amp = kf.get("fr", {}).get("amp", np.nan)
+        fr_bin = kf.get("fr", {}).get("bin_hz", np.nan)
+        tpf_list = kf.get("tpf", [])
+        if tpf_list:
+            # metrics: max TPF amp and mean SBR (n=1)
+            max_tpf = max(tpf_list, key=lambda r: (r.get("amp") if np.isfinite(r.get("amp", np.nan)) else -1))
+            mean_sbr = np.nan
+            if any(np.isfinite(r.get("sbr_n1", np.nan)) for r in tpf_list):
+                vals = [r.get("sbr_n1") for r in tpf_list if np.isfinite(r.get("sbr_n1", np.nan))]
+                mean_sbr = float(np.mean(vals)) if len(vals) else np.nan
+            summary = (
+                f"**{label}**: spindle fr≈{fmt_float(fr_bin)} Hz has amplitude {fmt_float(fr_amp)}{(' ' + unit) if unit else ''}; "
+                f"TPF harmonics peak at k={max_tpf.get('k')} (f≈{fmt_float(max_tpf.get('bin_hz'))} Hz) "
+                f"with amp {fmt_float(max_tpf.get('amp'))}{(' ' + unit) if unit else ''}. "
+                f"Primary sideband ratio (±fr) ≈ {fmt_float(mean_sbr)}."
+            )
+        else:
+            summary = (
+                f"**{label}**: spindle fr≈{fmt_float(fr_bin)} Hz amp {fmt_float(fr_amp)}{(' ' + unit) if unit else ''}; "
+                "TPF harmonics not within spectrum range."
+            )
+        if np.isfinite(rms):
+            summary += f" RMS ≈ {fmt_float(rms)}{(' ' + unit) if unit else ''}."
+        channel_summaries.append(summary)
+
+    # Overall qualitative cue (non-binding heuristic for narrative only)
+    # Heuristic: if many TPF harmonics are strong and sidebands are pronounced, narrative highlights possible damage.
+    def heuristic_break_signal(channel_kf: Dict[str, dict]) -> str:
+        flags = 0
+        for label, kf in channel_kf.items():
+            fr_amp = kf.get("fr", {}).get("amp", np.nan)
+            tpf_list = kf.get("tpf", [])
+            strong_tpf = sum(1 for r in tpf_list if np.isfinite(r.get("amp", np.nan)) and r["amp"] > (fr_amp if np.isfinite(fr_amp) else 0))
+            sbr_vals = [r.get("sbr_n1") for r in tpf_list if np.isfinite(r.get("sbr_n1", np.nan))]
+            mean_sbr = (np.mean(sbr_vals) if sbr_vals else 0)
+            if strong_tpf >= 3:
+                flags += 1
+            if mean_sbr and mean_sbr > 0.7:
+                flags += 1
+        if flags >= 2:
+            return "Key‑frequency pattern shows strong TPF content and pronounced sidebands, which often accompanies tool damage or chipping."
+        elif flags == 1:
+            return "Key‑frequency content shows some TPF/sideband prominence; monitor for degradation."
+        else:
+            return "Key‑frequency content is modest; spectra are consistent with an intact tool during stable cutting."
+
+    narrative_hint = heuristic_break_signal(keyfreq_by_channel)
+
+    mem_text = (
+        "Machine vibration snapshot — tool break label: "
+        f"{break_text}. Spindle speed n = {n_text}, fundamental f₀ = {f0_text}, sampling fs = {fs_text}. "
+        + (f"Key frequencies: spindle f_r={fmt_float(fr)} Hz" if fr else "")
+        + (f", tooth‑passing f_t={fmt_float(ft)} Hz (Z={z_teeth}). " if ft else ". ")
+        + f"File header context: {header_context_text}. "
+        + narrative_hint + " "
+        + " ".join(channel_summaries)
+    )
+
+    st.write(mem_text)
+
+    # Memory payload (keeps full amplitudes for downstream use)
+    memory_payload = {
+        "type": "vibration_memory_text",
+        "schema_version": 8,  # bumped for key‑freq explanation text
+        "created_at": datetime.utcnow().isoformat() + "Z",
+        "tool_break": broke,
+        "n_rpm": n_rpm,
+        "f0_hz": f_fund,
+        "sample_frequency_hz": fs,
+        "z_teeth": z_teeth,
+        "fr_hz": fr,
+        "ft_hz": ft,
+        "file_header": file_header,
+        "text": mem_text,
+        "key_frequencies_by_channel": keyfreq_by_channel,
+    }
+
+    colmj, colmt = st.columns(2)
+    with colmj:
+        st.download_button(
+            "⬇️ Download Memory (JSON)",
+            data=json.dumps(memory_payload, ensure_ascii=False, indent=2).encode("utf-8"),
+            file_name="machine_vibration_memory_text.json",
+            mime="application/json",
+        )
+    with colmt:
+        st.download_button(
+            "⬇️ Download Memory (TXT)",
+            data=mem_text.encode("utf-8"),
+            file_name="machine_vibration_memory.txt",
+            mime="text/plain",
+        )
+
+    st.divider()
+
+    # --------------------------------------------------
+    # ML Training (Key‑freq only)
+    # --------------------------------------------------
+    st.subheader("ML Training (Key‑freq only)")
+    st.caption(
+        "Single input row using only amplitudes from key frequencies: spindle fr and TPF harmonics k·ft (with optional sideband ratio SBR at ±fr). Target is `break` (boolean) provided separately."
+    )
+
+    # Build a single feature row composed *only* of key‑frequency features
+    feature_row = {}
+
+    # Global context — optionally include fr and ft as numeric context features
+    if np.isfinite(fr) if fr is not None else False:
+        feature_row["global_fr_hz"] = float(fr)
+    if np.isfinite(ft) if ft is not None else False:
+        feature_row["global_ft_hz"] = float(ft)
+
+    # Per‑channel key‑frequency features
+    for ch in selected_channels:
+        label = data.get(ch, {}).get("SignalName", ch)
+        prefix = slug(label) or slug(ch)
+        kf = keyfreq_by_channel.get(label, {})
+        fr_amp = kf.get("fr", {}).get("amp", np.nan)
+        fr_bin = kf.get("fr", {}).get("bin_hz", np.nan)
+        feature_row[f"{prefix}_fr_amp"] = float(fr_amp) if np.isfinite(fr_amp) else None
+        feature_row[f"{prefix}_fr_bin_hz"] = float(fr_bin) if np.isfinite(fr_bin) else None
+
+        tpf_list = kf.get("tpf", [])
+        for r in tpf_list:
+            k_idx = int(r.get("k", 0))
+            a = r.get("amp", np.nan)
+            b = r.get("bin_hz", np.nan)
+            sbr = r.get("sbr_n1", np.nan)
+            feature_row[f"{prefix}_tpf_h{k_idx}_amp"] = float(a) if np.isfinite(a) else None
+            feature_row[f"{prefix}_tpf_h{k_idx}_bin_hz"] = float(b) if np.isfinite(b) else None
+            # Sideband ratio (n=1)
+            feature_row[f"{prefix}_tpf_h{k_idx}_sbr"] = float(sbr) if np.isfinite(sbr) else None
+
+        # Lightweight summary stats for learning stability (still key‑freq derived)
+        if tpf_list:
+            amps = [r.get("amp", np.nan) for r in tpf_list]
+            sbrs = [r.get("sbr_n1", np.nan) for r in tpf_list]
+            if any(np.isfinite(amps)):
+                feature_row[f"{prefix}_tpf_amp_max"] = float(np.nanmax(amps))
+                feature_row[f"{prefix}_tpf_amp_mean"] = float(np.nanmean(amps))
+            if any(np.isfinite(sbrs)):
+                feature_row[f"{prefix}_tpf_sbr_mean"] = float(np.nanmean(sbrs))
+
+    # One‑row DataFrame for editing; target kept separately
+    df_feat = pd.DataFrame([feature_row])
+
+    col_left, col_right = st.columns([3, 1])
+    with col_left:
+        edited_df_feat = st.data_editor(
+            df_feat,
+            use_container_width=True,
+            num_rows="fixed",
+            column_config={c: st.column_config.NumberColumn(format="%.6g") for c in df_feat.columns},
+        )
+    with col_right:
+        st.metric("Target: break", "YES" if broke else "NO")
+        st.caption("Provided separately from features")
+
+    # Export JSON & CSV
+    ebm_payload = {
+        "schema_version": 5,  # bumped — key‑freq‑only features
+        "created_at": datetime.utcnow().isoformat() + "Z",
+        "task": "tool_breakage_detection",
+        "target": {"break": broke},
+        "features": edited_df_feat.to_dict(orient="records")[0],
+    }
+
+    colj, colc = st.columns(2)
+    with colj:
+        st.download_button(
+            "⬇️ Download ML input (JSON)",
+            data=json.dumps(ebm_payload, ensure_ascii=False, indent=2).encode("utf-8"),
+            file_name="machine_vibration_keyfreq_input.json",
+            mime="application/json",
+        )
+    with colc:
+        st.download_button(
+            "⬇️ Download ML input (CSV)",
+            data=edited_df_feat.to_csv(index=False).encode("utf-8"),
+            file_name="machine_vibration_keyfreq_input.csv",
+            mime="text/csv",
+        )
+
+    st.divider()
+
+    # --------------------------------------------------
+    # Per-channel plots (time, freq, Key Frequencies)
+    # --------------------------------------------------
+    if selected_channels:
+        tabs = st.tabs([harmonic_tables[ch][0] for ch in selected_channels])
+        for tab, ch in zip(tabs, selected_channels):
+            with tab:
+                label, unit, _ = harmonic_tables[ch]
+                ch_data = data.get(ch, {})
+                signal = np.asarray(ch_data.get("Signal", []), dtype=float)
+                if signal.size == 0:
+                    st.error("No signal data found for this channel.")
+                    continue
+
+                N = len(signal)
+                t = np.arange(N) / fs
+                xf, amp = compute_fft(signal, fs, apply_hann)
+
+                st.markdown(
+                    f"**Channel:** `{ch}`  \n"
+                    f"**Name:** **{label}**  \n"
+                    f"**Samples:** {N}  \n"
+                    f"**fs:** {fs:g} Hz  \n"
+                    f"**Bin Δf:** {fmt_float(xf[1]-xf[0] if len(xf)>1 else float('nan'))} Hz"
+                )
+
+                t_tab, f_tab, key_tab = st.tabs(["Time Domain", "Frequency Domain", "Key Frequencies"])  # improved
+                with t_tab:
+                    fig = go.Figure(go.Scatter(x=t, y=signal, mode="lines", name=label))
+                    fig.update_layout(xaxis_title="Time [s]", yaxis_title=unit or "Amplitude")
+                    st.plotly_chart(fig, use_container_width=True)
+
+                with f_tab:
+                    fig = go.Figure(go.Scatter(x=xf, y=amp, mode="lines", name=label))
+                    if f_fund:
+                        for f_h in np.arange(1, int(harmonics_count) + 1) * (f_fund or 0):
+                            if f_h <= (xf[-1] if len(xf) else 0):
+                                fig.add_vline(x=f_h, line_width=1, line_dash="dash", opacity=0.35)
+                    fig.update_layout(xaxis_title="Frequency [Hz]", yaxis_title="Amplitude")
+                    st.plotly_chart(fig, use_container_width=True)
+
+                # --- Key Frequencies tab ---
+                with key_tab:
+                    if fr is None and ft is None:
+                        st.info("Key Frequencies require 'n' (RPM) and 'z' (number of teeth). Provide these in the JSON.")
+                    else:
+                        # Base spectrum
+                        figkf = go.Figure()
+                        figkf.add_trace(go.Scatter(x=xf, y=amp, mode="lines", name=label, opacity=0.45))
+
+                        rows = []
+                        x_spindle, y_spindle, txt_spindle = [], [], []
+                        x_tpf, y_tpf, txt_tpf = [], [], []
+                        x_sb, y_sb, txt_sb = [], [], []
+
+                        # Helper to maybe annotate
+                        def _maybe_text(a: float, prefix: str) -> str:
+                            if not annotate_amplitudes or not np.isfinite(a) or a < float(annotation_min_amp):
+                                return ""
+                            return f"{prefix}{fmt_float(a, sig=4)}"
+
+                        fmax = xf[-1] if len(xf) else 0
+
+                        # Spindle line & marker
+                        if fr:
+                            bfreq_fr, a_fr = nearest_bin_amplitude(xf, amp, fr)
+                            rows.append({"Type": "Spindle (fr)", "k": 1, "Target f [Hz]": fr, "Bin f [Hz]": bfreq_fr, "Amplitude": a_fr})
+                            if np.isfinite(bfreq_fr) and np.isfinite(a_fr):
+                                figkf.add_vline(x=bfreq_fr, line_width=2, line_dash="dot", opacity=0.7)
+                                x_spindle.append(bfreq_fr); y_spindle.append(a_fr); txt_spindle.append(_maybe_text(a_fr, "A= "))
+
+                        # TPF harmonics and sidebands
+                        if ft:
+                            for k in range(1, int(k_tpf) + 1):
+                                target = k * ft
+                                if target > fmax:
+                                    break
+                                bfreq_k, a_k = nearest_bin_amplitude(xf, amp, target)
+                                rows.append({"Type": "TPF", "k": k, "Target f [Hz]": target, "Bin f [Hz]": bfreq_k, "Amplitude": a_k})
+                                if np.isfinite(bfreq_k):
+                                    figkf.add_vline(x=bfreq_k, line_width=1, line_dash="dash", opacity=0.6)
+                                    x_tpf.append(bfreq_k); y_tpf.append(a_k); txt_tpf.append(_maybe_text(a_k, "A= "))
+                                # multiple sideband orders: ± n·fr
+                                if include_sidebands and fr and int(max_sideband_order) > 0:
+                                    for n_sb in range(1, int(max_sideband_order) + 1):
+                                        f_minus = max(0.0, target - n_sb * fr)
+                                        f_plus = target + n_sb * fr
+                                        if f_minus <= fmax:
+                                            bfreq_m, a_m = nearest_bin_amplitude(xf, amp, f_minus)
+                                            rows.append({"Type": f"Sideband -{n_sb}", "k": k, "Target f [Hz]": f_minus, "Bin f [Hz]": bfreq_m, "Amplitude": a_m})
+                                            if np.isfinite(bfreq_m):
+                                                figkf.add_vline(x=bfreq_m, line_width=1, line_dash="dot", opacity=0.35)
+                                                x_sb.append(bfreq_m); y_sb.append(a_m); txt_sb.append(_maybe_text(a_m, f"A= "))
+                                        if f_plus <= fmax:
+                                            bfreq_p, a_p = nearest_bin_amplitude(xf, amp, f_plus)
+                                            rows.append({"Type": f"Sideband +{n_sb}", "k": k, "Target f [Hz]": f_plus, "Bin f [Hz]": bfreq_p, "Amplitude": a_p})
+                                            if np.isfinite(bfreq_p):
+                                                figkf.add_vline(x=bfreq_p, line_width=1, line_dash="dot", opacity=0.35)
+                                                x_sb.append(bfreq_p); y_sb.append(a_p); txt_sb.append(_maybe_text(a_p, f"A= "))
+
+                        # Add markers with optional labels
+                        if x_spindle:
+                            figkf.add_trace(
+                                go.Scatter(
+                                    x=x_spindle, y=y_spindle, mode="markers+text" if annotate_amplitudes else "markers",
+                                    text=txt_spindle if annotate_amplitudes else None, textposition="top center",
+                                    name="Spindle fr", marker_symbol="diamond", marker_size=10,
+                                )
+                            )
+                        if x_tpf:
+                            figkf.add_trace(
+                                go.Scatter(
+                                    x=x_tpf, y=y_tpf, mode="markers+text" if annotate_amplitudes else "markers",
+                                    text=txt_tpf if annotate_amplitudes else None, textposition="top center",
+                                    name="TPF harmonics k·ft", marker_symbol="x", marker_size=9,
+                                )
+                            )
+                        if x_sb:
+                            figkf.add_trace(
+                                go.Scatter(
+                                    x=x_sb, y=y_sb, mode="markers+text" if annotate_amplitudes else "markers",
+                                    text=txt_sb if annotate_amplitudes else None, textposition="top center",
+                                    name="Sidebands ± n·fr", marker_size=8,
+                                )
+                            )
+
+                        figkf.update_layout(xaxis_title="Frequency [Hz]", yaxis_title=f"Amplitude{(' [' + unit + ']') if unit else ''}")
+                        st.plotly_chart(figkf, use_container_width=True)
+
+                        # Table of key frequencies
+                        if rows:
+                            df_kf = pd.DataFrame(rows)
+                            st.dataframe(df_kf, use_container_width=True)
+                            st.download_button(
+                                label="⬇️ Download Key Frequencies (CSV)",
+                                data=df_kf.to_csv(index=False).encode("utf-8"),
+                                file_name=f"key_frequencies_{slug(label)}.csv",
+                                mime="text/csv",
+                            )
+                        else:
+                            st.caption("No key frequency data available for this channel.")
+else:
+    st.info("Please upload a JSON file to get started.")
+
+# --------------------------------------------------
+# Footer
+# --------------------------------------------------
+st.markdown("<hr>", unsafe_allow_html=True)
+st.caption("© Sagar Sen 2025 — Machine Vibration Analysis App")
+
 
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))