Update app.py

app.py

@@ -418,6 +418,692 @@ def match_pdf_to_athlete(pdfs_data, athlete_name):
             return pdf
     return None
 
+# =========================================================
+# ANALYSE V3
+# =========================================================
+
+ANALYSIS_CONFIG = {
+    "heel_force_N": {
+        "label": "Force talon",
+        "unit": "N",
+        "description_low": "Force talon plutôt faible par rapport à la zone attendue.",
+        "description_normal": "Force talon dans la zone attendue.",
+        "description_high": "Force talon élevée, pouvant refléter une contrainte d'impact majorée."
+    },
+    "heel_pressure_N_cm2": {
+        "label": "Pression talon",
+        "unit": "N/cm²",
+        "description_low": "Pression talon plutôt faible.",
+        "description_normal": "Pression talon dans la zone attendue.",
+        "description_high": "Pression talon élevée, pouvant indiquer une concentration de charge accrue."
+    },
+    "cadence_spm": {
+        "label": "Cadence",
+        "unit": "pas/min",
+        "description_low": "Cadence basse par rapport à la zone attendue.",
+        "description_normal": "Cadence dans la zone attendue.",
+        "description_high": "Cadence élevée par rapport à la zone attendue."
+    },
+    "contact_pct": {
+        "label": "Temps de contact",
+        "unit": "%",
+        "description_low": "Temps de contact plutôt faible.",
+        "description_normal": "Temps de contact dans la zone attendue.",
+        "description_high": "Temps de contact élevé, pouvant traduire une dynamique de course réduite."
+    },
+    "flight_pct": {
+        "label": "Temps de vol",
+        "unit": "%",
+        "description_low": "Temps de vol plutôt faible.",
+        "description_normal": "Temps de vol dans la zone attendue.",
+        "description_high": "Temps de vol élevé par rapport à la zone attendue."
+    },
+    "asymmetry_pct": {
+        "label": "Asymétrie talon",
+        "unit": "%",
+        "description_low": "Asymétrie faible.",
+        "description_normal": "Asymétrie dans la zone acceptable.",
+        "description_high": "Asymétrie élevée, à surveiller."
+    },
+    "foot_rotation_deg": {
+        "label": "Différence rotation G/D",
+        "unit": "°",
+        "description_low": "Différence de rotation plutôt faible.",
+        "description_normal": "Différence de rotation dans la zone attendue.",
+        "description_high": "Différence de rotation élevée, pouvant majorer certaines contraintes mécaniques."
+    }
+}
+
+
+def clamp(value, min_value=0, max_value=100):
+    return max(min_value, min(max_value, value))
+
+
+def classify_value(value, low, high):
+    if value is None or pd.isna(value):
+        return "non disponible"
+    if value < low:
+        return "basse"
+    if value > high:
+        return "élevée"
+    return "normale"
+
+
+def compute_deviation_score(value, low, high):
+    if value is None or pd.isna(value):
+        return 0.0
+
+    if low <= value <= high:
+        return 0.0
+
+    if value < low:
+        if low == 0:
+            return 0.0
+        return round((low - value) / low, 3)
+
+    if value > high:
+        if high == 0:
+            return 0.0
+        return round((value - high) / high, 3)
+
+    return 0.0
+
+
+def get_priority(status, deviation_score, variable_key=None):
+    if status == "normale":
+        return "RAS"
+
+    if status == "basse":
+        if variable_key in ["cadence_spm", "flight_pct"]:
+            return "modérée"
+        return "faible"
+
+    if status == "élevée":
+        if deviation_score >= 0.20:
+            return "élevée"
+        return "modérée"
+
+    return "RAS"
+
+
+def priority_to_points(priority):
+    mapping = {"RAS": 0, "faible": 1, "modérée": 2, "élevée": 3}
+    return mapping.get(priority, 0)
+
+
+def pattern_priority_to_points(priority):
+    mapping = {"modérée": 2, "élevée": 3}
+    return mapping.get(priority, 0)
+
+
+def build_analysis_inputs(row, metrics, thresholds, attaque_finale):
+    merged_data = {
+        "heel_force_N": metrics["force_talon_moy"],
+        "heel_pressure_N_cm2": metrics["pression_talon_moy"],
+        "cadence_spm": row["Cadence (pas/min)"],
+        "contact_pct": row["Contact (%)"],
+        "flight_pct": row["Flight (%)"],
+        "asymmetry_pct": metrics["asym_talon"],
+        "foot_rotation_deg": metrics["diff_rotation"],
+        "impact_score": metrics["contraintes"],
+        "dynamic_score": metrics["dynamique"],
+        "symmetry_score": metrics["symetrie"],
+        "rollover_score": metrics["deroule"],
+        "attack_type": attaque_finale,
+    }
+
+    thresholds_analysis = {
+        "heel_force_N": {
+            "low": thresholds["force_n_low"],
+            "high": thresholds["force_n_high"],
+        },
+        "heel_pressure_N_cm2": {
+            "low": thresholds["pression_low"],
+            "high": thresholds["pression_high"],
+        },
+        "cadence_spm": {
+            "low": thresholds["cadence_low"],
+            "high": thresholds["cadence_high"],
+        },
+        "contact_pct": {
+            "low": thresholds["contact_low"],
+            "high": thresholds["contact_high"],
+        },
+        "flight_pct": {
+            "low": thresholds["flight_low"],
+            "high": thresholds["flight_high"],
+        },
+        "asymmetry_pct": {
+            "low": thresholds["asym_low"],
+            "high": thresholds["asym_high"],
+        },
+        "foot_rotation_deg": {
+            "low": thresholds["rotation_low"],
+            "high": thresholds["rotation_high"],
+        },
+    }
+
+    return merged_data, thresholds_analysis
+
+
+def analyze_variable(key, value, thresholds):
+    if key not in ANALYSIS_CONFIG:
+        return None
+    if key not in thresholds:
+        return None
+
+    config = ANALYSIS_CONFIG[key]
+    low = thresholds[key]["low"]
+    high = thresholds[key]["high"]
+
+    status = classify_value(value, low, high)
+    deviation_score = compute_deviation_score(value, low, high)
+    priority = get_priority(status, deviation_score, variable_key=key)
+
+    if status == "basse":
+        interpretation = config["description_low"]
+    elif status == "élevée":
+        interpretation = config["description_high"]
+    elif status == "normale":
+        interpretation = config["description_normal"]
+    else:
+        interpretation = "Donnée non disponible."
+
+    return {
+        "variable": key,
+        "label": config["label"],
+        "value": value,
+        "unit": config["unit"],
+        "low": low,
+        "high": high,
+        "status": status,
+        "priority": priority,
+        "deviation_score": deviation_score,
+        "interpretation": interpretation,
+    }
+
+
+def run_biomech_analysis(merged_data, thresholds_analysis):
+    results = []
+    for key in ANALYSIS_CONFIG.keys():
+        result = analyze_variable(key, merged_data.get(key), thresholds_analysis)
+        if result is not None:
+            results.append(result)
+    return pd.DataFrame(results)
+
+
+def get_status_map(df_analysis):
+    if df_analysis.empty:
+        return {}
+    return dict(zip(df_analysis["variable"], df_analysis["status"]))
+
+
+def is_high(status_map, key):
+    return status_map.get(key) == "élevée"
+
+
+def is_low(status_map, key):
+    return status_map.get(key) == "basse"
+
+
+def detect_combined_patterns(merged_data, df_analysis):
+    patterns = []
+    status_map = get_status_map(df_analysis)
+
+    impact_score = merged_data.get("impact_score")
+    dynamic_score = merged_data.get("dynamic_score")
+    symmetry_score = merged_data.get("symmetry_score")
+    rollover_score = merged_data.get("rollover_score")
+    attack_type = merged_data.get("attack_type", "indéterminée")
+
+    if is_high(status_map, "heel_force_N") and is_high(status_map, "heel_pressure_N_cm2"):
+        patterns.append({
+            "name": "impact_load_flag",
+            "title": "Contrainte d'impact majorée",
+            "priority": "élevée",
+            "category": "impact",
+            "message": "La combinaison d'une force talon élevée et d'une pression talon élevée suggère une contrainte d'impact majorée."
+        })
+    elif is_high(status_map, "heel_force_N") or is_high(status_map, "heel_pressure_N_cm2"):
+        patterns.append({
+            "name": "impact_signal_flag",
+            "title": "Signal d'impact à surveiller",
+            "priority": "modérée",
+            "category": "impact",
+            "message": "Un marqueur d'impact talonnier est au-dessus de la zone attendue."
+        })
+
+    if is_low(status_map, "cadence_spm") and is_high(status_map, "contact_pct"):
+        patterns.append({
+            "name": "low_dynamics_flag",
+            "title": "Dynamique de course possiblement réduite",
+            "priority": "élevée",
+            "category": "dynamics",
+            "message": "La combinaison d'une cadence basse et d'un temps de contact élevé évoque une dynamique de course potentiellement réduite."
+        })
+
+    if is_low(status_map, "flight_pct") and is_high(status_map, "contact_pct"):
+        patterns.append({
+            "name": "reactivity_flag",
+            "title": "Réactivité mécanique possiblement diminuée",
+            "priority": "modérée",
+            "category": "dynamics",
+            "message": "Le temps de vol bas associé à un temps de contact élevé évoque une moindre réactivité mécanique."
+        })
+
+    if pd.notna(dynamic_score) and dynamic_score < 50:
+        if is_high(status_map, "contact_pct") or is_low(status_map, "flight_pct"):
+            patterns.append({
+                "name": "global_dynamic_flag",
+                "title": "Déficit dynamique renforcé",
+                "priority": "élevée",
+                "category": "dynamics",
+                "message": "Le score de dynamique bas renforce l'hypothèse d'une dynamique de course altérée."
+            })
+
+    if is_high(status_map, "asymmetry_pct"):
+        if pd.notna(symmetry_score) and symmetry_score < 60:
+            patterns.append({
+                "name": "asymmetry_flag",
+                "title": "Asymétrie renforcée",
+                "priority": "élevée",
+                "category": "symmetry",
+                "message": "L'asymétrie mesurée est élevée et cohérente avec un score de symétrie faible."
+            })
+        else:
+            patterns.append({
+                "name": "asymmetry_watch_flag",
+                "title": "Asymétrie à surveiller",
+                "priority": "modérée",
+                "category": "symmetry",
+                "message": "Une asymétrie au-dessus de la zone attendue est observée."
+            })
+
+    if is_high(status_map, "foot_rotation_deg"):
+        if pd.notna(rollover_score) and rollover_score < 60:
+            patterns.append({
+                "name": "mechanical_pattern_flag",
+                "title": "Pattern mécanique distal à surveiller",
+                "priority": "modérée",
+                "category": "mechanics",
+                "message": "La différence de rotation élevée associée à un déroulé peu efficient suggère un pattern mécanique distal à surveiller."
+            })
+        else:
+            patterns.append({
+                "name": "rotation_flag",
+                "title": "Différence de rotation élevée",
+                "priority": "modérée",
+                "category": "mechanics",
+                "message": "La différence de rotation est au-dessus de la zone attendue."
+            })
+
+    if attack_type == "attaque talon":
+        if is_high(status_map, "heel_force_N") or is_high(status_map, "heel_pressure_N_cm2"):
+            patterns.append({
+                "name": "rearfoot_impact_context",
+                "title": "Attaque talon avec charge d'impact marquée",
+                "priority": "modérée",
+                "category": "attack",
+                "message": "Le profil d'attaque talon est associé à des marqueurs d'impact élevés."
+            })
+
+    if pd.notna(dynamic_score) and pd.notna(rollover_score):
+        if dynamic_score < 50 and rollover_score < 55:
+            patterns.append({
+                "name": "global_efficiency_flag",
+                "title": "Efficience mécanique possiblement réduite",
+                "priority": "modérée",
+                "category": "global",
+                "message": "La combinaison d'un score de dynamique bas et d'un déroulé faible évoque une efficience mécanique possiblement réduite."
+            })
+
+    return deduplicate_patterns(patterns)
+
+
+def deduplicate_patterns(patterns):
+    seen = set()
+    unique_patterns = []
+    for pattern in patterns:
+        key = (pattern["name"], pattern["title"])
+        if key not in seen:
+            seen.add(key)
+            unique_patterns.append(pattern)
+    return unique_patterns
+
+
+def compute_domain_scores(merged_data, df_analysis, patterns):
+    if df_analysis.empty:
+        return {
+            "impact": 0,
+            "dynamics": 0,
+            "symmetry": 0,
+            "mechanics": 0,
+            "attack": 0,
+            "global": 0,
+        }
+
+    row_map = {row["variable"]: row for _, row in df_analysis.iterrows()}
+
+    def var_points(var_name, weight=1.0):
+        row = row_map.get(var_name)
+        if not row:
+            return 0.0
+        base = priority_to_points(row["priority"]) * 10
+        bonus = row["deviation_score"] * 20
+        return (base + bonus) * weight
+
+    def pattern_points(category):
+        total = 0
+        for p in patterns:
+            if p["category"] == category:
+                total += pattern_priority_to_points(p["priority"]) * 10
+        return total
+
+    impact_score_profile = merged_data.get("impact_score")
+    dynamic_score_profile = merged_data.get("dynamic_score")
+    symmetry_score_profile = merged_data.get("symmetry_score")
+    rollover_score_profile = merged_data.get("rollover_score")
+
+    impact = 0
+    impact += var_points("heel_force_N", 1.2)
+    impact += var_points("heel_pressure_N_cm2", 1.2)
+    impact += pattern_points("impact")
+    impact += pattern_points("attack")
+    if pd.notna(impact_score_profile) and impact_score_profile >= 70:
+        impact += (impact_score_profile - 70) * 0.2
+
+    dynamics = 0
+    dynamics += var_points("cadence_spm", 1.0)
+    dynamics += var_points("contact_pct", 1.2)
+    dynamics += var_points("flight_pct", 1.0)
+    dynamics += pattern_points("dynamics")
+    if pd.notna(dynamic_score_profile) and dynamic_score_profile < 60:
+        dynamics += (60 - dynamic_score_profile) * 0.5
+
+    symmetry = 0
+    symmetry += var_points("asymmetry_pct", 1.5)
+    symmetry += pattern_points("symmetry")
+    if pd.notna(symmetry_score_profile) and symmetry_score_profile < 70:
+        symmetry += (70 - symmetry_score_profile) * 0.5
+
+    mechanics = 0
+    mechanics += var_points("foot_rotation_deg", 1.4)
+    mechanics += pattern_points("mechanics")
+    if pd.notna(rollover_score_profile) and rollover_score_profile < 65:
+        mechanics += (65 - rollover_score_profile) * 0.35
+
+    attack = 0
+    attack += pattern_points("attack")
+    attack += 0.5 * var_points("heel_force_N", 1.0)
+    attack += 0.5 * var_points("heel_pressure_N_cm2", 1.0)
+
+    global_score = (
+        impact * 0.30 +
+        dynamics * 0.30 +
+        symmetry * 0.20 +
+        mechanics * 0.20
+    )
+
+    return {
+        "impact": int(clamp(round(impact))),
+        "dynamics": int(clamp(round(dynamics))),
+        "symmetry": int(clamp(round(symmetry))),
+        "mechanics": int(clamp(round(mechanics))),
+        "attack": int(clamp(round(attack))),
+        "global": int(clamp(round(global_score))),
+    }
+
+
+def get_domain_label(score):
+    if score >= 75:
+        return "élevé"
+    if score >= 45:
+        return "modéré"
+    if score >= 20:
+        return "léger"
+    return "faible"
+
+
+def get_primary_domains(domain_scores, top_n=3):
+    filtered = {k: v for k, v in domain_scores.items() if k != "global"}
+    return sorted(filtered.items(), key=lambda x: x[1], reverse=True)[:top_n]
+
+
+def compute_global_summary_v3(df_analysis, patterns, domain_scores):
+    if df_analysis.empty:
+        return {
+            "normal_count": 0,
+            "attention_count": 0,
+            "high_priority_count": 0,
+            "moderate_priority_count": 0,
+            "pattern_count": 0,
+            "global_level": "indéterminé",
+        }
+
+    normal_count = int((df_analysis["status"] == "normale").sum())
+    attention_count = int((df_analysis["status"] != "normale").sum())
+    high_priority_count = int((df_analysis["priority"] == "élevée").sum())
+    moderate_priority_count = int((df_analysis["priority"] == "modérée").sum())
+
+    pattern_high = sum(1 for p in patterns if p["priority"] == "élevée")
+    pattern_moderate = sum(1 for p in patterns if p["priority"] == "modérée")
+    global_domain_score = domain_scores.get("global", 0)
+
+    total_high = high_priority_count + pattern_high
+    total_moderate = moderate_priority_count + pattern_moderate
+
+    if total_high >= 2 or global_domain_score >= 75:
+        global_level = "élevé"
+    elif total_high == 1 or total_moderate >= 3 or global_domain_score >= 45:
+        global_level = "modéré"
+    elif attention_count >= 1 or len(patterns) >= 1 or global_domain_score >= 20:
+        global_level = "léger"
+    else:
+        global_level = "faible"
+
+    return {
+        "normal_count": normal_count,
+        "attention_count": attention_count,
+        "high_priority_count": total_high,
+        "moderate_priority_count": total_moderate,
+        "pattern_count": len(patterns),
+        "global_level": global_level,
+    }
+
+
+def generate_global_narrative(summary, domain_scores):
+    if summary["global_level"] == "faible":
+        return (
+            "Le profil est globalement cohérent par rapport aux seuils individualisés, "
+            "sans signal biomécanique majeur détecté à ce stade."
+        )
+
+    label_map = {
+        "impact": "contrainte d'impact",
+        "dynamics": "dynamique de course",
+        "symmetry": "symétrie",
+        "mechanics": "mécanique distale",
+        "attack": "organisation de l'attaque",
+    }
+
+    top_domains = get_primary_domains(domain_scores, top_n=3)
+    top_labels = [label_map.get(name, name) for name, score in top_domains if score >= 20]
+    domains_text = ", ".join(top_labels) if top_labels else "plusieurs dimensions biomécaniques"
+
+    if summary["global_level"] == "léger":
+        return f"Le profil met en évidence quelques signaux isolés, principalement autour de : {domains_text}."
+    if summary["global_level"] == "modéré":
+        return f"Le profil présente plusieurs points d'attention cohérents, notamment sur : {domains_text}."
+    return (
+        f"Le profil présente plusieurs signaux convergents, en particulier sur : {domains_text}. "
+        "Une interprétation approfondie est justifiée avant la phase de recommandations."
+    )
+
+
+def prepare_analysis_table(df_analysis):
+    if df_analysis.empty:
+        return df_analysis
+
+    priority_order = {"élevée": 3, "modérée": 2, "faible": 1, "RAS": 0}
+    status_order = {"élevée": 2, "basse": 1, "normale": 0, "non disponible": -1}
+
+    df = df_analysis.copy()
+    df["priority_rank"] = df["priority"].map(priority_order).fillna(0)
+    df["status_rank"] = df["status"].map(status_order).fillna(-1)
+
+    df = df.sort_values(
+        by=["priority_rank", "status_rank", "deviation_score"],
+        ascending=[False, False, False]
+    )
+
+    return df.drop(columns=["priority_rank", "status_rank"])
+
+
+def display_status_badge(status):
+    if status == "normale":
+        st.success("Normale")
+    elif status == "basse":
+        st.warning("Basse")
+    elif status == "élevée":
+        st.error("Élevée")
+    else:
+        st.info("Non disponible")
+
+
+def display_priority_badge(priority):
+    if priority == "RAS":
+        st.success("RAS")
+    elif priority == "faible":
+        st.info("Faible")
+    elif priority == "modérée":
+        st.warning("Modérée")
+    elif priority == "élevée":
+        st.error("Élevée")
+    else:
+        st.info(priority)
+
+
+def display_pattern_badge(priority):
+    if priority == "élevée":
+        st.error("Pattern prioritaire")
+    elif priority == "modérée":
+        st.warning("Pattern à surveiller")
+    else:
+        st.info(priority)
+
+
+def render_analysis_tab_v3(merged_data, thresholds_analysis):
+    st.subheader("📈 Analyse des données")
+
+    df_analysis = run_biomech_analysis(merged_data, thresholds_analysis)
+    patterns = detect_combined_patterns(merged_data, df_analysis)
+    domain_scores = compute_domain_scores(merged_data, df_analysis, patterns)
+    summary = compute_global_summary_v3(df_analysis, patterns, domain_scores)
+    narrative = generate_global_narrative(summary, domain_scores)
+
+    c1, c2, c3, c4, c5 = st.columns(5)
+    c1.metric("Variables normales", summary["normal_count"])
+    c2.metric("Points d'attention", summary["attention_count"])
+    c3.metric("Priorités hautes", summary["high_priority_count"])
+    c4.metric("Patterns détectés", summary["pattern_count"])
+    c5.metric("Niveau global", summary["global_level"].capitalize())
+
+    st.markdown("---")
+    st.markdown("### Conclusion synthétique")
+
+    if summary["global_level"] == "faible":
+        st.success(narrative)
+    elif summary["global_level"] == "léger":
+        st.info(narrative)
+    elif summary["global_level"] == "modéré":
+        st.warning(narrative)
+    else:
+        st.error(narrative)
+
+    st.markdown("---")
+    st.markdown("### Scores par domaine")
+
+    d1, d2, d3, d4, d5 = st.columns(5)
+    d1.metric("Impact", f"{domain_scores['impact']}/100")
+    d2.metric("Dynamique", f"{domain_scores['dynamics']}/100")
+    d3.metric("Symétrie", f"{domain_scores['symmetry']}/100")
+    d4.metric("Mécanique", f"{domain_scores['mechanics']}/100")
+    d5.metric("Attaque", f"{domain_scores['attack']}/100")
+
+    st.markdown("---")
+    st.markdown("### Synthèse par variable")
+
+    if df_analysis.empty:
+        st.info("Aucune donnée disponible pour l'analyse.")
+    else:
+        df_display = prepare_analysis_table(df_analysis)[[
+            "label", "value", "unit", "low", "high", "status", "priority"
+        ]].copy()
+
+        df_display.columns = [
+            "Variable", "Valeur", "Unité", "Seuil bas", "Seuil haut", "Statut", "Priorité"
+        ]
+        st.dataframe(df_display, hide_index=True, use_container_width=True)
+
+    st.markdown("---")
+    st.markdown("### Patterns biomécaniques détectés")
+
+    if not patterns:
+        st.success("Aucun pattern combiné majeur détecté.")
+    else:
+        for pattern in patterns:
+            col1, col2 = st.columns([4, 1])
+            with col1:
+                st.markdown(f"**{pattern['title']}**")
+                st.write(pattern["message"])
+            with col2:
+                display_pattern_badge(pattern["priority"])
+            st.markdown("---")
+
+    st.markdown("### Détail par variable")
+    if not df_analysis.empty:
+        df_sorted = prepare_analysis_table(df_analysis)
+        for _, row in df_sorted.iterrows():
+            col1, col2, col3 = st.columns([2.5, 1, 1])
+
+            with col1:
+                st.markdown(f"**{row['label']}**")
+                st.write(
+                    f"Valeur mesurée : **{row['value']:.2f} {row['unit']}**  \n"
+                    f"Zone attendue : **{row['low']:.2f} à {row['high']:.2f} {row['unit']}**"
+                    if pd.notna(row["value"]) else
+                    f"Valeur mesurée : **N/A**  \nZone attendue : **{row['low']:.2f} à {row['high']:.2f} {row['unit']}**"
+                )
+                st.write(row["interpretation"])
+
+            with col2:
+                st.markdown("**Statut**")
+                display_status_badge(row["status"])
+
+            with col3:
+                st.markdown("**Priorité**")
+                display_priority_badge(row["priority"])
+
+            st.markdown("---")
+
+    st.markdown("### Axes dominants à prioriser")
+    top_domains = get_primary_domains(domain_scores, top_n=3)
+    domain_name_map = {
+        "impact": "Impact",
+        "dynamics": "Dynamique",
+        "symmetry": "Symétrie",
+        "mechanics": "Mécanique distale",
+        "attack": "Attaque",
+    }
+
+    shown = False
+    for domain_key, score in top_domains:
+        if score >= 20:
+            shown = True
+            st.markdown(f"- **{domain_name_map.get(domain_key, domain_key)}** : {score}/100 (**{get_domain_label(score)}**)")
+
+    if not shown:
+        st.success("Aucun axe dominant majeur ne se dégage à ce stade.")
 
 # Charge CSV
 dfs = []
