Update pages/1_Simulation.py

pages/1_Simulation.py

@@ -1,74 +1,429 @@
-# pages/1_Simulation.py
-import streamlit as st
-import pandas as pd
-import numpy as np
+st.title("시뮬레이션 실행")
+# app_simulation_multi.py
+# - 직접 입력: 단일 재질/비드
+# - 범위 입력: 다중 재질/다중 비드 → 전체 경우 수 생성 후 규칙/스윕 필터 → MAX_FAILURE & THINNING 동시 예측(Blend)
+from dashboard_theme.theme import inject
+inject("graphite_gold")
+
+import os
+import itertools
+import warnings
+from pathlib import Path
 from datetime import datetime
-from predict_blend import BlendPredictor
+from decimal import Decimal
+from typing import Dict, List, Tuple, Union
+
+import numpy as np
+import pandas as pd
 import streamlit as st
-import base64
 
-st.set_page_config(page_title="시뮬레이션", layout="wide")
+warnings.filterwarnings("ignore", category=FutureWarning)
 
 # 인증 체크
 if "authenticated" not in st.session_state or not st.session_state["authenticated"]:
     st.error("⛔ 접근 불가: 먼저 메인 화면에서 비밀번호를 입력하세요.")
     st.stop()
 
-st.title("시뮬레이션 실행")
-
-# =========================================================
-# 모델 로더
-# =========================================================
-@st.cache_resource(show_spinner=True)
-def get_predictor():
-    return BlendPredictor()
-
-predictor = get_predictor()
-
-# =========================================================
-# 기본값 & 매핑
-# =========================================================
+# =========================================
+# 페이지 설정 & 스타일
+# =========================================
+
+def _set_env_from_secrets(key: str):
+    try:
+        val = st.secrets[key]
+    except Exception:
+        val = None
+    if val:
+        os.environ[key] = str(val)
+
+_set_env_from_secrets("FS_THIN_ART_DIR")
+_set_env_from_secrets("FS_MF_ART_DIR")
+
+# ---- Compact 모드: 전체 여백/패딩 축소 ----
+st.markdown("""
+<style>
+/* 전체 컨테이너 상하 패딩 줄이기 */
+.block-container{padding-top:0.6rem !important; padding-bottom:1.25rem !important;}
+/* 제목/소제목 간격 */
+h1, h2, h3{margin-top:0.4rem !important; margin-bottom:0.6rem !important;}
+/* 패널과 metric 카드 간격/높이 조금 축소 */
+.panel{margin:8px 0 12px !important; padding:16px 16px 12px !important;}
+.metric{min-height:128px !important; padding:18px !important;}
+.metric .value{margin:4px 0 6px !important;}
+/* 구분선 간격 */
+hr, .stDivider{margin:10px 0 !important;}
+/* 섹션 사이 마진 조금씩 줄이기 */
+.stMarkdown, [data-testid="stMarkdownContainer"]{margin:0 !important;}
+/* 캡션-익스팬더 타이트 묶기 */
+.tight-block .stCaption, .tight-block small{margin-top:0 !important; display:block;}
+.tight-block [data-testid="stExpander"] > details{margin-top:6px !important;}
+</style>
+""", unsafe_allow_html=True)
+
+# =========================================
+# 기본값 & 전역 상태
+# =========================================
 DEFAULT_RESULT = {"THINNING": 0.65, "MAX_FAILURE": 1.02}
-
 DISPLAY_LABELS = ["440", "590", "780"]
 DISPLAY_TO_MODEL = {"440": "440.0", "590": "590.0", "780": "780.0"}
-
 MATERIAL_THICKNESS_CAP = {"440": 0.17, "590": 0.16, "780": 0.10}
 
 st.session_state.setdefault("history", [])
 st.session_state.setdefault("input_mode", "직접 입력")
