Upload folder using huggingface_hub

Dockerfile

@@ -0,0 +1,14 @@
+FROM python:3.12-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 7860
+
+HEALTHCHECK CMD curl --fail http://localhost:7860/_stcore/health || exit 1
+
+CMD ["streamlit", "run", "app.py", "--server.port=7860", "--server.address=0.0.0.0", "--server.headless=true"]

README.md

@@ -1,10 +1,34 @@
 ---
-title: Crash Intelligence
-emoji: 🚀
-colorFrom: gray
-colorTo: indigo
+title: Crash Intelligence Platform
+emoji: 🛡️
+colorFrom: green
+colorTo: blue
 sdk: static
 pinned: false
+short_description: AI crash material ranking and CAE card generation
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Crash Intelligence Platform
+
+AI-powered Streamlit application (browser runtime via stlite) for recommending, predicting, and validating automotive crash-performance materials across steel, aluminum, magnesium, composites, polymers, foams, elastomers, and adhesives.
+
+## Features
+
+- **Material Data Layer** — searchable database of crash-relevant mechanical, cost, and sustainability properties
+- **Crash Scenario Intelligence** — frontal, side, rear, pole, pedestrian, battery pack, BIW, and EV underbody scenarios
+- **AI Ranking Engine** — multi-objective ranking for crashworthiness, weight, cost, sustainability, and failure risk
+- **Material Comparison** — radar charts, scatter trade-offs, and family-level benchmarks
+- **CAE Material Card Generator** — draft LS-DYNA / Abaqus / PAM-CRASH / Radioss cards with plastic curves
+- **Validation Workflow** — AI vs CAE vs physical proxies aligned to Euro NCAP / FMVSS / IIHS
+
+## Run locally (full Streamlit server)
+
+```bash
+pip install -r requirements.txt
+python -m utils.data_generator
+streamlit run app.py
+```
+
+## Hugging Face Space
+
+This Space hosts the Streamlit app through a static/stlite runtime so the interactive dashboard is publicly available without paid Docker hardware.

app.py