@@ -489,6 +1175,12 @@ attaque_finale = metrics["attaque_csv"]
 if matched_pdf and matched_pdf.get("attaque_pdf") and matched_pdf["attaque_pdf"] != "indéterminée":
     attaque_finale = matched_pdf["attaque_pdf"]
 
+merged_data, thresholds_analysis = build_analysis_inputs(
+    row=row,
+    metrics=metrics,
+    thresholds=thresholds,
+    attaque_finale=attaque_finale,
+)    
 
 def build_summary(row, metrics, attaque_finale):
     contraintes_txt = (
@@ -516,8 +1208,8 @@ def build_summary(row, metrics, attaque_finale):
 
 summary = build_summary(row, metrics, attaque_finale)
 
-tab_profil, tab_seuils, tab_pdf = st.tabs(
-    ["Profil biomécanique", "Seuils individualisés", "Apports du PDF Zebris"]
+tab_profil, tab_seuils, tab_analyse, tab_pdf = st.tabs(
+    ["Profil biomécanique", "Seuils individualisés", "Analyse", "Apports du PDF Zebris"]
 )
 
 with tab_profil:
@@ -666,6 +1358,9 @@ with tab_seuils:
     with s3:
         st.dataframe(symetrie_df, hide_index=True, use_container_width=True)
 
+with tab_analyse:
+    render_analysis_tab_v3(merged_data, thresholds_analysis)
+    
 with tab_pdf:
     if not matched_pdf:
         st.info("Aucun PDF Zebris associé à cet athlète n’a été trouvé.")