-st.session_state.setdefault("material", "590")
-
-# =========================================================
-# 유틸 함수
-# =========================================================
-def bead_to_flags(bead: str):
-    if bead == "Left Bead":   return 1, 0
-    if bead == "Right Bead":  return 0, 1
-    if bead == "Double Bead": return 1, 1
-    return 0, 0
-
-def calc_thinning(thickness, upperR, lowerR):
-    """THINNING은 단순 산식"""
-    t = float(thickness); ur = float(upperR); lr = float(lowerR)
-    base = 0.18 + (0.9 - t) * 0.25
-    geom = max(0.0, ur - lr) * 0.01
-    thinning = max(0.05, min(0.8, base + geom))
-    return round(thinning, 3)
-
-def build_df(material_display, thickness, diameter, degree, upperR, lowerR, beadType):
-    lb, rb = bead_to_flags(beadType)
-    mat_model = DISPLAY_TO_MODEL[material_display]
-    return pd.DataFrame([{
-        "material": mat_model,
-        "thickness": float(thickness),
-        "diameter": int(diameter),
-        "degree": int(degree),
-        "upper_radius": float(upperR),
-        "lower_radius": float(lowerR),
-        "LB": int(lb),
-        "RB": int(rb),
-    }])
+st.session_state.setdefault("material", "590")  # 직접 입력 기본값
+
+# =========================================
+# 파일 탐색
+# =========================================
+def _find_file(name: str):
+    here = Path(__file__).parent
+    for p in [here / name, here / "assets" / name, Path.cwd() / name, Path("/mnt/data") / name]:
+        if p.exists():
+            return str(p)
+    return ""
+
+# 필요 시 절대경로로 바꿔도 됨
+RULES_XLSX = _find_file("형상별_허용범위정리표.xlsx")
+SWEEP_XLSX = _find_file("직경별_설계변경허용범위.xlsx")
+
+# =========================================
+# 조합 생성 & 필터 유틸
+# =========================================
+def dseq(start: float, stop: float, step: float, q="0.001") -> List[float]:
+    s, e, stp = map(lambda x: Decimal(str(x)), [start, stop, step])
+    vals, cur = [], s
+    while cur <= e + Decimal("1e-12"):
+        vals.append(float(cur.quantize(Decimal(q))))
+        cur += stp
+    return vals
+
+def bead_to_lr(bead_value: Union[str, None]) -> Tuple[int, int]:
+    mapping = {None:(2,2),"none":(0,0),"right":(0,1),"left":(1,0),"double":(1,1)}
+    key = bead_value.lower() if isinstance(bead_value, str) else bead_value
+    return mapping.get(key, (0, 0))
+
+def make_all_combinations(cfg: Dict) -> pd.DataFrame:
+    bead_values = cfg.get("beads") or [None]
+    bead_info = [(b, *bead_to_lr(b)) for b in bead_values]
+
+    materials = cfg["materials"]
+    thickness = dseq(cfg["min_thickness"], cfg["max_thickness"], cfg["thickness_step"])
+    diameter  = [int(x) for x in dseq(cfg["min_diameter"], cfg["max_diameter"], cfg["diameter_step"], q="1")]
+    upper_r   = dseq(cfg["upper_min"], cfg["upper_max"], cfg["upper_step"])
+    lower_r   = dseq(cfg["lower_min"], cfg["lower_max"], cfg["lower_step"])
+    degree    = [int(x) for x in dseq(cfg["min_degree"], cfg["max_degree"], cfg["degree_step"], q="1")]
+
+    grid = itertools.product(materials, thickness, upper_r, lower_r, diameter, degree, bead_info)
+    rows = []
+    for mat, th, ur, lr, dia, deg, bead_t in grid:
+        bead_name, lb, rb = bead_t
+        rows.append((mat, th, ur, lr, dia, deg, bead_name, lb, rb))
+
+    df = pd.DataFrame(
+        rows,
+        columns=["material", "thickness", "upper_radius", "lower_radius",
+                 "diameter", "degree", "bead", "LB", "RB"]
+    )
+    return df
+
+# ----- Sweep 한계 -----
+def build_limit_dicts(df_sweep: pd.DataFrame):
+    t = df_sweep.copy().replace("F", np.nan)
+    if "Sweep" in t.columns:
+        t = t.set_index("Sweep")
+    new_cols = []
+    for c in t.columns:
+        try: new_cols.append(int(c))
+        except: new_cols.append(c)
+    t.columns = new_cols
+    long = t.stack(dropna=False).reset_index()
+    long.columns = ["row", "degree", "limit"]
+    tmp = long["row"].str.extract(r"(?P<diameter>\d+)_(?P<which>upper|lower)_radius")
+    long = pd.concat([long, tmp], axis=1)
+    long["diameter"] = pd.to_numeric(long["diameter"], errors="coerce")
+    long["degree"]   = pd.to_numeric(long["degree"], errors="coerce")
+    long["limit"]    = pd.to_numeric(long["limit"], errors="coerce")
+    upper = long[long["which"]=="upper"].dropna(subset=["diameter","degree"])
+    lower = long[long["which"]=="lower"].dropna(subset=["diameter","degree"])
+    upper_dict = {(int(d), int(g)): v for d, g, v in zip(upper["diameter"], upper["degree"], upper["limit"]) }
+    lower_dict = {(int(d), int(g)): v for d, g, v in zip(lower["diameter"], lower["degree"], lower["limit"]) }
+    return upper_dict, lower_dict
+
+def filter_grid_by_sweep_limits(df_grid: pd.DataFrame, df_sweep: pd.DataFrame) -> pd.DataFrame:
+    upper_dict, lower_dict = build_limit_dicts(df_sweep)
+    key = list(zip(df_grid["diameter"].astype(int), df_grid["degree"].astype(int)))
+    df_grid = df_grid.copy()
+    df_grid["limit_upper"] = [upper_dict.get(k, np.nan) for k in key]
+    df_grid["limit_lower"] = [lower_dict.get(k, np.nan) for k in key]
+    not_nan = df_grid["limit_upper"].notna() & df_grid["limit_lower"].notna()
+    within  = (df_grid["upper_radius"] <= df_grid["limit_upper"]) & \
+              (df_grid["lower_radius"] <= df_grid["limit_lower"])
+    return df_grid[not_nan & within].reset_index(drop=True)
+
+# ----- 규칙 시트 -----
+SHEET_BY_BEAD = {"left":"left", "right":"right", "double":"both", "none":"none"}
+
+def _normalize_input_df(df: pd.DataFrame) -> pd.DataFrame:
+    df2 = df.copy()
+    df2.columns = [str(c).strip() for c in df2.columns]
+    rename = {}
+    for c in df2.columns:
+        lc = c.lower().strip()
+        if lc == "diamater": rename[c] = "diameter"
+        elif lc in ("material","diameter","degree","bead"): rename[c] = lc
+    df2 = df2.rename(columns=rename)
+    need = {"material","diameter","degree","bead"}
+    missing = need - set(df2.columns)
+    if missing:
+        raise ValueError(f"입력 데이터프레임에 필요한 컬럼이 없습니다: {missing}")
+    df2["bead"] = df2["bead"].astype(str).str.strip().str.lower()
+    for c in ["material","diameter","degree"]:
+        df2[c] = pd.to_numeric(df2[c], errors="coerce")
+    return df2.dropna(subset=["material","diameter","degree"]).copy()
+
+def _read_rule_sheet(xlsx_path: str, sheet_name: str) -> pd.DataFrame:
+    rule = pd.read_excel(xlsx_path, sheet_name=sheet_name)
+    rule.columns = rule.columns.str.strip().str.lower()
+    rule = rule.rename(columns={"diamater":"diameter"})
+    need = {"material","diameter","min_degree","max_degree"}
+    missing = need - set(rule.columns)
+    if missing:
+        raise ValueError(f"규칙 시트 '{sheet_name}'에 필요한 컬럼이 없습니다: {missing}")
+    for c in need: rule[c] = pd.to_numeric(rule[c], errors="coerce")
+    rule = rule.dropna(subset=list(need)).copy()
+    rule = rule.astype({"material":"int64","diameter":"int64"})
+    return rule[["material","diameter","min_degree","max_degree"]]
+
+def _apply_rules(df_part: pd.DataFrame, rule: pd.DataFrame) -> pd.DataFrame:
+    if df_part.empty: return df_part.copy()
+    df_part = df_part[df_part["material"].isin(rule["material"].unique())].copy()
+    if df_part.empty: return df_part
+    merged = df_part.merge(rule, on=["material","diameter"], how="left")
+    mask = (
+        merged["min_degree"].notna()
+        & merged["max_degree"].notna()
+        & (merged["degree"] >= merged["min_degree"])
+        & (merged["degree"] <= merged["max_degree"])
+    )
+    return merged.loc[mask, df_part.columns].reset_index(drop=True)
+
+def filter_all_by_bead(df: pd.DataFrame, rules_xlsx: str) -> pd.DataFrame:
+    base = _normalize_input_df(df)
+    outs = []
+    for bead_value, sheet in SHEET_BY_BEAD.items():
+        part = base[base["bead"] == bead_value].copy()
+        if part.empty: continue
+        rule = _read_rule_sheet(rules_xlsx, sheet)
+        outs.append(_apply_rules(part, rule))
+    if not outs: return base.iloc[0:0].copy()
+    return pd.concat(outs, axis=0, ignore_index=True).reset_index(drop=True)
+
+# =========================================
+# 예측기 (두 타깃 동시)
+# =========================================
+import torch
+import torch.nn as nn
+import lightgbm as lgb
+
+ART_DIR_MF_DEFAULT   = "artifacts_blend"
+ART_DIR_THIN_DEFAULT = "artifacts_blend_thinning"
+CAT_COL_DEFAULT = "material"
+NUM_COLS_DEFAULT = ["thickness","diameter","degree","upper_radius","lower_radius","LB","RB"]
+
+class FTTransformer(nn.Module):
+    def __init__(self, n_materials:int, n_num:int, d_model:int=192, nhead:int=8,
+                 num_layers:int=4, dim_ff:int=768, dropout:float=0.15):
+        super().__init__()
+        self.mat_emb = nn.Embedding(n_materials, d_model)
+        self.num_linears = nn.ModuleList([nn.Linear(1, d_model) for _ in range(n_num)])
+        self.cls = nn.Parameter(torch.zeros(1, 1, d_model))
+        nn.init.trunc_normal_(self.cls, std=0.02)
+        enc_layer = nn.TransformerEncoderLayer(
+            d_model=d_model, nhead=nhead, dim_feedforward=dim_ff,
+            dropout=dropout, batch_first=True, activation='gelu', norm_first=True
+        )
+        self.encoder = nn.TransformerEncoder(enc_layer, num_layers=num_layers)
+        self.head = nn.Sequential(nn.LayerNorm(d_model), nn.Linear(d_model, d_model), nn.GELU(), nn.Dropout(dropout), nn.Linear(d_model, 1))
+    def forward(self, mat_ids, x_num):
+        B = x_num.size(0)
+        mat_tok = self.mat_emb(mat_ids).unsqueeze(1)
+        num_tok = torch.cat([lin(x_num[:, i:i+1]).unsqueeze(1) for i, lin in enumerate(self.num_linears)], dim=1)
+        tokens = torch.cat([self.cls.expand(B, -1, -1), mat_tok, num_tok], dim=1)
+        h = self.encoder(tokens)
+        return self.head(h[:, 0, :])
+
+def _scale_like_fold(X_num: np.ndarray, mean: np.ndarray, scale: np.ndarray) -> np.ndarray:
+    return ((X_num - mean) / scale).astype(np.float32)
+
+def _canonize_list(materials): return [str(m).strip() for m in materials]
+def _build_alias2canon(canon_list):
+    alias2canon = {}
+    for c in canon_list:
+        alias2canon[c] = c
+        s = c.strip(); alias2canon[s] = c
+        if "." in s: alias2canon[s.rstrip("0").rstrip(".")] = c
+        try:
+            v = float(s); alias2canon[str(v)] = c
+            if v.is_integer(): alias2canon[str(int(v))] = c
+        except: pass
+    return alias2canon
+def _first_existing(*paths):
+    for p in paths:
+        if os.path.exists(p): return p
+    return None
+def _load_json_like(art_dir: str, basename: str) -> dict:
+    p1 = os.path.join(art_dir, f"{basename}.json"); p2 = os.path.join(art_dir, basename)
+    p = _first_existing(p1, p2)
+    if p is None: raise FileNotFoundError(f"Missing {basename}(.json) in {self.art_dir}")
+    import json;  return json.load(open(p, "r", encoding="utf-8"))
+def _load_columns_meta(art_dir: str):
+    p = _first_existing(os.path.join(art_dir, "columns_thinning.json"), os.path.join(art_dir, "columns.json"))
+    if not p: return None
+    import json;  return json.load(open(p, "r", encoding="utf-8"))
+
+class _SingleTargetBlendPredictor:
+    def __init__(self, art_dir:str, lgbm_prefix:str, ftt_prefix:str, alpha_json:str,
+                 cat_col_default:str=CAT_COL_DEFAULT, num_cols_default:List[str]=None,
+                 allow_columns_meta:bool=False, unknown_policy:str="error"):
+        self.art_dir = art_dir; self.lgbm_prefix=lgbm_prefix; self.ftt_prefix=ftt_prefix
+        self.alpha_json=alpha_json; self.unknown_policy=unknown_policy
+        self.cat_col = cat_col_default; self.num_cols = list(num_cols_default or NUM_COLS_DEFAULT)
+        if allow_columns_meta:
+            meta = _load_columns_meta(art_dir)
+            if meta: self.cat_col = meta.get("cat_col", self.cat_col); self.num_cols = meta.get("num_cols", self.num_cols)
+        self.folds_ft = self._load_ft_folds()
+        self.boosters = self._load_lgbm_folds()
+        self.materials = self._load_materials()
+        self.best_alpha = float(_load_json_like(art_dir, self.alpha_json)["best_alpha"])
+        self.materials_canon = _canonize_list(self.materials)
+        self.alias2canon = _build_alias2canon(self.materials_canon)
+        self.mat2id = {m:i for i,m in enumerate(self.materials_canon)}
+
+    def _load_ft_folds(self):
+        folds=[]
+        for fold in range(1,11):
+            p = os.path.join(self.art_dir, f"{self.ftt_prefix}{fold}.pt")
+            if not os.path.exists(p):
+                if folds: break
+                continue
+            ckpt = torch.load(p, map_location="cpu", weights_only=False)
+            model = FTTransformer(len(ckpt["materials"]), len(ckpt["num_cols"]))
+            model.load_state_dict(ckpt["state_dict"]); model.eval()
+            folds.append({"model":model,"materials":ckpt["materials"],"num_cols":ckpt["num_cols"],
+                          "scaler_mean":np.array(ckpt["scaler_mean"],dtype=np.float32),
+                          "scaler_scale":np.array(ckpt["scaler_scale"],dtype=np.float32)})
+        if not folds: raise FileNotFoundError(f"No FT checkpoints found in {self.art_dir} (prefix={self.ftt_prefix})")
+        return folds
+    def _load_lgbm_folds(self):
+        boosters=[]
+        for fold in range(1,11):
+            p = _first_existing(os.path.join(self.art_dir,f"{self.lgbm_prefix}{fold}.txt"),
+                                os.path.join(self.art_dir,f"{self.lgbm_prefix}{fold}"))
+            if p is None:
+                if boosters: break
+                continue
+            boosters.append(lgb.Booster(model_file=p))
+        if not boosters: raise FileNotFoundError(f"No LightGBM model files found in {self.art_dir} (prefix={self.lgbm_prefix})")
+        return boosters
+    def _load_materials(self):
+        try: return _load_json_like(self.art_dir,"materials")["materials"]
+        except FileNotFoundError: return self.folds_ft[0]["materials"]
+    def _prep_df(self, df_new: pd.DataFrame) -> pd.DataFrame:
+        df = df_new.copy()
+        need = [self.cat_col] + self.num_cols
+        missing = [c for c in need if c not in df.columns]
+        if missing: raise ValueError(f"Missing columns in input: {missing}")
+        df[self.cat_col] = df[self.cat_col].astype(str).str.strip()
+        df["_mat_canon"] = df[self.cat_col].map(self.alias2canon)
+        if self.unknown_policy == "error":
+            unknown = df.loc[df["_mat_canon"].isna(), self.cat_col].unique().tolist()
+            if unknown: raise ValueError(f"Unknown materials in input {unknown}. Known materials: {self.materials_canon[:10]}{' ...' if len(self.materials_canon)>10 else ''}")
+            df["_mat_id"] = df["_mat_canon"].map(self.mat2id).astype(int)
+        else:
+            df["_mat_canon"] = df["_mat_canon"].fillna(self.materials_canon[0])
+            df["_mat_id"] = df["_mat_canon"].map(self.mat2id).astype(int)
+        df[self.num_cols] = df[self.num_cols].apply(pd.to_numeric, errors="coerce")
+        if df[self.num_cols].isnull().any().any():
+            bad = df[self.num_cols].columns[df[self.num_cols].isnull().any()].tolist()
+            raise ValueError(f"Non-numeric values detected in columns: {bad}")
+        return df
+    def predict_ft(self, df_new: pd.DataFrame) -> np.ndarray:
+        df = self._prep_df(df_new); mids = torch.tensor(df["_mat_id"].values, dtype=torch.long)
+        preds=[]
+        for f in self.folds_ft:
+            Xn = df[f["num_cols"]].values.astype(np.float32)
+            x_scaled = _scale_like_fold(Xn, f["scaler_mean"], f["scaler_scale"])
+            with torch.no_grad():
+                p = f["model"](mids, torch.tensor(x_scaled, dtype=torch.float32)).cpu().numpy().ravel()
+            preds.append(p)
+        return np.mean(preds, axis=0)
+    def predict_lgbm(self, df_new: pd.DataFrame) -> np.ndarray:
+        df = self._prep_df(df_new)
+        X = df[[self.cat_col] + self.num_cols].copy()
+        X[self.cat_col] = pd.Categorical(df["_mat_canon"], categories=self.materials_canon)
+        preds = [bst.predict(X, num_iteration=getattr(bst,"best_iteration",None)) for bst in self.boosters]
+        return np.mean(preds, axis=0)
+    def predict_blend(self, df_new: pd.DataFrame, alpha: float|None=None) -> np.ndarray:
+        alpha = self.best_alpha if alpha is None else alpha
+        return alpha * self.predict_ft(df_new) + (1 - alpha) * self.predict_lgbm(df_new)
+
+class MultiTargetBlendPredictor:
+    def __init__(self, art_dir_mf:str, art_dir_thin:str, unknown_policy:str="error"):
+        self.mf = _SingleTargetBlendPredictor(art_dir=art_dir_mf, lgbm_prefix="lgbm_fold", ftt_prefix="ftt_fold",
+                                              alpha_json="blend_alpha", allow_columns_meta=False,
+                                              unknown_policy=unknown_policy)
+        self.thin = _SingleTargetBlendPredictor(art_dir=art_dir_thin, lgbm_prefix="lgbm_thinning_fold",
+                                                ftt_prefix="ftt_thinning_fold", alpha_json="blend_alpha_thinning",
+                                                allow_columns_meta=True, unknown_policy=unknown_policy)
+    def predict_both(self, df_new: pd.DataFrame, alpha_mf: float|None=None, alpha_th: float|None=None):
+        return {
+            "blend_max_failure": self.mf.predict_blend(df_new, alpha_mf),
+            "blend_thinning": self.thin.predict_blend(df_new, alpha_th),
+            "lgbm_max_failure": self.mf.predict_blend(df_new, 0.0),
+            "dl_max_failure":   self.mf.predict_blend(df_new, 1.0),
+            "lgbm_thinning":    self.thin.predict_blend(df_new, 0.0),
+            "dl_thinning":      self.thin.predict_blend(df_new, 1.0),
+        }
+
+@st.cache_resource(show_spinner=False)
+def get_predictor():
+    art_mf = os.environ.get("FS_MF_ART_DIR", ART_DIR_MF_DEFAULT)
+    art_th = os.environ.get("FS_THIN_ART_DIR", ART_DIR_THIN_DEFAULT)
+    return MultiTargetBlendPredictor(art_dir_mf=art_mf, art_dir_thin=art_th, unknown_policy="fallback0")
+
+def predict_both_blend(df: pd.DataFrame):
+    out = get_predictor().predict_both(df)
+    return out["blend_max_failure"], out["blend_thinning"]
+
+# =========================================
+# UI 유틸
+# =========================================
+def bead_to_flags_ui(bead: str):
+    if bead == "Left Bead": return 1,0
+    if bead == "Right Bead": return 0,1
+    if bead == "Double Bead": return 1,1
+    return 0,0
+
+def _bead_key_from_label(label: str) -> str:
+    return {"No Bead":"none","Left Bead":"left","Right Bead":"right","Double Bead":"double"}[label]
+
+# (업그레이드) 아이콘 지원 Metric 카드
+def metric_card(label: str, value: float, lo: float, hi: float, icon: str = "📉"):
+    ok = lo <= float(value) <= hi
+    cls = "ok" if ok else "bad"
+    status_text = "정상" if ok else "범위 밖"
+    st.markdown(
+        f"""
+        <div class="metric {cls}" style="text-align:center;">
+          <div class="label" style="font-weight:600; margin-bottom:6px;">{icon} {label}</div>
+          <div class="value" style="font-size:2rem; font-weight:bold;">{float(value):.3f}</div>
+          <div class="chip" style="margin-top:4px; margin-bottom:4px;">{status_text}</div>
+          <div class="range" style="font-size:0.85rem; color:gray;">허용범위: {lo:.2f} ~ {hi:.2f}</div>
+        </div>
+        """,
+        unsafe_allow_html=True
+    )
+
 
 def val_or_range(single_key, range_key, unit=""):
     mode = st.session_state.get("input_mode", "직접 입력")