@@ -0,0 +1,580 @@
+"""Crash Intelligence — AI-powered automotive crash material platform."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pandas as pd
+import plotly.graph_objects as go
+import streamlit as st
+
+from utils.calculations import (
+    available_families,
+    card_to_text,
+    family_summary,
+    generate_material_card,
+    rank_materials,
+    recommend_for_scenario,
+    scenario_kpi,
+)
+from utils.data_generator import (
+    COMPONENTS,
+    CRASH_SCENARIOS,
+    JOINING_METHODS,
+    SOLVERS,
+    generate_all,
+)
+from utils.visualizations import (
+    cost_sustain_bubble,
+    energy_intrusion_scatter,
+    family_bar,
+    kpi_gauge,
+    radar_materials,
+    scatter_crash_vs_weight,
+    scenario_heatmap,
+    stress_strain_curves,
+    top_recommendations_bar,
+    validation_error_hist,
+    validation_parity,
+)
+
+DATA_DIR = Path(__file__).resolve().parent / "data"
+
+st.set_page_config(
+    page_title="Crash Intelligence Platform",
+    page_icon="🛡️",
+    layout="wide",
+    initial_sidebar_state="expanded",
+)
+
+st.markdown(
+    """
+<style>
+@import url('https://fonts.googleapis.com/css2?family=Source+Sans+3:wght@400;600;700&family=IBM+Plex+Sans:wght@500;600&display=swap');
+
+html, body, [class*="css"] {
+  font-family: 'Source Sans 3', 'Segoe UI', sans-serif;
+  color: #0f172a;
+}
+.block-container { padding-top: 1.2rem; padding-bottom: 2rem; max-width: 1400px; }
+h1, h2, h3 { font-family: 'IBM Plex Sans', sans-serif !important; color: #0B3D2E !important; }
+div[data-testid="stMetricValue"] { font-size: 1.6rem; color: #0B6E4F; }
+div[data-testid="stMetricLabel"] { color: #334155; }
+section[data-testid="stSidebar"] {
+  background: linear-gradient(180deg, #0B3D2E 0%, #1B4965 100%);
+}
+section[data-testid="stSidebar"] * { color: #f8fafc !important; }
+section[data-testid="stSidebar"] .stSelectbox label,
+section[data-testid="stSidebar"] .stMultiSelect label,
+section[data-testid="stSidebar"] .stSlider label {
+  color: #e2e8f0 !important;
+}
+.hero {
+  background: linear-gradient(120deg, #0B3D2E 0%, #1B4965 55%, #5FA8D3 100%);
+  color: #ffffff;
+  padding: 1.4rem 1.6rem;
+  border-radius: 12px;
+  margin-bottom: 1rem;
+}
+.hero h1 { color: #ffffff !important; margin: 0 0 0.35rem 0; font-size: 1.9rem; }
+.hero p { color: #e2e8f0; margin: 0; font-size: 1.02rem; }
+.card-box {
+  background: #ffffff;
+  border: 1px solid #e2e8f0;
+  border-left: 4px solid #0B6E4F;
+  border-radius: 8px;
+  padding: 0.9rem 1rem;
+  margin-bottom: 0.6rem;
+  color: #0f172a;
+}
+.stTabs [data-baseweb="tab"] { color: #0f172a; font-weight: 600; }
+.stDataFrame { color: #0f172a; }
+</style>
+""",
+    unsafe_allow_html=True,
+)
+
+
+@st.cache_data(show_spinner="Loading crash material datasets…")
+def load_datasets() -> dict[str, pd.DataFrame]:
+    materials_path = DATA_DIR / "materials.csv"
+    if not materials_path.exists():
+        generate_all(DATA_DIR)
+    return {
+        "materials": pd.read_csv(DATA_DIR / "materials.csv"),
+        "stress_strain": pd.read_csv(DATA_DIR / "stress_strain.csv"),
+        "recommendations": pd.read_csv(DATA_DIR / "recommendations.csv"),
+        "validation": pd.read_csv(DATA_DIR / "validation.csv"),
+    }
+
+
+def render_hero() -> None:
+    st.markdown(
+        """
+        <div class="hero">
+          <h1>Crash Intelligence Platform</h1>
+          <p>
+            AI-powered material recommendation, prediction, and CAE card generation for
+            automotive crash-performance applications across metals, composites, polymers, foams, and adhesives.
+          </p>
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )
+
+
+def main() -> None:
+    data = load_datasets()
+    materials = data["materials"]
+    stress = data["stress_strain"]
+    recommendations = data["recommendations"]
+    validation = data["validation"]
+
+    render_hero()
+
+    families = available_families()
+    with st.sidebar:
+        st.markdown("### Filters & Targets")
+        selected_families = st.multiselect(
+            "Material families",
+            options=families,
+            default=families[:8],
+        )
+        scenario = st.selectbox("Crash scenario", CRASH_SCENARIOS, index=0)
+        component = st.selectbox("Vehicle component", COMPONENTS, index=8)
+        max_cost = st.slider("Max cost (USD/kg)", 1.0, 80.0, 40.0, 1.0)
+        min_uts = st.slider("Min UTS (MPa)", 20, 1800, 200, 20)
+        max_density = st.slider("Max density (g/cm³)", 0.1, 8.0, 8.0, 0.1)
+        st.markdown("---")
+        st.markdown("### Multi-objective weights")
+        w_crash = st.slider("Crash performance", 0.0, 1.0, 0.30, 0.05)
+        w_weight = st.slider("Lightweighting", 0.0, 1.0, 0.20, 0.05)
+        w_cost = st.slider("Cost performance", 0.0, 1.0, 0.20, 0.05)
+        w_sust = st.slider("Sustainability", 0.0, 1.0, 0.15, 0.05)
+        w_fail = st.slider("Low failure risk", 0.0, 1.0, 0.15, 0.05)
+        weights = {
+            "crash": w_crash,
+            "weight": w_weight,
+            "cost": w_cost,
+            "sustainability": w_sust,
+            "failure": w_fail,
+        }
+        st.markdown("---")
+        st.caption(
+            f"Database: {len(materials):,} materials · "
+            f"{len(recommendations):,} scenario predictions · "
+            f"{len(validation):,} validation pairs"
+        )
+
+    filt = materials[materials["family"].isin(selected_families)].copy()
+    if filt.empty:
+        st.warning("No materials match the selected families. Expand the family filter.")
+        return
+
+    filt = filt[
+        (filt["cost_usd_kg"] <= max_cost)
+        & (filt["uts_mpa"] >= min_uts)
+        & (filt["density_g_cm3"] <= max_density)
+    ]
+    if filt.empty:
+        st.warning("No materials match the current property filters. Relax cost / UTS / density limits.")
+        return
+
+    rec_filt = recommendations[recommendations["family"].isin(selected_families)]
+
+    ranked = rank_materials(
+        filt,
+        families=selected_families,
+        max_cost=max_cost,
+        min_uts=min_uts,
+        max_density=max_density,
+        weights=weights,
+        top_n=8,
+    )
+
+    tabs = st.tabs(
+        [
+            "Overview",
+            "Material Explorer",
+            "Crash Scenario AI",
+            "Compare & Rank",
+            "Material Cards",
+            "Validation",
+            "Data Library",
+        ]
+    )
+
+    # --- Overview ---
+    with tabs[0]:
+        st.subheader("Platform KPIs")
+        c1, c2, c3, c4, c5 = st.columns(5)
+        c1.metric("Materials", f"{len(filt):,}")
+        c2.metric("Avg Crash Index", f"{filt['crashworthiness_index'].mean():.1f}")
+        c3.metric("Avg Energy Potential", f"{filt['energy_absorption_potential'].mean():.2f}")
+        c4.metric("Avg Sustainability", f"{filt['sustainability_score'].mean():.1f}")
+        c5.metric("AI–CAE Pass Rate", f"{(validation['pass_fail']=='Pass').mean()*100:.0f}%")
+
+        g1, g2, g3 = st.columns(3)
+        with g1:
+            st.plotly_chart(
+                kpi_gauge(float(filt["crashworthiness_index"].mean()), "Crashworthiness", "#0B6E4F"),
+                use_container_width=True,
+            )
+        with g2:
+            st.plotly_chart(
+                kpi_gauge(float(filt["lightweighting_score"].mean()), "Lightweighting", "#1B4965"),
+                use_container_width=True,
+            )
+        with g3:
+            st.plotly_chart(
+                kpi_gauge(float(filt["sustainability_score"].mean()), "Sustainability", "#2A9D8F"),
+                use_container_width=True,
+            )
+
+        st.markdown("#### Family performance & trade-offs")
+        summary = family_summary(filt)
+        r1, r2 = st.columns(2)
+        with r1:
+            st.plotly_chart(
+                family_bar(summary, "crashworthiness_index", "Crashworthiness by Family"),
+                use_container_width=True,
+            )
+        with r2:
+            st.plotly_chart(scatter_crash_vs_weight(filt), use_container_width=True)
+
+        st.plotly_chart(scenario_heatmap(rec_filt), use_container_width=True)
+
+        st.markdown(
+            """
+            <div class="card-box">
+              <strong>Value proposition:</strong> Shortlist safer, lighter, cheaper, and more sustainable
+              crash-critical materials before expensive CAE and physical testing — then export draft
+              solver-ready material cards for LS-DYNA, Abaqus, PAM-CRASH, and Radioss.
+            </div>
+            """,
+            unsafe_allow_html=True,
+        )
+
+    # --- Material Explorer ---
+    with tabs[1]:
+        st.subheader("Material Data Explorer")
+        st.markdown(
+            "Browse standardized mechanical, cost, and sustainability properties across automotive crash materials."
+        )
+        m1, m2 = st.columns(2)
+        with m1:
+            st.plotly_chart(
+                family_bar(summary, "energy_absorption_potential", "Energy Absorption Potential"),
+                use_container_width=True,
+            )
+        with m2:
+            st.plotly_chart(cost_sustain_bubble(filt), use_container_width=True)
+
+        curve_options = (
+            stress[stress["family"].isin(selected_families)][["material_id", "material_name", "family"]]
+            .drop_duplicates()
+            .head(80)
+        )
+        if not curve_options.empty:
+            pick = st.multiselect(
+                "Select materials for stress–strain curves",
+                options=curve_options["material_id"].tolist(),
+                default=curve_options["material_id"].tolist()[:3],
+                format_func=lambda mid: (
+                    f"{curve_options.loc[curve_options.material_id==mid, 'material_name'].iloc[0]} "
+                    f"({curve_options.loc[curve_options.material_id==mid, 'family'].iloc[0]})"
+                ),
+            )
+            if pick:
+                st.plotly_chart(stress_strain_curves(stress, pick), use_container_width=True)
+
+        st.dataframe(
+            filt[
+                [
+                    "material_name",
+                    "family",
+                    "density_g_cm3",
+                    "youngs_modulus_gpa",
+                    "yield_strength_mpa",
+                    "uts_mpa",
+                    "elongation_pct",
+                    "failure_strain",
+                    "cost_usd_kg",
+                    "co2_kg_kg",
+                    "crashworthiness_index",
+                    "sustainability_score",
+                    "source",
+                    "confidence_score",
+                ]
+            ].sort_values("crashworthiness_index", ascending=False),
+            use_container_width=True,
+            height=360,
+        )
+
+    # --- Crash Scenario AI ---
+    with tabs[2]:
+        st.subheader("Crash Scenario Intelligence")
+        st.markdown(
+            f"Recommendations for **{scenario}** on **{component}** using multi-objective AI ranking."
+        )
+        top_rec = recommend_for_scenario(
+            filt,
+            rec_filt,
+            scenario=scenario,
+            component=component,
+            families=selected_families,
+            top_n=5,
+        )
+        if top_rec.empty:
+            st.info("No recommendations available for this combination.")
+        else:
+            k1, k2, k3, k4 = st.columns(4)
+            k1.metric("Top Crash Score", f"{top_rec['crash_score'].iloc[0]:.1f}")
+            k2.metric(
+                "Best Weight Reduction",
+                f"{top_rec.get('weight_reduction_pct', pd.Series([0])).iloc[0]:.1f}%",
+            )
+            k3.metric("Top Material", str(top_rec["material_name"].iloc[0]))
+            k4.metric("Family", str(top_rec["family"].iloc[0]))
+
+            st.plotly_chart(top_recommendations_bar(top_rec), use_container_width=True)
+            c_a, c_b = st.columns(2)
+            with c_a:
+                st.plotly_chart(energy_intrusion_scatter(rec_filt), use_container_width=True)
+            with c_b:
+                sk = scenario_kpi(rec_filt)
+                st.plotly_chart(
+                    family_bar(
+                        sk.rename(columns={"crash_scenario": "family", "avg_crash_score": "crashworthiness_index"}),
+                        "crashworthiness_index",
+                        "Average Crash Score by Scenario",
+                    ),
+                    use_container_width=True,
+                )
+
+            st.markdown("#### Top 5 recommendations")
+            display_cols = [
+                c
+                for c in [
+                    "material_name",
+                    "family",
+                    "thickness_mm",
+                    "joining_method",
+                    "crash_score",
+                    "energy_absorption_kj",
+                    "intrusion_mm",
+                    "peak_force_kn",
+                    "crush_force_efficiency",
+                    "weight_reduction_pct",
+                    "cost_score",
+                    "sustainability_score",
+                    "simulation_risk",
+                ]
+                if c in top_rec.columns
+            ]
+            st.dataframe(top_rec[display_cols], use_container_width=True)
+
+            st.markdown("#### Suggested next steps")
+            best = top_rec.iloc[0]
+            join = best.get("joining_method", JOINING_METHODS[0])
+            thick = best.get("thickness_mm", 2.0)
+            st.markdown(
+                f"""
+                <div class="card-box">
+                  <strong>Recommended action:</strong> Evaluate <em>{best['material_name']}</em>
+                  ({best['family']}) at ~{thick} mm with <em>{join}</em> joining.
+                  Expected crash score {best['crash_score']:.1f}.
+                  Run component-level {scenario.lower()} CAE before physical validation.
+                </div>
+                """,
+                unsafe_allow_html=True,
+            )
+
+    # --- Compare & Rank ---
+    with tabs[3]:
+        st.subheader("Material Comparison & Ranking")
+        if ranked.empty:
+            st.info("No ranked materials under current constraints.")
+        else:
+            st.plotly_chart(radar_materials(ranked), use_container_width=True)
+            left, right = st.columns(2)
+            with left:
+                st.plotly_chart(
+                    family_bar(
+                        ranked.rename(columns={"material_name": "family", "mo_score": "crashworthiness_index"})[
+                            ["family", "crashworthiness_index"]
+                        ],
+                        "crashworthiness_index",
+                        "Multi-Objective Score (Top Materials)",
+                    ),
+                    use_container_width=True,
+                )
+            with right:
+                st.dataframe(
+                    ranked[
+                        [
+                            "material_name",
+                            "family",
+                            "mo_score",
+                            "crashworthiness_index",
+                            "lightweighting_score",
+                            "cost_performance_score",
+                            "sustainability_score",
+                            "failure_risk",
+                            "uts_mpa",
+                            "density_g_cm3",
+                            "cost_usd_kg",
+                        ]
+                    ],
+                    use_container_width=True,
+                    height=420,
+                )
+
+    # --- Material Cards ---
+    with tabs[4]:
+        st.subheader("CAE Material Card Generator")
+        st.markdown(
+            "Generate draft solver-ready material cards including elastic modulus, yield, "
+            "plastic curve, strain-rate sensitivity, failure strain, and confidence score."
+        )
+        card_mat_name = st.selectbox(
+            "Select material",
+            options=ranked["material_name"].tolist() if not ranked.empty else filt["material_name"].head(50).tolist(),
+        )
+        solver = st.selectbox("Target solver", SOLVERS)
+        mat_row = filt[filt["material_name"] == card_mat_name]
+        if mat_row.empty and not ranked.empty:
+            mat_row = ranked[ranked["material_name"] == card_mat_name]
+        if mat_row.empty:
+            mat_row = materials[materials["material_name"] == card_mat_name]
+
+        if not mat_row.empty:
+            material = mat_row.iloc[0]
+            card = generate_material_card(material, solver=solver)
+            text = card_to_text(card)
+
+            mc1, mc2, mc3, mc4 = st.columns(4)
+            mc1.metric("Card Type", card["card_type"].split()[0])
+            mc2.metric("Yield (MPa)", f"{card['yield_strength_mpa']:.0f}")
+            mc3.metric("Failure Strain", f"{card['failure_strain']:.3f}")
+            mc4.metric("Confidence", f"{card['confidence_score']:.2f}")
+
+            col_l, col_r = st.columns([1.1, 0.9])
+            with col_l:
+                st.code(text, language="text")
+                st.download_button(
+                    "Download material card",
+                    data=text,
+                    file_name=f"{material['material_name']}_{solver.replace(' ', '_')}.k",
+                    mime="text/plain",
+                )
+            with col_r:
+                curve_id = material["material_id"] if "material_id" in material.index else None
+                if curve_id and curve_id in stress["material_id"].values:
+                    st.plotly_chart(
+                        stress_strain_curves(stress, [curve_id]),
+                        use_container_width=True,
+                    )
+                else:
+                    fig = go.Figure()
+                    fig.add_trace(
+                        go.Scatter(
+                            x=card["plastic_curve_strain"],
+                            y=card["plastic_curve_stress_mpa"],
+                            mode="lines+markers",
+                            line=dict(color="#0B6E4F", width=3),
+                            name="Plastic curve",
+                        )
+                    )
+                    fig.update_layout(
+                        title="Draft Plastic Curve",
+                        xaxis_title="Plastic Strain",
+                        yaxis_title="Stress (MPa)",
+                        height=400,
+                        paper_bgcolor="white",
+                        plot_bgcolor="#f8fafc",
+                        font=dict(color="#1a1a1a"),
+                    )
+                    st.plotly_chart(fig, use_container_width=True)
+
+                st.markdown(
+                    f"""
+                    <div class="card-box">
+                      <strong>Validation status:</strong> {card['validation_status']}<br/>
+                      <strong>Damage model:</strong> {card['damage_evolution']}<br/>
+                      <strong>Temperature:</strong> {card['temperature_dependency']}
+                    </div>
+                    """,
+                    unsafe_allow_html=True,
+                )
+
+    # --- Validation ---
+    with tabs[5]:
+        st.subheader("Validation Workflow")
+        st.markdown(
+            "Compare AI predictions with CAE and physical crash proxies aligned to Euro NCAP / FMVSS / IIHS."
+        )
+        val = validation[validation["family"].isin(selected_families)]
+        v1, v2, v3, v4 = st.columns(4)
+        v1.metric("Validation pairs", f"{len(val):,}")
+        v2.metric("Mean AI–CAE error", f"{val['ai_cae_error_pct'].mean():.1f}%")
+        v3.metric("Pass rate", f"{(val['pass_fail']=='Pass').mean()*100:.0f}%")
+        v4.metric("Mean NHTSA-star proxy", f"{val['nhtsa_star_proxy'].mean():.1f}")
+
+        vc1, vc2 = st.columns(2)
+        with vc1:
+            st.plotly_chart(validation_parity(val), use_container_width=True)
+        with vc2:
+            st.plotly_chart(validation_error_hist(val), use_container_width=True)
+
+        st.markdown("#### Validation ladder")
+        levels = [
+            ("Coupon tests", "Tensile, compression, shear, strain-rate, fracture"),
+            ("Component tests", "Bumper beam, crash box, rail, door beam, battery enclosure"),
+            ("CAE validation", "Compare AI prediction with LS-DYNA / Abaqus / PAM-CRASH"),
+            ("Physical crash", "Compare simulation with crash-test measurements"),
+            ("Certification", "Euro NCAP, FMVSS, IIHS, OEM internal standards"),
+        ]
+        for title, desc in levels:
+            st.markdown(
+                f'<div class="card-box"><strong>{title}:</strong> {desc}</div>',
+                unsafe_allow_html=True,
+            )
+
+        st.dataframe(
+            val.sort_values("ai_cae_error_pct").head(200),
+            use_container_width=True,
+            height=320,
+        )
+
+    # --- Data Library ---
+    with tabs[6]:
+        st.subheader("Data Library & Export")
+        st.markdown(
+            "Public-style material and crash datasets used by the ranking and card-generation engines."
+        )
+        dataset_choice = st.selectbox(
+            "Dataset",
+            ["materials", "recommendations", "validation", "stress_strain"],
+        )
+        export_df = data[dataset_choice]
+        if dataset_choice != "stress_strain":
+            if "family" in export_df.columns:
+                export_df = export_df[export_df["family"].isin(selected_families)]
+        st.dataframe(export_df.head(500), use_container_width=True, height=400)
+        st.download_button(
+            f"Download {dataset_choice}.csv",
+            data=export_df.to_csv(index=False),
+            file_name=f"{dataset_choice}.csv",
+            mime="text/csv",
+        )
+
+    st.markdown("---")
+    st.caption(
+        "Crash Intelligence Platform · Prototype powered by public-style material & crash databases · "
+        "For OEM production use, calibrate with supplier cards, high strain-rate tests, and full-vehicle CAE."
+    )
+
+
+if __name__ == "__main__":
+    main()

index.html

@@ -1 +1,67 @@
-<html><body><h1>Crash Intelligence</h1></body></html>
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Crash Intelligence Platform</title>
+    <link
+      rel="stylesheet"
+      href="https://cdn.jsdelivr.net/npm/@stlite/browser@0.80.5/build/stlite.css"
+    />
+    <style>
+      html, body, #root {
+        margin: 0;
+        padding: 0;
+        width: 100%;
+        height: 100%;
+        background: #ffffff;
+        color: #0f172a;
+      }
+      .boot {
+        font-family: "Source Sans 3", "Segoe UI", sans-serif;
+        color: #0B3D2E;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        height: 100%;
+        font-size: 1.1rem;
+      }
+    </style>
+    <script type="module">
+      import { mount } from "https://cdn.jsdelivr.net/npm/@stlite/browser@0.80.5/build/stlite.js";
+
+      const root = document.getElementById("root");
+      root.innerHTML = '<div class="boot">Loading Crash Intelligence Platform…</div>';
+
+      mount(
+        {
+          entrypoint: "app.py",
+          requirements: ["pandas", "numpy", "plotly"],
+          streamlitConfig: {
+            "client.toolbarMode": "minimal",
+            "theme.base": "light",
+            "theme.primaryColor": "#0B6E4F",
+            "theme.backgroundColor": "#ffffff",
+            "theme.secondaryBackgroundColor": "#f8fafc",
+            "theme.textColor": "#0f172a",
+          },
+          files: {
+            "app.py": { url: "./app.py" },
+            "utils/__init__.py": { url: "./utils/__init__.py" },
+            "utils/data_generator.py": { url: "./utils/data_generator.py" },
+            "utils/calculations.py": { url: "./utils/calculations.py" },
+            "utils/visualizations.py": { url: "./utils/visualizations.py" },
+            "data/materials.csv": { url: "./data/materials.csv" },
+            "data/recommendations.csv": { url: "./data/recommendations.csv" },
+            "data/stress_strain.csv": { url: "./data/stress_strain.csv" },
+            "data/validation.csv": { url: "./data/validation.csv" },
+          },
+        },
+        root
+      );
+    </script>
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

requirements.txt

@@ -0,0 +1,4 @@
+streamlit==1.45.0
+pandas==2.2.3
+numpy==1.26.4
+plotly==5.24.1

utils/__init__.py

@@ -0,0 +1 @@
+"""Crash Intelligence platform utilities."""

utils/calculations.py

@@ -0,0 +1,215 @@
+"""Domain calculations for crash material intelligence."""
+
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+
+from utils.data_generator import MATERIAL_CARD_MAP, MATERIAL_FAMILIES
+
+
+WEIGHTS_DEFAULT = {
+    "crash": 0.30,
+    "weight": 0.20,
+    "cost": 0.20,
+    "sustainability": 0.15,
+    "failure": 0.15,
+}
+
+
+def multi_objective_score(
+    df: pd.DataFrame,
+    weights: dict[str, float] | None = None,
+) -> pd.Series:
+    """Compute weighted multi-objective ranking score."""
+    w = weights or WEIGHTS_DEFAULT
+    total = sum(w.values()) or 1.0
+    w = {k: v / total for k, v in w.items()}
+    score = (
+        w["crash"] * df["crashworthiness_index"]
+        + w["weight"] * df["lightweighting_score"]
+        + w["cost"] * np.clip(df["cost_performance_score"] * 1.2, 0, 100)
+        + w["sustainability"] * df["sustainability_score"]
+        + w["failure"] * (100 * (1.0 - df["failure_risk"]))
+    )
+    return score.round(2)
+
+
+def rank_materials(
+    materials: pd.DataFrame,
+    families: list[str] | None = None,
+    max_cost: float | None = None,
+    min_uts: float | None = None,
+    max_density: float | None = None,
+    weights: dict[str, float] | None = None,
+    top_n: int = 5,
+) -> pd.DataFrame:
+    """Filter and rank materials for crash applications."""
+    df = materials.copy()
+    if families:
+        df = df[df["family"].isin(families)]
+    if max_cost is not None:
+        df = df[df["cost_usd_kg"] <= max_cost]
+    if min_uts is not None:
+        df = df[df["uts_mpa"] >= min_uts]
+    if max_density is not None:
+        df = df[df["density_g_cm3"] <= max_density]
+    if df.empty:
+        return df
+    df = df.copy()
+    df["mo_score"] = multi_objective_score(df, weights)
+    return df.sort_values("mo_score", ascending=False).head(top_n)
+
+
+def recommend_for_scenario(
+    materials: pd.DataFrame,
+    recommendations: pd.DataFrame,
+    scenario: str,
+    component: str,
+    families: list[str] | None = None,
+    top_n: int = 5,
+) -> pd.DataFrame:
+    """Recommend materials for a crash scenario + component pair."""
+    rec = recommendations[
+        (recommendations["crash_scenario"] == scenario)
+        & (recommendations["component"] == component)
+    ].copy()
+    if families:
+        rec = rec[rec["family"].isin(families)]
+    if rec.empty:
+        ranked = rank_materials(materials, families=families, top_n=top_n)
+        ranked = ranked.copy()
+        ranked["crash_scenario"] = scenario
+        ranked["component"] = component
+        ranked["crash_score"] = ranked["crashworthiness_index"]
+        ranked["thickness_mm"] = 2.0
+        ranked["joining_method"] = "Hybrid Weld-Bond"
+        ranked["simulation_risk"] = (ranked["failure_risk"] * 100).round(2)
+        return ranked
+
+    agg_cols = [
+        "crash_score",
+        "energy_absorption_kj",
+        "intrusion_mm",
+        "peak_force_kn",
+        "crush_force_efficiency",
+        "specific_energy_absorption",
+        "weight_reduction_pct",
+        "cost_score",
+        "sustainability_score",
+        "lightweighting_score",
+        "simulation_risk",
+        "thickness_mm",
+    ]
+    grouped = (
+        rec.groupby(["material_id", "material_name", "family", "joining_method"], as_index=False)[
+            agg_cols
+        ]
+        .mean(numeric_only=True)
+        .sort_values("crash_score", ascending=False)
+        .head(top_n)
+    )
+    return grouped
+
+
+def generate_material_card(material: pd.Series, solver: str = "LS-DYNA") -> dict:
+    """Build a draft CAE-ready material card payload."""
+    family = material["family"]
+    card_type = MATERIAL_CARD_MAP.get(family, "MAT_024")
+    curve_pts = 10
+    strains = np.linspace(0.0, float(material["failure_strain"]), curve_pts)
+    ys = float(material["yield_strength_mpa"])
+    uts = float(material["uts_mpa"])
+    stresses = []
+    for eps in strains:
+        if eps <= 0:
+            stresses.append(ys)
+        else:
+            t = min(eps / max(material["failure_strain"], 1e-6), 1.0)
+            stresses.append(ys + (uts - ys) * t)
+
+    card = {
+        "solver": solver,
+        "card_type": card_type,
+        "material_name": material["material_name"],
+        "family": family,
+        "density_g_cm3": float(material["density_g_cm3"]),
+        "youngs_modulus_gpa": float(material["youngs_modulus_gpa"]),
+        "poisson_ratio": 0.30 if "Aluminum" in family or family == "Magnesium" else 0.29,
+        "yield_strength_mpa": ys,
+        "uts_mpa": uts,
+        "failure_strain": float(material["failure_strain"]),
+        "strain_rate_sensitivity": float(material["strain_rate_sensitivity"]),
+        "plastic_curve_strain": [round(float(s), 5) for s in strains],
+        "plastic_curve_stress_mpa": [round(float(s), 2) for s in stresses],
+        "damage_evolution": "Linear softening to zero stress at failure strain",
+        "temperature_dependency": "Room-temperature card; scale factors TBD",
+        "validation_status": "Draft — public-data prototype",
+        "confidence_score": float(material["confidence_score"]),
+    }
+    return card
+
+
+def card_to_text(card: dict) -> str:
+    """Serialize a material card to a readable text block."""
+    lines = [
+        f"*KEYWORD  ({card['solver']} draft)",
+        f"$ Material: {card['material_name']} ({card['family']})",
+        f"$ Card type: {card['card_type']}",
+        f"$ Confidence: {card['confidence_score']:.2f}",
+        f"$ Validation: {card['validation_status']}",
+        "*MAT_PIECEWISE_LINEAR_PLASTICITY",
+        f"$ RO (g/cm3) = {card['density_g_cm3']}",
+        f"$ E (GPa) = {card['youngs_modulus_gpa']}",
+        f"$ PR = {card['poisson_ratio']}",
+        f"$ SIGY (MPa) = {card['yield_strength_mpa']}",
+        f"$ FAIL = {card['failure_strain']}",
+        f"$ C (strain-rate) = {card['strain_rate_sensitivity']}",
+        "$ Plastic curve (strain, stress MPa):",
+    ]
+    for eps, sig in zip(card["plastic_curve_strain"], card["plastic_curve_stress_mpa"]):
+        lines.append(f"$   {eps:.5f}, {sig:.2f}")
+    lines.append(f"$ Damage: {card['damage_evolution']}")
+    lines.append(f"$ Temperature: {card['temperature_dependency']}")
+    lines.append("*END")
+    return "\n".join(lines)
+
+
+def family_summary(materials: pd.DataFrame) -> pd.DataFrame:
+    """Aggregate key metrics by material family."""
+    cols = [
+        "density_g_cm3",
+        "uts_mpa",
+        "crashworthiness_index",
+        "energy_absorption_potential",
+        "cost_usd_kg",
+        "sustainability_score",
+        "lightweighting_score",
+        "failure_risk",
+    ]
+    return (
+        materials.groupby("family")[cols]
+        .mean(numeric_only=True)
+        .reset_index()
+        .sort_values("crashworthiness_index", ascending=False)
+    )
+
+
+def scenario_kpi(recommendations: pd.DataFrame) -> pd.DataFrame:
+    """KPI rollup by crash scenario."""
+    return (
+        recommendations.groupby("crash_scenario")
+        .agg(
+            avg_crash_score=("crash_score", "mean"),
+            avg_energy=("energy_absorption_kj", "mean"),
+            avg_intrusion=("intrusion_mm", "mean"),
+            avg_weight_reduction=("weight_reduction_pct", "mean"),
+            n_cases=("rec_id", "count"),
+        )
+        .reset_index()
+        .sort_values("avg_crash_score", ascending=False)
+    )
+
+
+def available_families() -> list[str]:
+    return list(MATERIAL_FAMILIES.keys())

utils/data_generator.py

@@ -0,0 +1,535 @@
+"""Synthetic public-style material and crash datasets for the Crash Intelligence platform."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+RNG = np.random.default_rng(42)
+
+MATERIAL_FAMILIES = {
+    "Mild Steel": {
+        "grades": ["AISI 1008", "AISI 1010", "DC04", "DC06", "St14"],
+        "density": (7.80, 7.87),
+        "modulus": (200, 210),
+        "yield": (140, 280),
+        "uts": (270, 420),
+        "elongation": (25, 45),
+        "failure_strain": (0.25, 0.55),
+        "cost": (0.6, 1.2),
+        "co2": (1.8, 2.5),
+        "recyclability": (0.85, 0.98),
+        "strain_rate_sens": (0.01, 0.04),
+    },
+    "AHSS": {
+        "grades": ["DP600", "DP800", "DP1000", "TRIP780", "CP800", "MS1200"],
+        "density": (7.80, 7.85),
+        "modulus": (200, 210),
+        "yield": (350, 900),
+        "uts": (600, 1200),
+        "elongation": (8, 25),
+        "failure_strain": (0.08, 0.22),
+        "cost": (1.0, 2.2),
+        "co2": (2.0, 2.8),
+        "recyclability": (0.80, 0.95),
+        "strain_rate_sens": (0.02, 0.06),
+    },
+    "UHSS": {
+        "grades": ["MS1500", "MS1700", "PHS1500", "PHS1800", "QP980", "QP1180"],
+        "density": (7.80, 7.85),
+        "modulus": (200, 210),
+        "yield": (900, 1500),
+        "uts": (1200, 2000),
+        "elongation": (4, 12),
+        "failure_strain": (0.04, 0.12),
+        "cost": (1.8, 3.5),
+        "co2": (2.2, 3.2),
+        "recyclability": (0.75, 0.92),
+        "strain_rate_sens": (0.015, 0.05),
+    },
+    "Boron Steel": {
+        "grades": ["22MnB5", "30MnB5", "Usibor 1500", "Usibor 2000", "Ductibor 500"],
+        "density": (7.80, 7.85),
+        "modulus": (200, 210),
+        "yield": (1000, 1400),
+        "uts": (1400, 2000),
+        "elongation": (5, 10),
+        "failure_strain": (0.05, 0.10),
+        "cost": (2.0, 3.8),
+        "co2": (2.3, 3.4),
+        "recyclability": (0.78, 0.93),
+        "strain_rate_sens": (0.02, 0.045),
+    },
+    "Aluminum 5xxx": {
+        "grades": ["AA5052", "AA5083", "AA5182", "AA5754", "AA5454"],
+        "density": (2.66, 2.70),
+        "modulus": (68, 72),
+        "yield": (90, 220),
+        "uts": (190, 320),
+        "elongation": (12, 30),
+        "failure_strain": (0.15, 0.35),
+        "cost": (2.5, 4.0),
+        "co2": (8.0, 12.0),
+        "recyclability": (0.90, 0.98),
+        "strain_rate_sens": (0.01, 0.03),
+    },
+    "Aluminum 6xxx": {
+        "grades": ["AA6005", "AA6061", "AA6063", "AA6082", "AA6111"],
+        "density": (2.68, 2.71),
+        "modulus": (68, 72),
+        "yield": (150, 280),
+        "uts": (220, 340),
+        "elongation": (8, 18),
+        "failure_strain": (0.10, 0.22),
+        "cost": (2.8, 4.5),
+        "co2": (8.5, 13.0),
+        "recyclability": (0.90, 0.98),
+        "strain_rate_sens": (0.01, 0.035),
+    },
+    "Aluminum 7xxx": {
+        "grades": ["AA7003", "AA7020", "AA7075", "AA7050", "AA7085"],
+        "density": (2.78, 2.82),
+        "modulus": (70, 73),
+        "yield": (300, 500),
+        "uts": (400, 580),
+        "elongation": (5, 12),
+        "failure_strain": (0.06, 0.14),
+        "cost": (4.0, 7.0),
+        "co2": (10.0, 16.0),
+        "recyclability": (0.85, 0.95),
+        "strain_rate_sens": (0.008, 0.025),
+    },
+    "Magnesium": {
+        "grades": ["AZ31B", "AZ61", "AZ91", "AM60", "ZK60"],
+        "density": (1.74, 1.82),
+        "modulus": (42, 48),
+        "yield": (120, 220),
+        "uts": (200, 320),
+        "elongation": (8, 18),
+        "failure_strain": (0.08, 0.20),
+        "cost": (4.5, 8.0),
+        "co2": (15.0, 25.0),
+        "recyclability": (0.70, 0.90),
+        "strain_rate_sens": (0.02, 0.05),
+    },
+    "CFRP": {
+        "grades": ["T700/Epoxy", "T800/Epoxy", "IM7/PEEK", "M55J/Epoxy", "AS4/Epoxy"],
+        "density": (1.50, 1.65),
+        "modulus": (70, 150),
+        "yield": (600, 1200),
+        "uts": (800, 1800),
+        "elongation": (1.2, 2.5),
+        "failure_strain": (0.012, 0.025),
+        "cost": (25, 80),
+        "co2": (20, 45),
+        "recyclability": (0.20, 0.45),
+        "strain_rate_sens": (0.005, 0.02),
+    },
+    "GFRP": {
+        "grades": ["E-Glass/Epoxy", "S-Glass/Epoxy", "E-Glass/PP", "E-Glass/PA6", "SMC"],
+        "density": (1.80, 2.10),
+        "modulus": (20, 45),
+        "yield": (200, 450),
+        "uts": (300, 700),
+        "elongation": (1.5, 4.0),
+        "failure_strain": (0.015, 0.04),
+        "cost": (5, 18),
+        "co2": (4, 12),
+        "recyclability": (0.25, 0.50),
+        "strain_rate_sens": (0.01, 0.03),
+    },
+    "Natural Fiber Composite": {
+        "grades": ["Flax/PP", "Hemp/PLA", "Jute/Epoxy", "Kenaf/PP", "Bamboo/Epoxy"],
+        "density": (1.20, 1.50),
+        "modulus": (8, 25),
+        "yield": (60, 150),
+        "uts": (80, 200),
+        "elongation": (2, 6),
+        "failure_strain": (0.02, 0.06),
+        "cost": (3, 10),
+        "co2": (0.5, 3.0),
+        "recyclability": (0.50, 0.80),
+        "strain_rate_sens": (0.015, 0.04),
+    },
+    "Polymer": {
+        "grades": ["PP-GF30", "PA6-GF35", "ABS", "PC/ABS", "PBT-GF30", "TPU"],
+        "density": (0.95, 1.45),
+        "modulus": (1.5, 12),
+        "yield": (25, 120),
+        "uts": (30, 160),
+        "elongation": (5, 80),
+        "failure_strain": (0.05, 1.5),
+        "cost": (1.5, 6.0),
+        "co2": (2.0, 6.5),
+        "recyclability": (0.40, 0.85),
+        "strain_rate_sens": (0.03, 0.10),
+    },
+    "Elastomer": {
+        "grades": ["EPDM", "NR", "SBR", "NBR", "Silicone"],
+        "density": (0.90, 1.25),
+        "modulus": (0.005, 0.05),
+        "yield": (2, 15),
+        "uts": (5, 30),
+        "elongation": (200, 600),
+        "failure_strain": (2.0, 6.0),
+        "cost": (2.0, 8.0),
+        "co2": (2.5, 7.0),
+        "recyclability": (0.15, 0.40),
+        "strain_rate_sens": (0.05, 0.15),
+    },
+    "Structural Foam": {
+        "grades": ["EPS", "EPP", "PUR Foam", "Al Honeycomb", "PET Foam"],
+        "density": (0.03, 0.25),
+        "modulus": (0.01, 2.0),
+        "yield": (0.2, 8),
+        "uts": (0.3, 12),
+        "elongation": (5, 80),
+        "failure_strain": (0.4, 2.0),
+        "cost": (1.0, 15.0),
+        "co2": (1.5, 8.0),
+        "recyclability": (0.20, 0.70),
+        "strain_rate_sens": (0.04, 0.12),
+    },
+    "Adhesive": {
+        "grades": ["Epoxy Structural", "PU Crash", "Acrylic", "MS Polymer", "Toughened Epoxy"],
+        "density": (1.05, 1.40),
+        "modulus": (0.5, 4.0),
+        "yield": (10, 45),
+        "uts": (15, 60),
+        "elongation": (5, 100),
+        "failure_strain": (0.05, 1.2),
+        "cost": (8, 35),
+        "co2": (3.0, 10.0),
+        "recyclability": (0.05, 0.25),
+        "strain_rate_sens": (0.02, 0.08),
+    },
+}
+
+COMPONENTS = [
+    "Bumper Beam",
+    "Crash Box",
+    "Front Rail",
+    "Door Intrusion Beam",
+    "B-Pillar",
+    "A-Pillar",
+    "Roof Rail",
+    "Seat Structure",
+    "Battery Enclosure",
+    "Underbody Shield",
+    "Hood Inner",
+    "Crossmember",
+]
+
+CRASH_SCENARIOS = [
+    "Frontal Crash",
+    "Side Impact",
+    "Rear Impact",
+    "Pole Impact",
+    "Pedestrian Impact",
+    "Battery Pack Crash",
+    "Bumper Beam Crash",
+    "Door Intrusion",
+    "Seat Structure Crash",
+    "BIW Crash",
+    "EV Underbody Protection",
+]
+
+JOINING_METHODS = [
+    "Spot Weld",
+    "Laser Weld",
+    "MIG Weld",
+    "SPR (Self-Piercing Rivet)",
+    "Structural Adhesive",
+    "Hybrid Weld-Bond",
+    "Bolt Fastened",
+    "FDS (Flow Drill Screw)",
+]
+
+SOLVERS = ["LS-DYNA", "Abaqus Explicit", "PAM-CRASH", "Radioss"]
+
+MATERIAL_CARD_MAP = {
+    "Mild Steel": "MAT_024",
+    "AHSS": "MAT_024",
+    "UHSS": "MAT_024",
+    "Boron Steel": "MAT_024",
+    "Aluminum 5xxx": "MAT_024",
+    "Aluminum 6xxx": "MAT_024",
+    "Aluminum 7xxx": "MAT_024",
+    "Magnesium": "MAT_024",
+    "CFRP": "MAT_054 / Composite Damage",
+    "GFRP": "MAT_054 / Composite Damage",
+    "Natural Fiber Composite": "MAT_054 / Composite Damage",
+    "Polymer": "MAT_187 / SAMP-1",
+    "Elastomer": "MAT_077 / Hyperelastic",
+    "Structural Foam": "MAT_063 / Crushable Foam",
+    "Adhesive": "MAT_240 / Cohesive Zone",
+}
+
+
+def _sample_range(bounds: tuple[float, float], n: int) -> np.ndarray:
+    lo, hi = bounds
+    return RNG.uniform(lo, hi, n)
+
+
+def generate_materials(n_records: int = 6000) -> pd.DataFrame:
+    """Generate a large public-style automotive crash materials database."""
+    families = list(MATERIAL_FAMILIES.keys())
+    rows: list[dict] = []
+
+    per_family = max(1, n_records // len(families))
+    for family in families:
+        spec = MATERIAL_FAMILIES[family]
+        n = per_family
+        grades = spec["grades"]
+        for i in range(n):
+            grade = grades[i % len(grades)]
+            density = float(_sample_range(spec["density"], 1)[0])
+            modulus = float(_sample_range(spec["modulus"], 1)[0])
+            yield_s = float(_sample_range(spec["yield"], 1)[0])
+            uts = float(_sample_range(spec["uts"], 1)[0])
+            if uts < yield_s:
+                uts = yield_s * RNG.uniform(1.05, 1.35)
+            elong = float(_sample_range(spec["elongation"], 1)[0])
+            fail = float(_sample_range(spec["failure_strain"], 1)[0])
+            cost = float(_sample_range(spec["cost"], 1)[0])
+            co2 = float(_sample_range(spec["co2"], 1)[0])
+            recycl = float(_sample_range(spec["recyclability"], 1)[0])
+            srs = float(_sample_range(spec["strain_rate_sens"], 1)[0])
+
+            specific_strength = uts / density
+            specific_stiffness = modulus / density
+            energy_abs_potential = 0.5 * (yield_s + uts) * fail / density
+            ductility_index = elong / max(uts / 100.0, 1e-6)
+            crash_index = (
+                0.35 * (energy_abs_potential / 50.0)
+                + 0.25 * (specific_strength / 200.0)
+                + 0.20 * min(fail * 5.0, 1.0)
+                + 0.20 * (1.0 / (1.0 + cost / 10.0))
+            )
+            crash_index = float(np.clip(crash_index * 100, 5, 98))
+            strength_weight = specific_strength
+            failure_risk = float(np.clip(1.0 - fail * 2.5 + srs * 2.0, 0.05, 0.95))
+            cost_perf = float(np.clip(crash_index / (cost + 0.5), 1, 80))
+            sustain = float(
+                np.clip(
+                    100 * recycl * (1.0 / (1.0 + co2 / 10.0)) * (1.0 / (1.0 + density / 5.0)),
+                    5,
+                    98,
+                )
+            )
+            lightweight = float(np.clip(100 * (1.0 - density / 8.0) * (specific_strength / 300.0), 5, 98))
+
+            rows.append(
+                {
+                    "material_id": f"{family[:3].upper()}-{i:04d}",
+                    "material_name": f"{grade}-{i % 100:02d}",
+                    "family": family,
+                    "grade": grade,
+                    "density_g_cm3": round(density, 3),
+                    "youngs_modulus_gpa": round(modulus, 2),
+                    "yield_strength_mpa": round(yield_s, 1),
+                    "uts_mpa": round(uts, 1),
+                    "elongation_pct": round(elong, 2),
+                    "failure_strain": round(fail, 4),
+                    "strain_rate_sensitivity": round(srs, 4),
+                    "cost_usd_kg": round(cost, 2),
+                    "co2_kg_kg": round(co2, 2),
+                    "recyclability": round(recycl, 3),
+                    "specific_strength": round(specific_strength, 2),
+                    "specific_stiffness": round(specific_stiffness, 2),
+                    "energy_absorption_potential": round(energy_abs_potential, 3),
+                    "ductility_index": round(ductility_index, 3),
+                    "crashworthiness_index": round(crash_index, 2),
+                    "strength_to_weight": round(strength_weight, 2),
+                    "failure_risk": round(failure_risk, 3),
+                    "cost_performance_score": round(cost_perf, 2),
+                    "sustainability_score": round(sustain, 2),
+                    "lightweighting_score": round(lightweight, 2),
+                    "material_card_type": MATERIAL_CARD_MAP[family],
+                    "confidence_score": round(float(RNG.uniform(0.55, 0.97)), 3),
+                    "source": RNG.choice(
+                        ["MatWeb", "NIST MDR", "Literature", "CAE Benchmark", "Public Dataset"]
+                    ),
+                }
+            )
+
+    df = pd.DataFrame(rows)
+    return df.sample(frac=1.0, random_state=42).reset_index(drop=True)
+
+
+def generate_stress_strain(materials: pd.DataFrame, n_curves: int = 400) -> pd.DataFrame:
+    """Generate plastic stress–strain curves for a subset of materials."""
+    sample = materials.sample(n=min(n_curves, len(materials)), random_state=7)
+    curve_rows: list[dict] = []
+    strains = np.linspace(0, 0.25, 40)
+
+    for _, mat in sample.iterrows():
+        e = mat["youngs_modulus_gpa"] * 1000  # MPa
+        ys = mat["yield_strength_mpa"]
+        uts = mat["uts_mpa"]
+        n_hard = RNG.uniform(0.08, 0.28)
+        for eps in strains:
+            if eps * e < ys:
+                stress = eps * e
+            else:
+                plastic = max(eps - ys / e, 0)
+                stress = ys + (uts - ys) * (1 - np.exp(-plastic / n_hard))
+                stress = min(stress, uts * 1.05)
+            rate_factor = 1.0 + mat["strain_rate_sensitivity"] * np.log1p(100)
+            curve_rows.append(
+                {
+                    "material_id": mat["material_id"],
+                    "material_name": mat["material_name"],
+                    "family": mat["family"],
+                    "strain": round(float(eps), 5),
+                    "stress_mpa": round(float(stress * rate_factor / rate_factor), 2),
+                    "stress_high_rate_mpa": round(float(stress * rate_factor), 2),
+                }
+            )
+    return pd.DataFrame(curve_rows)
+
+
+def generate_recommendations(materials: pd.DataFrame, n: int = 3000) -> pd.DataFrame:
+    """Generate crash-scenario recommendation / prediction records."""
+    rows: list[dict] = []
+    sample = materials.sample(n=min(n, len(materials) * 2), replace=True, random_state=11)
+
+    for i, (_, mat) in enumerate(sample.iterrows()):
+        scenario = CRASH_SCENARIOS[i % len(CRASH_SCENARIOS)]
+        component = COMPONENTS[i % len(COMPONENTS)]
+        thickness = float(RNG.uniform(0.8, 3.5))
+        joining = JOINING_METHODS[i % len(JOINING_METHODS)]
+
+        base = mat["crashworthiness_index"]
+        thickness_factor = np.clip(thickness / 2.0, 0.5, 1.6)
+        energy = float(base * thickness_factor * RNG.uniform(0.85, 1.15))
+        intrusion = float(np.clip(80 - base * 0.5 - thickness * 8 + RNG.normal(0, 5), 5, 120))
+        peak_force = float(mat["uts_mpa"] * thickness * 0.015 * RNG.uniform(0.8, 1.2))
+        cfe = float(np.clip(0.45 + base / 300 + RNG.normal(0, 0.05), 0.3, 0.95))
+        sea = float(mat["energy_absorption_potential"] * thickness_factor * RNG.uniform(0.9, 1.1))
+        crash_score = float(
+            np.clip(
+                0.3 * energy
+                + 0.2 * (100 - intrusion)
+                + 0.15 * cfe * 100
+                + 0.15 * mat["lightweighting_score"]
+                + 0.1 * mat["cost_performance_score"]
+                + 0.1 * mat["sustainability_score"],
+                10,
+                98,
+            )
+        )
+        weight_reduction = float(
+            np.clip((3.0 - mat["density_g_cm3"]) / 3.0 * 40 + RNG.normal(0, 3), -5, 55)
+        )
+        sim_risk = float(np.clip(mat["failure_risk"] * 100 + RNG.normal(0, 5), 5, 95))
+
+        rows.append(
+            {
+                "rec_id": f"REC-{i:05d}",
+                "material_id": mat["material_id"],
+                "material_name": mat["material_name"],
+                "family": mat["family"],
+                "component": component,
+                "crash_scenario": scenario,
+                "thickness_mm": round(thickness, 2),
+                "joining_method": joining,
+                "energy_absorption_kj": round(energy, 2),
+                "intrusion_mm": round(intrusion, 2),
+                "peak_force_kn": round(peak_force, 2),
+                "crush_force_efficiency": round(cfe, 3),
+                "specific_energy_absorption": round(sea, 3),
+                "crash_score": round(crash_score, 2),
+                "weight_reduction_pct": round(weight_reduction, 2),
+                "cost_score": round(mat["cost_performance_score"], 2),
+                "sustainability_score": round(mat["sustainability_score"], 2),
+                "lightweighting_score": round(mat["lightweighting_score"], 2),
+                "simulation_risk": round(sim_risk, 2),
+                "failure_risk": round(mat["failure_risk"], 3),
+                "solver": SOLVERS[i % len(SOLVERS)],
+                "validation_level": RNG.choice(
+                    [
+                        "Coupon Test",
+                        "Component Test",
+                        "CAE Validation",
+                        "Physical Crash",
+                        "Certification Align",
+                    ]
+                ),
+                "required_test": RNG.choice(
+                    [
+                        "Tensile + Strain-Rate",
+                        "3-Point Bend",
+                        "Drop Tower",
+                        "Component Crush",
+                        "Side Pole Sled",
+                        "Full-Vehicle Barrier",
+                    ]
+                ),
+            }
+        )
+    return pd.DataFrame(rows)
+
+
+def generate_validation(recommendations: pd.DataFrame, n: int = 1500) -> pd.DataFrame:
+    """Generate AI vs CAE / NHTSA-style validation comparison records."""
+    sample = recommendations.sample(n=min(n, len(recommendations)), random_state=21)
+    rows: list[dict] = []
+    for i, (_, rec) in enumerate(sample.iterrows()):
+        ai = rec["crash_score"]
+        noise = RNG.normal(0, 4)
+        cae = float(np.clip(ai + noise, 5, 100))
+        physical = float(np.clip(cae + RNG.normal(0, 3), 5, 100))
+        error_ai_cae = abs(ai - cae) / max(cae, 1e-6) * 100
+        error_cae_phys = abs(cae - physical) / max(physical, 1e-6) * 100
+        rows.append(
+            {
+                "val_id": f"VAL-{i:04d}",
+                "rec_id": rec["rec_id"],
+                "material_name": rec["material_name"],
+                "family": rec["family"],
+                "component": rec["component"],
+                "crash_scenario": rec["crash_scenario"],
+                "ai_crash_score": round(ai, 2),
+                "cae_crash_score": round(cae, 2),
+                "physical_crash_score": round(physical, 2),
+                "ai_cae_error_pct": round(error_ai_cae, 2),
+                "cae_physical_error_pct": round(error_cae_phys, 2),
+                "nhtsa_star_proxy": int(np.clip(round(physical / 20), 1, 5)),
+                "standard": RNG.choice(["Euro NCAP", "FMVSS", "IIHS", "OEM Internal"]),
+                "pass_fail": "Pass" if error_ai_cae < 12 else "Review",
+            }
+        )
+    return pd.DataFrame(rows)
+
+
+def generate_all(data_dir: Path | str) -> dict[str, pd.DataFrame]:
+    """Generate and persist all datasets."""
+    data_dir = Path(data_dir)
+    data_dir.mkdir(parents=True, exist_ok=True)
+
+    materials = generate_materials(6000)
+    stress = generate_stress_strain(materials, 400)
+    recommendations = generate_recommendations(materials, 3500)
+    validation = generate_validation(recommendations, 1800)
+
+    materials.to_csv(data_dir / "materials.csv", index=False)
+    stress.to_csv(data_dir / "stress_strain.csv", index=False)
+    recommendations.to_csv(data_dir / "recommendations.csv", index=False)
+    validation.to_csv(data_dir / "validation.csv", index=False)
+
+    return {
+        "materials": materials,
+        "stress_strain": stress,
+        "recommendations": recommendations,
+        "validation": validation,
+    }
+
+
+if __name__ == "__main__":
+    out = Path(__file__).resolve().parent.parent / "data"
+    datasets = generate_all(out)
+    for name, df in datasets.items():
+        print(f"{name}: {len(df)} rows")

utils/visualizations.py

@@ -0,0 +1,284 @@
+"""Plotly visualization helpers for Crash Intelligence."""
+
+from __future__ import annotations
+
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+
+COLOR_SEQUENCE = [
+    "#0B6E4F",
+    "#08A045",
+    "#1B4965",
+    "#5FA8D3",
+    "#C44536",
+    "#E8871E",
+    "#6B4C9A",
+    "#2A9D8F",
+    "#E76F51",
+    "#264653",
+    "#F4A261",
+    "#457B9D",
+    "#9B2226",
+    "#005F73",
+    "#CA6702",
+]
+
+LAYOUT_DEFAULTS = dict(
+    paper_bgcolor="rgba(255,255,255,1)",
+    plot_bgcolor="rgba(248,250,252,1)",
+    font=dict(family="Source Sans 3, Segoe UI, sans-serif", color="#1a1a1a", size=13),
+    margin=dict(l=50, r=30, t=50, b=50),
+    legend=dict(bgcolor="rgba(255,255,255,0.9)", bordercolor="#ddd", borderwidth=1),
+)
+
+
+def _apply_layout(fig: go.Figure, title: str, height: int = 420) -> go.Figure:
+    fig.update_layout(title=title, height=height, **LAYOUT_DEFAULTS)
+    fig.update_xaxes(showgrid=True, gridcolor="#e5e7eb", zeroline=False)
+    fig.update_yaxes(showgrid=True, gridcolor="#e5e7eb", zeroline=False)
+    return fig
+
+
+def family_bar(summary: pd.DataFrame, metric: str, title: str) -> go.Figure:
+    fig = px.bar(
+        summary.sort_values(metric, ascending=True),
+        x=metric,
+        y="family",
+        orientation="h",
+        color=metric,
+        color_continuous_scale=["#D8F3DC", "#0B6E4F"],
+        labels={"family": "Material Family", metric: metric.replace("_", " ").title()},
+    )
+    return _apply_layout(fig, title, height=480)
+
+
+def scatter_crash_vs_weight(materials: pd.DataFrame) -> go.Figure:
+    fig = px.scatter(
+        materials.sample(n=min(2000, len(materials)), random_state=3),
+        x="lightweighting_score",
+        y="crashworthiness_index",
+        color="family",
+        size="uts_mpa",
+        hover_data=["material_name", "cost_usd_kg", "sustainability_score"],
+        color_discrete_sequence=COLOR_SEQUENCE,
+        labels={
+            "lightweighting_score": "Lightweighting Score",
+            "crashworthiness_index": "Crashworthiness Index",
+        },
+    )
+    return _apply_layout(fig, "Crashworthiness vs Lightweighting", height=480)
+
+
+def radar_materials(top: pd.DataFrame) -> go.Figure:
+    categories = [
+        "crashworthiness_index",
+        "lightweighting_score",
+        "cost_performance_score",
+        "sustainability_score",
+        "energy_absorption_potential",
+    ]
+    labels = ["Crash", "Weight", "Cost-Perf", "Sustainability", "Energy Abs."]
+    fig = go.Figure()
+    for i, (_, row) in enumerate(top.head(5).iterrows()):
+        values = []
+        for c in categories:
+            v = float(row[c])
+            if c == "energy_absorption_potential":
+                v = min(v * 2.0, 100)
+            if c == "cost_performance_score":
+                v = min(v * 1.5, 100)
+            values.append(v)
+        values.append(values[0])
+        fig.add_trace(
+            go.Scatterpolar(
+                r=values,
+                theta=labels + [labels[0]],
+                name=str(row.get("material_name", row.get("family", f"M{i}"))),
+                line=dict(color=COLOR_SEQUENCE[i % len(COLOR_SEQUENCE)], width=2),
+                fill="toself",
+                opacity=0.55,
+            )
+        )
+    fig.update_layout(
+        polar=dict(
+            bgcolor="#f8fafc",
+            radialaxis=dict(visible=True, range=[0, 100], gridcolor="#e5e7eb"),
+            angularaxis=dict(gridcolor="#e5e7eb"),
+        ),
+        title="Multi-Objective Material Comparison",
+        height=480,
+        **{k: v for k, v in LAYOUT_DEFAULTS.items() if k != "margin"},
+        margin=dict(l=60, r=60, t=50, b=40),
+    )
+    return fig
+
+
+def stress_strain_curves(curves: pd.DataFrame, material_ids: list[str]) -> go.Figure:
+    fig = go.Figure()
+    subset = curves[curves["material_id"].isin(material_ids)]
+    for i, mid in enumerate(material_ids):
+        mdf = subset[subset["material_id"] == mid]
+        if mdf.empty:
+            continue
+        name = mdf["material_name"].iloc[0]
+        fig.add_trace(
+            go.Scatter(
+                x=mdf["strain"],
+                y=mdf["stress_mpa"],
+                mode="lines",
+                name=f"{name} (quasi-static)",
+                line=dict(color=COLOR_SEQUENCE[i % len(COLOR_SEQUENCE)], width=2.5),
+            )
+        )
+        fig.add_trace(
+            go.Scatter(
+                x=mdf["strain"],
+                y=mdf["stress_high_rate_mpa"],
+                mode="lines",
+                name=f"{name} (high-rate)",
+                line=dict(
+                    color=COLOR_SEQUENCE[i % len(COLOR_SEQUENCE)],
+                    width=2,
+                    dash="dash",
+                ),
+            )
+        )
+    fig.update_layout(
+        xaxis_title="True Strain",
+        yaxis_title="True Stress (MPa)",
+    )
+    return _apply_layout(fig, "Stress–Strain Curves (Strain-Rate Sensitive)", height=460)
+
+
+def scenario_heatmap(recommendations: pd.DataFrame) -> go.Figure:
+    pivot = (
+        recommendations.groupby(["crash_scenario", "family"])["crash_score"]
+        .mean()
+        .reset_index()
+        .pivot(index="crash_scenario", columns="family", values="crash_score")
+    )
+    fig = px.imshow(
+        pivot,
+        color_continuous_scale=["#F1FAEE", "#1B4965", "#0B6E4F"],
+        aspect="auto",
+        labels=dict(color="Crash Score"),
+    )
+    return _apply_layout(fig, "Avg Crash Score by Scenario × Family", height=520)
+
+
+def energy_intrusion_scatter(recommendations: pd.DataFrame) -> go.Figure:
+    sample = recommendations.sample(n=min(1500, len(recommendations)), random_state=5)
+    fig = px.scatter(
+        sample,
+        x="intrusion_mm",
+        y="energy_absorption_kj",
+        color="crash_scenario",
+        symbol="family",
+        hover_data=["material_name", "component", "crash_score"],
+        color_discrete_sequence=COLOR_SEQUENCE,
+        labels={
+            "intrusion_mm": "Intrusion (mm)",
+            "energy_absorption_kj": "Energy Absorption (kJ)",
+        },
+    )
+    return _apply_layout(fig, "Energy Absorption vs Intrusion", height=460)
+
+
+def validation_parity(validation: pd.DataFrame) -> go.Figure:
+    fig = go.Figure()
+    fig.add_trace(
+        go.Scatter(
+            x=validation["cae_crash_score"],
+            y=validation["ai_crash_score"],
+            mode="markers",
+            name="AI vs CAE",
+            marker=dict(color="#1B4965", size=7, opacity=0.55),
+        )
+    )
+    lims = [0, 100]
+    fig.add_trace(
+        go.Scatter(
+            x=lims,
+            y=lims,
+            mode="lines",
+            name="Ideal",
+            line=dict(color="#C44536", dash="dash", width=2),
+        )
+    )
+    fig.update_layout(xaxis_title="CAE Crash Score", yaxis_title="AI Crash Score")
+    return _apply_layout(fig, "AI Prediction vs CAE Validation", height=440)
+
+
+def validation_error_hist(validation: pd.DataFrame) -> go.Figure:
+    fig = px.histogram(
+        validation,
+        x="ai_cae_error_pct",
+        nbins=30,
+        color="pass_fail",
+        color_discrete_map={"Pass": "#0B6E4F", "Review": "#C44536"},
+        labels={"ai_cae_error_pct": "AI–CAE Error (%)"},
+    )
+    return _apply_layout(fig, "AI–CAE Error Distribution", height=400)
+
+
+def cost_sustain_bubble(materials: pd.DataFrame) -> go.Figure:
+    sample = materials.sample(n=min(1500, len(materials)), random_state=9)
+    fig = px.scatter(
+        sample,
+        x="cost_usd_kg",
+        y="sustainability_score",
+        size="crashworthiness_index",
+        color="family",
+        hover_data=["material_name", "density_g_cm3", "uts_mpa"],
+        color_discrete_sequence=COLOR_SEQUENCE,
+        labels={
+            "cost_usd_kg": "Cost (USD/kg)",
+            "sustainability_score": "Sustainability Score",
+        },
+    )
+    return _apply_layout(fig, "Cost vs Sustainability (bubble = crash score)", height=460)
+
+
+def top_recommendations_bar(top: pd.DataFrame) -> go.Figure:
+    plot_df = top.copy()
+    name_col = "material_name" if "material_name" in plot_df.columns else "family"
+    fig = px.bar(
+        plot_df.sort_values("crash_score", ascending=True),
+        x="crash_score",
+        y=name_col,
+        color="family" if "family" in plot_df.columns else None,
+        orientation="h",
+        color_discrete_sequence=COLOR_SEQUENCE,
+        labels={"crash_score": "Crash Score", name_col: "Material"},
+    )
+    return _apply_layout(fig, "Top Recommended Materials", height=420)
+
+
+def kpi_gauge(value: float, title: str, color: str = "#0B6E4F") -> go.Figure:
+    fig = go.Figure(
+        go.Indicator(
+            mode="gauge+number",
+            value=value,
+            title={"text": title, "font": {"size": 14, "color": "#1a1a1a"}},
+            number={"font": {"color": "#1a1a1a"}},
+            gauge={
+                "axis": {"range": [0, 100], "tickcolor": "#1a1a1a"},
+                "bar": {"color": color},
+                "bgcolor": "#f1f5f9",
+                "bordercolor": "#cbd5e1",
+                "steps": [
+                    {"range": [0, 40], "color": "#fee2e2"},
+                    {"range": [40, 70], "color": "#fef3c7"},
+                    {"range": [70, 100], "color": "#dcfce7"},
+                ],
+            },
+        )
+    )
+    fig.update_layout(
+        height=220,
+        margin=dict(l=20, r=20, t=40, b=10),
+        paper_bgcolor="white",
+        font=dict(color="#1a1a1a"),
+    )
+    return fig