@@ -79,207 +434,517 @@ def val_or_range(single_key, range_key, unit=""):
         return f"{st.session_state[single_key]}{unit}"
     return "-"
 
-def frange_inclusive(lo: float, hi: float, step: float):
-    lo = float(lo); hi = float(hi); step = float(step)
-    n = int(round((hi - lo) / step)) + 1
-    return [round(lo + i * step, 10) for i in range(n)]
+def render_cap_table():
+    with st.expander("상한 기준표 보기", expanded=False):
+        st.markdown("""
+        <table style="width:100%; border-collapse: collapse;" border="1">
+            <tr><th>재질(표기)</th><th>모델 라벨</th><th>두께 감소율(허용 상한)</th></tr>
+            <tr><td>440</td><td>440.0</td><td style="color:red">0.17</td></tr>
+            <tr><td>590</td><td>590.0</td><td style="color:red">0.16</td></tr>
+            <tr><td>780</td><td>780.0</td><td style="color:red">0.10</td></tr>
+        </table>
+        """, unsafe_allow_html=True)
+
+def build_df_single(material_display, thickness, diameter, degree, upperR, lowerR, beadType):
+    lb, rb = bead_to_flags_ui(beadType)
+    mat_model = DISPLAY_TO_MODEL[material_display]
+    return pd.DataFrame([{
+        "material": mat_model,
+        "thickness": float(thickness),
+        "diameter": int(diameter),
+        "degree": int(degree),
+        "upper_radius": float(upperR),
+        "lower_radius": float(lowerR),
+        "LB": int(lb), "RB": int(rb),
+    }])
 
-# =========================================================
-# 탭 구성
-# =========================================================
+@st.cache_resource(show_spinner=False)
+def get_sweep_df():
+    return pd.read_excel(SWEEP_XLSX, sheet_name=0) if SWEEP_XLSX else None
+
+@st.cache_resource(show_spinner=False)
+def get_sweep_dicts():
+    df = get_sweep_df()
+    if df is None: return {}, {}
+    return build_limit_dicts(df)
+
+def validate_direct_input(material, diameter, degree, bead_label, upperR, lowerR):
+    if RULES_XLSX:
+        bead_key = _bead_key_from_label(bead_label)
+        rule = _read_rule_sheet(RULES_XLSX, SHEET_BY_BEAD[bead_key])
+        row = rule[(rule["material"] == int(material)) & (rule["diameter"] == int(diameter))]
+        if not row.empty:
+            r = row.iloc[0]; mn, mx = int(r["min_degree"]), int(r["max_degree"])
+            if not (mn <= int(degree) <= mx):
+                return False, f"각도 {degree}°는 규칙 범위({mn}~{mx}°) 밖입니다."
+    else:
+        return True, None
+    upper_dict, lower_dict = get_sweep_dicts()
+    key = (int(diameter), int(degree))
+    u = upper_dict.get(key, np.nan); l = lower_dict.get(key, np.nan)
+    if np.isnan(u) or np.isnan(l): return False, "스윕표에 없는 직경/각도 조합입니다."
+    if float(upperR) > float(u) or float(lowerR) > float(l):
+        return False, f"R 한계 초과: 상단R ≤ {u}, 하단R ≤ {l} 이어야 합니다."
+    return True, None
+
+def _reset_optimum_summary():
+    for k in ["best_filter_thin","best_filter_mf","best_all_thin","best_all_mf"]:
+        st.session_state.pop(k, None)
+    st.session_state.pop("topcard_source", None)
+
+# =========================================
+# 탭 UI
+# =========================================
 tabs = st.tabs(["조건 설정 & 실행", "결과 시각화", "기록 조회"])
 
-# =========================================================
+# -----------------------------------------
 # 1) 조건 설정 & 실행
-# =========================================================
+# -----------------------------------------
 with tabs[0]:
     st.header("조건 설정")
     st.markdown("---")
 
-    col_b1, col_b2 = st.columns(2)
-    with col_b1:
-        st.session_state["beadType"] = st.selectbox(
-            "비드 타입 선택", ["No Bead", "Double Bead", "Left Bead", "Right Bead"]
-        )
-    with col_b2:
-        cur = st.session_state.get("material", "590")
-        idx = DISPLAY_LABELS.index(cur) if cur in DISPLAY_LABELS else 1
-        st.session_state["material"] = st.selectbox("재질", DISPLAY_LABELS, index=idx)
+    st.subheader("입력 모드")
+    st.session_state["input_mode"] = st.radio("입력 방식", ["직접 입력", "범위 값 입력"], horizontal=True, label_visibility="collapsed", key="mode_radio")
+    _prev_mode = st.session_state.get("_prev_input_mode")
+    if _prev_mode is not None and _prev_mode != st.session_state["input_mode"]:
+        _reset_optimum_summary()
+    st.session_state["_prev_input_mode"] = st.session_state["input_mode"]
 
-    st.session_state["input_mode"] = st.radio(
-        "입력 방식", ["직접 입력", "범위 값 입력"], horizontal=True
-    )
+    col_b1, col_b2 = st.columns(2)
+    if st.session_state["input_mode"] == "직접 입력":
+        with col_b1:
+            st.session_state["beadType"] = st.selectbox("비드 타입 선택", ["No Bead","Double Bead","Left Bead","Right Bead"])
+        with col_b2:
+            cur = st.session_state.get("material", "590")
+            idx = DISPLAY_LABELS.index(cur) if cur in DISPLAY_LABELS else 1
+            st.session_state["material"] = st.selectbox("재질", DISPLAY_LABELS, index=idx)
+    else:
+        with col_b1:
+            st.session_state["beadTypes_multi"] = st.multiselect(
+                "비드 타입 선택 (복수 가능)", ["No Bead","Double Bead","Left Bead","Right Bead"],
+                default=["Right Bead"])
+        with col_b2:
+            default_materials = [st.session_state.get("material","590")]
+            st.session_state["materials_multi"] = st.multiselect(
+                "재질 (복수 가능)", DISPLAY_LABELS, default=default_materials)
+
+    st.subheader("성형 조건")
+    st.markdown("<div style='height:6px'></div>", unsafe_allow_html=True)
 
-    # ---------------- 직접 입력 ----------------
     if st.session_state["input_mode"] == "직접 입력":
+        for key in ["diameterRange","degreeRange","upperRRange","lowerRRange","thicknessRange"]:
+            st.session_state.pop(key, None)
+
         col_t, col_d = st.columns(2)
         with col_t:
-            st.session_state["thickness"] = st.selectbox("소재 두께 (mm)", 
-                [0.7,0.8,0.9,1.0,1.1,1.2], index=2)
+            st.session_state["thickness"] = st.selectbox("소재 두께 (mm)", [0.7,0.8,0.9,1.0,1.1,1.2], index=2)
         with col_d:
             st.session_state["diameter"] = st.number_input("직경 (mm)", 10, 1000, 20)
 
         col1, col2 = st.columns(2)
         with col1:
-            st.session_state["upperR"] = st.number_input("상단 R", 1.0, 10.0, 4.0)
+            st.session_state["upperR"] = st.number_input("상단 R", 1, 100, 4)
         with col2:
-            st.session_state["lowerR"] = st.number_input("하단 R", 1.0, 10.0, 3.0)
+            st.session_state["lowerR"] = st.number_input("하단 R", 1, 100, 3)
 
         st.session_state["degree"] = st.number_input("각도 (°)", 0, 90, 75)
 
-        if st.button("시뮬레이션 실행하기", type="primary", use_container_width=True):
-            df = build_df(
-                st.session_state["material"],
-                st.session_state["thickness"],
-                st.session_state["diameter"],
-                st.session_state["degree"],
-                st.session_state["upperR"],
-                st.session_state["lowerR"],
+        if st.button("시뮬레이션 실행하기", use_container_width=True, type="primary"):
+            _reset_optimum_summary()
+            ok, err = validate_direct_input(
+                st.session_state["material"], st.session_state["diameter"], st.session_state["degree"],
+                st.session_state["beadType"], st.session_state["upperR"], st.session_state["lowerR"]
+            )
+            if not ok:
+                st.error(f"규칙 위반: {err}")
+                st.stop()
+
+            df = build_df_single(
+                st.session_state["material"], st.session_state["thickness"], st.session_state["diameter"],
+                st.session_state["degree"], st.session_state["upperR"], st.session_state["lowerR"],
                 st.session_state["beadType"],
             )
             try:
-                mf = float(predictor.predict_blend(df)[0])   # ✅ 모델 예측
+                with st.spinner("모델 예측 중입니다…"):
+                    mf_arr, th_arr = predict_both_blend(df)
+                    mf = float(mf_arr[0]); th = float(th_arr[0])
             except Exception as e:
-                st.error(f"모델 예측 실패: {e}")
-                st.stop()
-            th = calc_thinning(df.loc[0,"thickness"], df.loc[0,"upper_radius"], df.loc[0,"lower_radius"])
+                st.error(f"모델 예측 실패: {e}"); st.stop()
+
             st.session_state.sim_result = {"THINNING": th, "MAX_FAILURE": mf}
-            st.success("✅ 시뮬레이션 완료!")
+            st.session_state.topcard_source = "single"
+            st.success("✅ 시뮬레이션 완료! (Blend 모델 사용)")
 
-    # ---------------- 범위 값 입력 ----------------
     else:
-        st.session_state["thicknessRange"] = st.slider("소재 두께 범위 (mm)", 0.7, 1.2, (0.7, 1.0), step=0.1)
-        st.session_state["diameterRange"]  = st.slider("직경 범위 (mm)", 10, 50, (15, 30))
-        st.session_state["upperRRange"]    = st.slider("상단 R 범위", 1, 10, (3, 7))
-        st.session_state["lowerRRange"]    = st.slider("하단 R 범위", 1, 10, (2, 4))
-        st.session_state["degreeRange"]    = st.slider("각도 범위 (°)", 60, 90, (72, 87))
-
-        if st.button("시뮬레이션 실행하기", type="primary", use_container_width=True):
-            th_vals = frange_inclusive(*st.session_state["thicknessRange"], 0.1)
-            dr_vals = range(st.session_state["diameterRange"][0], st.session_state["diameterRange"][1] + 1)
-            ur_vals = range(st.session_state["upperRRange"][0], st.session_state["upperRRange"][1] + 1)
-            lr_vals = range(st.session_state["lowerRRange"][0], st.session_state["lowerRRange"][1] + 1)
-            dg_vals = range(st.session_state["degreeRange"][0], st.session_state["degreeRange"][1] + 1)
-
-            rows = []
-            mat_disp = st.session_state["material"]
-            bead = st.session_state["beadType"]
-            lb, rb = bead_to_flags(bead)
-            mat_model = DISPLAY_TO_MODEL[mat_disp]
-
-            for t in th_vals:
-                for d in dr_vals:
-                    for ur in ur_vals:
-                        for lr in lr_vals:
-                            for dg in dg_vals:
-                                rows.append({
-                                    "material": mat_model,
-                                    "thickness": float(t),
-                                    "diameter": int(d),
-                                    "degree": int(dg),
-                                    "upper_radius": float(ur),
-                                    "lower_radius": float(lr),
-                                    "LB": int(lb),
-                                    "RB": int(rb),
-                                })
-
-            df_all = pd.DataFrame(rows)
+        for key in ["diameter","degree","upperR","lowerR","thickness"]:
+            st.session_state.pop(key, None)
+
+        col_t, col_d = st.columns(2)
+        with col_t:
+            st.session_state["thicknessRange"] = st.slider("소재 두께 범위 (mm)", 0.7, 1.2, (0.7, 1.0), step=0.1)
+        with col_d:
+            st.session_state["diameterRange"]  = st.slider("직경 범위 (mm)", 10, 50, (15, 30))
+
+        col1, col2 = st.columns(2)
+        with col1:
+            st.session_state["upperRRange"]    = st.slider("상단 R 범위", 1, 15, (3, 7))
+        with col2:
+            st.session_state["lowerRRange"]    = st.slider("하단 R 범위", 1, 10, (2, 4))
+
+        st.session_state["degreeRange"] = st.slider("각도 범위 (°)", 60, 90, (72, 87))
+
+        st.divider()
+        st.subheader("결과 필터 조건 (선택)")
+        st.session_state["apply_post_filter"] = st.checkbox("결과 필터 적용 (THINNING ≤, MAX FAILURE ≤)", value=False)
+
+        selected_mats = st.session_state.get("materials_multi", []) or DISPLAY_LABELS
+        caps = [MATERIAL_THICKNESS_CAP[m] for m in selected_mats]
+        default_thin_cap = float(min(caps)) if len(caps) else 0.16
+
+        f2, f3 = st.columns([1,1])
+        with f2:
+            st.session_state.setdefault("filter_thinning_max", default_thin_cap)
+            st.session_state["filter_thinning_max"] = st.number_input(
+                "THINNING ≤", 0.0, 1.0, float(st.session_state["filter_thinning_max"]),
+                step=0.01, format="%.2f", disabled=not st.session_state["apply_post_filter"]
+            )
+        with f3:
+            st.session_state.setdefault("filter_max_failure_max", 1.0)
+            st.session_state["filter_max_failure_max"] = st.number_input(
+                "MAX FAILURE ≤", 0.0, 2.0, float(st.session_state["filter_max_failure_max"]),
+                step=0.01, format="%.2f", disabled=not st.session_state["apply_post_filter"]
+            )
+
+        if st.button("시뮬레이션 실행하기", use_container_width=True, type="primary"):
+            _reset_optimum_summary()
+
+            bead_keys = [_bead_key_from_label(b) for b in (st.session_state.get("beadTypes_multi") or ["Right Bead"])]
+            mats_disp = st.session_state.get("materials_multi") or DISPLAY_LABELS
+            mats_int = [int(m) for m in mats_disp]
+
+            cfg = {
+                "materials": mats_int,
+                "min_thickness": st.session_state["thicknessRange"][0],
+                "max_thickness": st.session_state["thicknessRange"][1],
+                "thickness_step": 0.1,
+                "min_diameter": st.session_state["diameterRange"][0],
+                "max_diameter": st.session_state["diameterRange"][1],
+                "diameter_step": 1,
+                "upper_min": st.session_state["upperRRange"][0],
+                "upper_max": st.session_state["upperRRange"][1],
+                "upper_step": 1.0,
+                "lower_min": st.session_state["lowerRRange"][0],
+                "lower_max": st.session_state["lowerRRange"][1],
+                "lower_step": 1.0,
+                "min_degree": st.session_state["degreeRange"][0],
+                "max_degree": st.session_state["degreeRange"][1],
+                "degree_step": 1,
+                "beads": bead_keys,
+            }
+            df_all = make_all_combinations(cfg)
+
+            if RULES_XLSX:
+                df_all = filter_all_by_bead(df_all, RULES_XLSX)
+            else:
+                st.warning("규칙 파일을 찾지 못했습니다. (형상별_허용범위정리표.xlsx)")
+            sweep_df = get_sweep_df()
+            if sweep_df is not None and not df_all.empty:
+                df_all = filter_grid_by_sweep_limits(df_all, sweep_df)
+            elif sweep_df is None:
+                st.warning("스윕 한계 파일을 찾지 못했습니다. (직경별_설계변경허용범위.xlsx)")
+
+            if df_all.empty:
+                st.warning("규칙/스윕 한계 적용 후 남는 조합이 없습니다.")
+                st.stop()
+
+            pred_df = df_all.copy()
+            pred_df["material"] = pred_df["material"].astype(int).astype(str).map(DISPLAY_TO_MODEL)
+
             try:
-                mf_pred = predictor.predict_blend(df_all)   # ✅ 모델 예측
+                with st.spinner("모델 예측 중입니다…"):
+                    mf_pred, th_pred = predict_both_blend(pred_df)
             except Exception as e:
-                st.error(f"모델 예측 실패: {e}")
-                st.stop()
+                st.error(f"모델 예측 실패: {e}"); st.stop()
 
-            df_all["THINNING"] = [
-                calc_thinning(r["thickness"], r["upper_radius"], r["lower_radius"])
-                for _, r in df_all.iterrows()
-            ]
+            df_all["THINNING"]    = th_pred
             df_all["MAX_FAILURE"] = mf_pred
 
-            st.session_state.sim_result = {
-                "THINNING": float(df_all["THINNING"].mean()),
-                "MAX_FAILURE": float(df_all["MAX_FAILURE"].mean()),
-            }
-            st.success(f"✅ {len(df_all)}개 조합 실행 완료!")
-
-# =========================================================
+            if st.session_state.get("apply_post_filter", False):
+                thin_thr = float(st.session_state["filter_thinning_max"])
+                mf_thr   = float(st.session_state["filter_max_failure_max"])
+                ok_mask = (df_all["THINNING"] <= thin_thr) & (df_all["MAX_FAILURE"] <= mf_thr)
+                matched = df_all.loc[ok_mask].copy()
+            else:
+                matched = df_all.copy()
+
+            total = len(df_all)
+
+            def _best_rows(df_ok: pd.DataFrame, df_all: pd.DataFrame):
+                best = {"filter_thin": None, "filter_mf": None, "all_thin": None, "all_mf": None}
+                if len(df_ok):
+                    best["filter_thin"] = df_ok.loc[df_ok["THINNING"].idxmin()]
+                    best["filter_mf"]   = df_ok.loc[df_ok["MAX_FAILURE"].idxmin()]
+                best["all_thin"] = df_all.loc[df_all["THINNING"].idxmin()]
+                best["all_mf"]   = df_all.loc[df_all["MAX_FAILURE"].idxmin()]
+                return best
+
+            best = _best_rows(matched if len(matched) else df_all, df_all)
+            st.session_state.best_filter_thin  = None if matched.empty else best["filter_thin"].to_dict()
+            st.session_state.best_filter_mf    = None if matched.empty else best["filter_mf"].to_dict()
+            st.session_state.best_all_thin     = best["all_thin"].to_dict()
+            st.session_state.best_all_mf       = best["all_mf"].to_dict()
+
+            if len(matched) and st.session_state.get("apply_post_filter", False):
+                st.session_state.sim_result = {
+                    "THINNING": float(best["filter_thin"]["THINNING"]),
+                    "MAX_FAILURE": float(best["filter_mf"]["MAX_FAILURE"]),
+                }
+                st.session_state.topcard_source = "filter"
+            else:
+                st.session_state.sim_result = {
+                    "THINNING": float(best["all_thin"]["THINNING"]),
+                    "MAX_FAILURE": float(best["all_mf"]["MAX_FAILURE"]),
+                }
+                st.session_state.topcard_source = "overall"
+
+            if len(matched):
+                now_str = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                matched = matched.copy()
+                matched["선택"]     = False
+                matched["Index"]     = None
+                matched["저장시각"] = now_str
+                matched["재질"] = matched["material"].astype(int).astype(str)
+
+                start_idx = len(st.session_state.history)
+                for i in range(len(matched)):
+                    matched.at[matched.index[i],"Index"] = start_idx + i + 1
+
+                matched = matched[[
+                    "선택","Index","저장시각","bead",
+                    "thickness","재질","diameter","degree","upper_radius","lower_radius",
+                    "THINNING","MAX_FAILURE"
+                ]].rename(columns={
+                    "bead":"비드 타입",
+                    "thickness":"소재 두께 (mm)",
+                    "upper_radius":"상단 R",
+                    "lower_radius":"하단 R",
+                })
+                st.session_state.history.extend(matched.to_dict("records"))
+                if st.session_state.get("apply_post_filter", False):
+                    st.success(f"✅ 총 {total}개 조합 중 **필터를 만족한 {len(matched)}개**를 기록에 추가했습니다.")
+                else:
+                    st.success(f"✅ 필터 미적용: **총 {len(matched)}개 전체 조합**을 기록에 추가했습니다.")
+            else:
+                if st.session_state.get("apply_post_filter", False):
+                    st.warning(f"필터 조건을 만족하는 조합이 없습니다. (총 {total}개 조합)")
+                else:
+                    st.warning("남는 조합이 없습니다.")
+
+# -----------------------------------------
 # 2) 결과 시각화
-# =========================================================
+# -----------------------------------------
 with tabs[1]:
     st.header("결과 시각화")
+
+    # (선택) 이 탭에서 hr/st.divider를 숨기고 싶으면 주석 해제
+    # st.markdown("""
+    # <style>#results-tab hr, #results-tab .stDivider{display:none!important}</style>
+    # <div id="results-tab">""", unsafe_allow_html=True)
+
     result_data = st.session_state.get("sim_result", DEFAULT_RESULT)
+    src = st.session_state.get("topcard_source", "")
+    if src == "filter":   st.caption("카드 값: **필터 내 최적** (THINNING 최소 / MAX FAILURE 최소)")
+    elif src == "overall": st.caption("카드 값: **전체 탐색 최적** (THINNING 최소 / MAX FAILURE 최소)")
+    elif src == "single":  st.caption("카드 값: **단일 입력 결과**")
+
+    col1, col2 = st.columns(2, gap="small")
+    with col1:
+        st.session_state.setdefault("material", "590")
+        cur_mat = st.session_state["material"]
+        thin_cap = MATERIAL_THICKNESS_CAP.get(cur_mat, 0.16)
+        st.session_state["thinning_min"] = 0.0
+        st.session_state["thinning_max"] = thin_cap
+        metric_card("THINNING (두께 감소율)",
+                    result_data.get("THINNING", 0.0),
+                    float(st.session_state["thinning_min"]),
+                    float(st.session_state["thinning_max"]))
+    with col2:
+        st.session_state.setdefault("max_failure_min", 0.00)
+        st.session_state.setdefault("max_failure_max", 0.97)
+        metric_card("MAX FAILURE",
+                    result_data.get("MAX_FAILURE", 0.0),
+                    float(st.session_state["max_failure_min"]),
+                    float(st.session_state["max_failure_max"]))
+
+    cL, cR = st.columns(2, gap="small")
+
+    def _summary_block(title: str, row_thin: pd.Series, row_mf: pd.Series):
+        st.subheader(title)
+        st.markdown("**THINNING 최소**")
+        if row_thin is not None and len(row_thin):
+            lb, rb = int(row_thin.get('LB',0)), int(row_thin.get('RB',0))
+            bead_label = ("No Bead" if (lb==0 and rb==0) else ("Left Bead" if (lb==1 and rb==0)
+                           else ("Right Bead" if (lb==0 and rb==1) else "Double Bead")))
+            st.markdown(
+                f"- 재질: **{row_thin.get('material','-')}** (비드: **{bead_label}**)<br>"
+                f"- 두께: **{row_thin.get('thickness','-')} mm**, 직경: **{row_thin.get('diameter','-')} mm**, 각도: **{row_thin.get('degree','-')}°**<br>"
+                f"- 상단 R: **{row_thin.get('upper_radius','-')}**, 하단 R: **{row_thin.get('lower_radius','-')}**<br>"
+                f"- **THINNING: {row_thin.get('THINNING',0):.3f}**, MAX_FAILURE: {row_thin.get('MAX_FAILURE',0):.3f}",
+                unsafe_allow_html=True)
+        else:
+            st.caption("해당 없음")
+        st.markdown("---")
+        st.markdown("**MAX_FAILURE 최소**")
+        if row_mf is not None and len(row_mf):
+            lb, rb = int(row_mf.get('LB',0)), int(row_mf.get('RB',0))
+            bead_label = ("No Bead" if (lb==0 and rb==0) else ("Left Bead" if (lb==1 and rb==0)
+                           else ("Right Bead" if (lb==0 and rb==1) else "Double Bead")))
+            st.markdown(
+                f"- 재질: **{row_mf.get('material','-')}** (비드: **{bead_label}**)<br>"
+                f"- 두께: **{row_mf.get('thickness','-')} mm**, 직경: **{row_mf.get('diameter','-')} mm**, 각도: **{row_mf.get('degree','-')}°**<br>"
+                f"- 상단 R: **{row_mf.get('upper_radius','-')}**, 하단 R: **{row_mf.get('lower_radius','-')}**<br>"
+                f"- THINNING: {row_mf.get('THINNING',0):.3f}, **MAX_FAILURE: {row_mf.get('MAX_FAILURE',0):.3f}**",
+                unsafe_allow_html=True)
+        else:
+            st.caption("해당 없음")
+
+    with cL:
+        _summary_block(
+            "필터 내 최적",
+            None if st.session_state.get("best_filter_thin") is None else pd.Series(st.session_state["best_filter_thin"]),
+            None if st.session_state.get("best_filter_mf")   is None else pd.Series(st.session_state["best_filter_mf"]),
+        )
+    with cR:
+        _summary_block(
+            "전체 탐색 최적",
+            pd.Series(st.session_state.get("best_all_thin", {})) if st.session_state.get("best_all_thin") else None,
+            pd.Series(st.session_state.get("best_all_mf", {}))   if st.session_state.get("best_all_mf")   else None,
+        )
+
+        # ✅ 기준 재질 & 상한표 — 같은 위치(한 열)에 세로로 정렬
+    with st.container():
+        material_list = DISPLAY_LABELS
+        cur = st.session_state.get("material", "590")
+        default_idx = material_list.index(cur) if cur in material_list else 1
+
+        sel = st.selectbox("기준 재질", material_list, index=default_idx, key="material_for_result")
+        st.session_state["material"] = sel
+
+        cap = MATERIAL_THICKNESS_CAP[sel]
+        st.session_state["thinning_min"] = 0.0
+        st.session_state["thinning_max"] = cap
+        st.caption(f"현재 기준 재질: {sel} (두께 감소율 상한 {cap:.2f})")
 
-    c1, c2 = st.columns(2)
-    with c1:
-        st.metric("THINNING", f"{result_data['THINNING']:.3f}")
-    with c2:
-        st.metric("MAX_FAILURE", f"{result_data['MAX_FAILURE']:.3f}")
+        # 바로 아래에 상한 기준표를 붙여서 표시
+        st.markdown('<div class="tight-block">', unsafe_allow_html=True)
+        st.caption("재질별 두께 감소율 상한")
+        render_cap_table()
+        st.markdown('</div>', unsafe_allow_html=True)
 
-# =========================================================
-# 3) 기록 조회
-# =========================================================
+
+    # (선택) 위에서 열었으면 닫기
+    # st.markdown("</div>", unsafe_allow_html=True)
+
+
+
+# -----------------------------------------
+# 3) 기록 조회  ✅ 전체 교체
+# -----------------------------------------
 with tabs[2]:
     st.header("기록 조회")
 
-    col1, col2, col3, col4 = st.columns([1, 1, 1, 1])
+    col1, col2, col3 = st.columns([1, 1, 1])
     with col1:
         save_btn = st.button("현재 결과 저장", type="primary", use_container_width=True)
     with col2:
         select_all_btn = st.button("전체 선택", use_container_width=True)
     with col3:
         delete_btn = st.button("선택 항목 삭제", use_container_width=True)
-    with col4:
-        export_btn = st.button("CSV 내보내기", use_container_width=True)
 
+    # ===== 현재 결과 저장 처리 =====
     if save_btn:
         if "sim_result" not in st.session_state:
             st.warning("먼저 시뮬레이션을 실행하세요.")
         else:
-            new_entry = {
+            # 다음 인덱스
+            try:
+                next_idx = max([r.get("Index", 0) for r in st.session_state.history]) + 1 if st.session_state.history else 1
+            except Exception:
+                next_idx = len(st.session_state.history) + 1
+
+            # 입력 모드/라벨
+            input_mode = st.session_state.get("input_mode", "직접 입력")
+            if input_mode == "직접 입력":
+                bead_label = st.session_state.get("beadType", "-")
+                material_label = st.session_state.get("material", "-")
+            else:
+                bead_label = ", ".join(st.session_state.get("beadTypes_multi", [])) or "-"
+                material_label = ", ".join(st.session_state.get("materials_multi", [])) or "-"
+
+            # 단일 값도 있으면 함께 저장(표에서 필터/정렬 편하게)
+            diameter_val = st.session_state.get("diameter")
+            degree_val   = st.session_state.get("degree")
+
+            new_row = {
                 "선택": False,
-                "Index": len(st.session_state.history) + 1,
+                "Index": next_idx,
                 "저장시각": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-                "비드 타입": st.session_state.get("beadType", "-"),
-                "입력 방식": st.session_state.get("input_mode", "-"),
+                "비드 타입": bead_label,
+                "입력 방식": input_mode,
                 "소재 두께 (mm)": val_or_range("thickness", "thicknessRange", " mm"),
-                "재질": st.session_state.get("material", "-"),
+                "재질": material_label,
                 "직경": val_or_range("diameter", "diameterRange", " mm"),
                 "각도": val_or_range("degree", "degreeRange", "°"),
                 "상단 R": val_or_range("upperR", "upperRRange"),
                 "하단 R": val_or_range("lowerR", "lowerRRange"),
-                "THINNING": st.session_state.sim_result.get("THINNING"),
-                "MAX_FAILURE": st.session_state.sim_result.get("MAX_FAILURE"),
+                "THINNING": float(st.session_state.sim_result.get("THINNING")),
+                "MAX_FAILURE": float(st.session_state.sim_result.get("MAX_FAILURE")),
+                # 참고용 원시 숫자(없으면 None)
+                "diameter": diameter_val,
+                "degree": degree_val,
             }
-            st.session_state.history.append(new_entry)
-            st.success("현재 결과가 기록에 저장되었습니다.")
 
-    if export_btn:
-        if st.session_state.history:
-            df_export = pd.DataFrame(st.session_state.history)
-            csv = df_export.to_csv(index=False).encode("utf-8-sig")
-            st.download_button("CSV 다운로드", csv, file_name="simulation_history.csv", mime="text/csv")
-        else:
-            st.info("내보낼 기록이 없습니다.")
+            st.session_state.history.append(new_row)
+            # 즉시 반영
+            st.success("현재 결과가 기록에 저장되었습니다.")
+            st.rerun()
 
+    # ===== 테이블/버튼 동작 =====
     if st.session_state.history:
         df = pd.DataFrame(st.session_state.history)
         cols = ["선택"] + [c for c in df.columns if c != "선택"]
         df = df[cols]
 
         if select_all_btn:
-            for row in st.session_state.history:
-                row["선택"] = True
-            df = pd.DataFrame(st.session_state.history)[cols]
+            for r in st.session_state.history:
+                r["선택"] = True
+            st.rerun()
 
         st.subheader(f"기록 테이블 (총 {len(df)}건, 체크 후 삭제 가능)")
-        edited_df = st.data_editor(df, hide_index=True, use_container_width=True)
+        edited_df = st.data_editor(
+            df, hide_index=True, use_container_width=True, key="history_editor"
+        )
 
         if delete_btn:
             selected_index = edited_df[edited_df["선택"] == True]["Index"].tolist()
             st.session_state.history = [
-                rec for rec in st.session_state.history if rec["Index"] not in selected_index
+                rec for rec in st.session_state.history if rec.get("Index") not in selected_index
             ]
             st.success(f"{len(selected_index)}개 항목 삭제 완료!")
             st.rerun()
+
+        # CSV 다운로드(전체/선택)
+        sel_df = edited_df[edited_df["선택"] == True].copy()
+        c1, c2 = st.columns(2)
+        with c1:
+            csv_all = edited_df.to_csv(index=False).encode("utf-8-sig")
+            st.download_button("CSV (전체 다운로드)", csv_all, "simulation_history_all.csv", "text/csv", use_container_width=True)
+        with c2:
+            if len(sel_df):
+                csv_sel = sel_df.to_csv(index=False).encode("utf-8-sig")
+                st.download_button("CSV (선택만 다운로드)", csv_sel, "simulation_history_selected.csv", "text/csv", use_container_width=True)
+            else:
+                st.caption("선택된 행이 없습니다. 표에서 체크 후 다운로드하세요.")
     else:
-        st.info("아직 저장된 기록이 없습니다.")
+        st.info("아직 저장된 기록이 없습니다. 범위 입력으로 실행하면 조건을 만족한 모든 조합이 자동 저장됩니다.")