Create app.py

app.py

@@ -0,0 +1,516 @@
+import numpy as np
+import pandas as pd
+import streamlit as st
+import matplotlib.pyplot as plt
+
+from zebris_extractor import extract_zebris_csv
+
+st.set_page_config(page_title="Zebris — Profil & Seuils", layout="wide")
+
+st.title("Zebris — Profil biomécanique & seuils individualisés")
+st.caption("Import de plusieurs CSV Zebris → choix d’un athlète → profil biomécanique + seuils personnalisés")
+
+with st.sidebar:
+    st.header("Import")
+    uploaded_files = st.file_uploader(
+        "Importer un ou plusieurs fichiers CSV Zebris",
+        type=["csv"],
+        accept_multiple_files=True,
+    )
+
+    if uploaded_files:
+        total_size = sum(f.size for f in uploaded_files)
+        if total_size > 100 * 1024 * 1024:
+            st.error("Volume total de fichiers trop important (>100 MB)")
+            st.stop()
+
+    st.header("Contexte")
+    volume_horaire = st.number_input(
+        "Volume horaire / semaine",
+        min_value=0.5,
+        max_value=40.0,
+        value=5.0,
+        step=0.5,
+    )
+
+if not uploaded_files:
+    st.info("Importe un ou plusieurs CSV Zebris pour afficher les profils et les seuils.")
+    st.stop()
+
+
+def avg(a, b):
+    if pd.isna(a) and pd.isna(b):
+        return np.nan
+    if pd.isna(a):
+        return float(b)
+    if pd.isna(b):
+        return float(a)
+    return (float(a) + float(b)) / 2
+
+
+def asym(a, b):
+    m = avg(a, b)
+    if pd.isna(m) or m == 0 or pd.isna(a) or pd.isna(b):
+        return np.nan
+    return abs(float(a) - float(b)) / m * 100
+
+
+def clamp_score(value, low, high, reverse=False):
+    if pd.isna(value):
+        return np.nan
+    score = (value - low) / (high - low) * 100
+    score = max(0, min(100, score))
+    return 100 - score if reverse else score
+
+
+def safe_mean(values):
+    vals = [v for v in values if pd.notna(v)]
+    if not vals:
+        return np.nan
+    return float(np.mean(vals))
+
+
+def compute_profile_metrics(row, poids_kg):
+    poids_n = poids_kg * 9.81
+
+    force_talon_moy = avg(row["Force talon G (N)"], row["Force talon D (N)"])
+    force_avant_moy = avg(row["Force avant-pied G (N)"], row["Force avant-pied D (N)"])
+    pression_talon_moy = avg(row["Pression talon G (N/cm²)"], row["Pression talon D (N/cm²)"])
+    cop_moy = avg(row["COP G (mm)"], row["COP D (mm)"])
+    transition_moy = avg(row["Transition G (s)"], row["Transition D (s)"])
+
+    asym_talon = asym(row["Force talon G (N)"], row["Force talon D (N)"])
+    asym_avant = asym(row["Force avant-pied G (N)"], row["Force avant-pied D (N)"])
+    asym_cop = asym(row["COP G (mm)"], row["COP D (mm)"])
+
+    diff_rotation = (
+        abs(float(row["Rotation G (°)"]) - float(row["Rotation D (°)"]))
+        if pd.notna(row["Rotation G (°)"]) and pd.notna(row["Rotation D (°)"])
+        else np.nan
+    )
+
+    force_talon_bw = force_talon_moy / poids_n if pd.notna(force_talon_moy) and poids_n else np.nan
+    ratio_talon_avant = (
+        force_talon_moy / force_avant_moy
+        if pd.notna(force_talon_moy) and pd.notna(force_avant_moy) and force_avant_moy != 0
+        else np.nan
+    )
+
+    # Contraintes locales recalées sur ton export Zebris
+    contraintes_force_score = clamp_score(force_talon_bw, 0.15, 0.45)
+    contraintes_pressure_score = clamp_score(pression_talon_moy, 3, 10)
+
+    contraintes = safe_mean([
+        0.6 * contraintes_force_score if pd.notna(contraintes_force_score) else np.nan,
+        0.4 * contraintes_pressure_score if pd.notna(contraintes_pressure_score) else np.nan,
+    ])
+    contraintes = round(contraintes) if pd.notna(contraintes) else np.nan
+
+    dynamique = safe_mean([
+        0.6 * clamp_score(row["Cadence (pas/min)"], 150, 185),
+        0.4 * clamp_score(row["Contact (%)"], 68, 76, reverse=True),
+    ])
+    dynamique = round(dynamique) if pd.notna(dynamique) else np.nan
+
+    sym_components = [x for x in [asym_talon, asym_avant, asym_cop, diff_rotation] if pd.notna(x)]
+    symetrie = round(100 - min(100, np.mean(sym_components) * 2.5)) if sym_components else np.nan
+
+    deroule = safe_mean([
+        0.5 * clamp_score(cop_moy, 210, 260),
+        0.5 * clamp_score(transition_moy, 0.05, 0.09, reverse=True),
+    ])
+    deroule = round(deroule) if pd.notna(deroule) else np.nan
+
+    attaque = "mixte"
+    if pd.notna(ratio_talon_avant):
+        if ratio_talon_avant > 1.05:
+            attaque = "talon"
+        elif ratio_talon_avant < 0.95:
+            attaque = "avant-pied"
+
+    return {
+        "force_talon_moy": force_talon_moy,
+        "force_avant_moy": force_avant_moy,
+        "pression_talon_moy": pression_talon_moy,
+        "cop_moy": cop_moy,
+        "transition_moy": transition_moy,
+        "asym_talon": asym_talon,
+        "asym_avant": asym_avant,
+        "asym_cop": asym_cop,
+        "diff_rotation": diff_rotation,
+        "force_talon_bw": force_talon_bw,
+        "ratio_talon_avant": ratio_talon_avant,
+        "contraintes": contraintes,
+        "dynamique": dynamique,
+        "symetrie": symetrie,
+        "deroule": deroule,
+        "attaque": attaque,
+    }
+
+
+def build_summary(row, metrics):
+    contraintes_txt = (
+        "élevées" if pd.notna(metrics["contraintes"]) and metrics["contraintes"] >= 70
+        else "modérées" if pd.notna(metrics["contraintes"]) and metrics["contraintes"] >= 45
+        else "faibles"
+    )
+    dyn_txt = (
+        "bonne" if pd.notna(metrics["dynamique"]) and metrics["dynamique"] >= 70
+        else "moyenne" if pd.notna(metrics["dynamique"]) and metrics["dynamique"] >= 45
+        else "faible"
+    )
+    sym_txt = "satisfaisante" if pd.notna(metrics["symetrie"]) and metrics["symetrie"] >= 70 else "perfectible"
+    der_txt = (
+        "favorable" if pd.notna(metrics["deroule"]) and metrics["deroule"] >= 70
+        else "intermédiaire" if pd.notna(metrics["deroule"]) and metrics["deroule"] >= 45
+        else "à surveiller"
+    )
+
+    return (
+        f"À {row['Vitesse (km/h)']} km/h, {row['Nom']} présente une attaque {metrics['attaque']}, "
+        f"des contraintes mécaniques {contraintes_txt}, une dynamique {dyn_txt}, une symétrie {sym_txt} "
+        f"et un déroulé {der_txt}."
+    )
+
+
+def draw_radar(metrics):
+    labels = ["Contraintes", "Dynamique", "Symétrie", "Déroulé"]
+    values = [
+        metrics["contraintes"] if pd.notna(metrics["contraintes"]) else 0,
+        metrics["dynamique"] if pd.notna(metrics["dynamique"]) else 0,
+        metrics["symetrie"] if pd.notna(metrics["symetrie"]) else 0,
+        metrics["deroule"] if pd.notna(metrics["deroule"]) else 0,
+    ]
+    values += values[:1]
+    angles = np.linspace(0, 2 * np.pi, len(labels), endpoint=False).tolist()
+    angles += angles[:1]
+
+    fig = plt.figure(figsize=(5, 5))
+    ax = plt.subplot(111, polar=True)
+    ax.plot(angles, values, linewidth=2)
+    ax.fill(angles, values, alpha=0.25)
+    ax.set_xticks(angles[:-1])
+    ax.set_xticklabels(labels)
+    ax.set_ylim(0, 100)
+    ax.set_yticks([25, 50, 75, 100])
+    ax.set_title("Radar biomécanique", pad=20)
+    return fig
+
+
+def draw_evolution(df, poids_kg):
+    data = []
+    for _, r in df.sort_values("Vitesse (km/h)").iterrows():
+        m = compute_profile_metrics(r, poids_kg)
+        data.append({
+            "Vitesse": r["Vitesse (km/h)"],
+            "Contraintes": m["contraintes"],
+            "Dynamique": m["dynamique"],
+            "Symétrie": m["symetrie"],
+            "Déroulé": m["deroule"],
+        })
+
+    evo = pd.DataFrame(data)
+    fig, ax = plt.subplots(figsize=(8, 4))
+    for col in ["Contraintes", "Dynamique", "Symétrie", "Déroulé"]:
+        ax.plot(evo["Vitesse"], evo[col], marker="o", label=col)
+    ax.set_ylim(0, 100)
+    ax.set_xlabel("Vitesse (km/h)")
+    ax.set_ylabel("Score /100")
+    ax.set_title("Évolution avec l’allure")
+    ax.legend()
+    ax.grid(True, alpha=0.3)
+    return fig
+
+
+def compute_advanced_thresholds(sub_df, poids_kg, volume_horaire):
+    poids_n = poids_kg * 9.81
+    df = sub_df.copy()
+
+    df["force_talon_moy"] = df.apply(lambda r: avg(r["Force talon G (N)"], r["Force talon D (N)"]), axis=1)
+    df["force_talon_bw"] = df["force_talon_moy"] / poids_n
+    df["pression_talon_moy"] = df.apply(lambda r: avg(r["Pression talon G (N/cm²)"], r["Pression talon D (N/cm²)"]), axis=1)
+    df["asym_talon"] = df.apply(lambda r: asym(r["Force talon G (N)"], r["Force talon D (N)"]), axis=1)
+    df["asym_avant"] = df.apply(lambda r: asym(r["Force avant-pied G (N)"], r["Force avant-pied D (N)"]), axis=1)
+    df["asym_cop"] = df.apply(lambda r: asym(r["COP G (mm)"], r["COP D (mm)"]), axis=1)
+    df["diff_rotation"] = df.apply(
+        lambda r: abs(float(r["Rotation G (°)"]) - float(r["Rotation D (°)"]))
+        if pd.notna(r["Rotation G (°)"]) and pd.notna(r["Rotation D (°)"]) else np.nan,
+        axis=1
+    )
+
+    if volume_horaire <= 3:
+        tol = 1.15
+        charge = "faible"
+    elif volume_horaire <= 6:
+        tol = 1.00
+        charge = "modérée"
+    else:
+        tol = 0.85
+        charge = "élevée"
+
+    def zone_from_series(series, min_floor=None):
+        s = pd.to_numeric(series, errors="coerce").dropna()
+        if len(s) == 0:
+            return (np.nan, np.nan)
+        mean = s.mean()
+        std = s.std(ddof=0)
+        if pd.isna(std):
+            std = 0
+        low = mean - std * tol
+        high = mean + std * tol
+        if min_floor is not None:
+            low = max(low, min_floor)
+        return (low, high)
+
+    force_bw_low, force_bw_high = zone_from_series(df["force_talon_bw"], min_floor=0)
+    pression_low, pression_high = zone_from_series(df["pression_talon_moy"], min_floor=0)
+    cadence_low, cadence_high = zone_from_series(df["Cadence (pas/min)"], min_floor=0)
+    contact_low, contact_high = zone_from_series(df["Contact (%)"], min_floor=0)
+    flight_low, flight_high = zone_from_series(df["Flight (%)"], min_floor=0)
+
+    asym_talon_low, asym_talon_high = zone_from_series(df["asym_talon"], min_floor=0)
+    asym_avant_low, asym_avant_high = zone_from_series(df["asym_avant"], min_floor=0)
+    asym_cop_low, asym_cop_high = zone_from_series(df["asym_cop"], min_floor=0)
+    rotation_low, rotation_high = zone_from_series(df["diff_rotation"], min_floor=0)
+
+    return {
+        "charge": charge,
+        "poids_n": poids_n,
+
+        "force_bw_low": force_bw_low,
+        "force_bw_high": force_bw_high,
+        "force_n_low": force_bw_low * poids_n if pd.notna(force_bw_low) else np.nan,
+        "force_n_high": force_bw_high * poids_n if pd.notna(force_bw_high) else np.nan,
+
+        "pression_low": pression_low,
+        "pression_high": pression_high,
+
+        "cadence_low": cadence_low,
+        "cadence_high": cadence_high,
+        "contact_low": contact_low,
+        "contact_high": contact_high,
+        "flight_low": flight_low,
+        "flight_high": flight_high,
+
+        "asym_talon_low": asym_talon_low,
+        "asym_talon_high": asym_talon_high,
+        "asym_avant_low": asym_avant_low,
+        "asym_avant_high": asym_avant_high,
+        "asym_cop_low": asym_cop_low,
+        "asym_cop_high": asym_cop_high,
+        "rotation_low": rotation_low,
+        "rotation_high": rotation_high,
+    }
+
+
+# Fusion de plusieurs CSV
+dfs = []
+load_errors = []
+
+for f in uploaded_files:
+    try:
+        df_one, debug = extract_zebris_csv(f)
+        if not df_one.empty:
+            df_one["Source fichier"] = f.name
+            dfs.append(df_one)
+        else:
+            load_errors.append(f"{f.name} : aucune ligne exploitable")
+    except Exception as e:
+        load_errors.append(f"{f.name} : {e}")
+
+if load_errors:
+    for err in load_errors:
+        st.warning(err)
+
+if not dfs:
+    st.error("Aucun fichier exploitable n’a pu être importé.")
+    st.stop()
+
+df_std = pd.concat(dfs, ignore_index=True)
+
+# Sélection athlète
+all_athletes = sorted(df_std["Nom"].dropna().unique().tolist())
+selected_athlete = st.selectbox("Athlète", all_athletes)
+
+sub_df = df_std[df_std["Nom"] == selected_athlete].copy()
+if sub_df.empty:
+    st.error("Aucune donnée trouvée pour cet athlète.")
+    st.stop()
+
+sources = sorted(sub_df["Source fichier"].dropna().unique().tolist())
+if len(sources) > 1:
+    selected_source = st.selectbox("Fichier source", sources)
+    sub_df = sub_df[sub_df["Source fichier"] == selected_source].copy()
+
+sub_df = sub_df.sort_values("Vitesse (km/h)")
+speeds = sub_df["Vitesse (km/h)"].dropna().tolist()
+selected_speed = st.selectbox("Allure analysée (km/h)", speeds)
+row = sub_df[sub_df["Vitesse (km/h)"] == selected_speed].iloc[0]
+
+poids_csv = row["Poids (kg)"] if pd.notna(row["Poids (kg)"]) else np.nan
+poids_kg = st.number_input(
+    "Poids du sportif (kg)",
+    min_value=30.0,
+    max_value=150.0,
+    value=float(poids_csv) if pd.notna(poids_csv) else 70.0,
+    step=0.1,
+)
+
+metrics = compute_profile_metrics(row, poids_kg)
+summary = build_summary(row, metrics)
+thresholds = compute_advanced_thresholds(sub_df, poids_kg, volume_horaire)
+
+tab_profil, tab_seuils = st.tabs(["Profil biomécanique", "Seuils individualisés"])
+
+with tab_profil:
+    c1, c2, c3, c4 = st.columns(4)
+    with c1:
+        st.metric("Contraintes", f"{metrics['contraintes']}/100" if pd.notna(metrics["contraintes"]) else "N/A")
+    with c2:
+        st.metric("Dynamique", f"{metrics['dynamique']}/100" if pd.notna(metrics["dynamique"]) else "N/A")
+    with c3:
+        st.metric("Symétrie", f"{metrics['symetrie']}/100" if pd.notna(metrics["symetrie"]) else "N/A")
+    with c4:
+        st.metric("Déroulé", f"{metrics['deroule']}/100" if pd.notna(metrics["deroule"]) else "N/A")
+
+    left, right = st.columns([1.2, 1])
+
+    with left:
+        st.subheader("Carte d’identité biomécanique")
+        st.write(summary)
+
+        indicators = pd.DataFrame(
+            {
+                "Indicateur": [
+                    "Fichier source",
+                    "Poids",
+                    "Cadence",
+                    "Contact",
+                    "Flight",
+                    "Force talon moyenne",
+                    "Force talon normalisée",
+                    "Pression talon moyenne",
+                    "Asymétrie talon",
+                    "COP moyen",
+                    "Différence rotation",
+                    "Attaque",
+                ],
+                "Valeur": [
+                    row.get("Source fichier", "N/A"),
+                    f"{poids_kg:.1f} kg",
+                    f"{row['Cadence (pas/min)']:.1f} pas/min" if pd.notna(row["Cadence (pas/min)"]) else "N/A",
+                    f"{row['Contact (%)']:.1f} %" if pd.notna(row["Contact (%)"]) else "N/A",
+                    f"{row['Flight (%)']:.1f} %" if pd.notna(row["Flight (%)"]) else "N/A",
+                    f"{metrics['force_talon_moy']:.1f} N" if pd.notna(metrics["force_talon_moy"]) else "N/A",
+                    f"{metrics['force_talon_bw']:.2f} BW" if pd.notna(metrics["force_talon_bw"]) else "N/A",
+                    f"{metrics['pression_talon_moy']:.1f} N/cm²" if pd.notna(metrics["pression_talon_moy"]) else "N/A",
+                    f"{metrics['asym_talon']:.1f} %" if pd.notna(metrics["asym_talon"]) else "N/A",
+                    f"{metrics['cop_moy']:.1f} mm" if pd.notna(metrics["cop_moy"]) else "N/A",
+                    f"{metrics['diff_rotation']:.1f}°" if pd.notna(metrics["diff_rotation"]) else "N/A",
+                    metrics["attaque"],
+                ],
+            }
+        )
+        st.dataframe(indicators, hide_index=True, use_container_width=True)
+
+    with right:
+        st.subheader("Radar biomécanique")
+        st.pyplot(draw_radar(metrics), use_container_width=True)
+
+    st.subheader("Évolution avec l’allure")
+    st.pyplot(draw_evolution(sub_df, poids_kg), use_container_width=True)
+
+with tab_seuils:
+    r1, r2, r3 = st.columns(3)
+    with r1:
+        st.metric("Poids", f"{poids_kg:.1f} kg")
+    with r2:
+        st.metric("Poids en Newton", f"{thresholds['poids_n']:.1f} N")
+    with r3:
+        st.metric("Charge", thresholds["charge"])
+
+    impact_df = pd.DataFrame({
+        "Variable": [
+            "Force talon normalisée",
+            "Force talon convertie",
+            "Pression talon",
+        ],
+        "Zone basse / faible": [
+            f"< {thresholds['force_bw_low']:.2f} BW" if pd.notna(thresholds["force_bw_low"]) else "N/A",
+            f"< {thresholds['force_n_low']:.1f} N" if pd.notna(thresholds["force_n_low"]) else "N/A",
+            f"< {thresholds['pression_low']:.2f} N/cm²" if pd.notna(thresholds["pression_low"]) else "N/A",
+        ],
+        "Zone attendue": [
+            f"{thresholds['force_bw_low']:.2f} à {thresholds['force_bw_high']:.2f} BW" if pd.notna(thresholds["force_bw_low"]) and pd.notna(thresholds["force_bw_high"]) else "N/A",
+            f"{thresholds['force_n_low']:.1f} à {thresholds['force_n_high']:.1f} N" if pd.notna(thresholds["force_n_low"]) and pd.notna(thresholds["force_n_high"]) else "N/A",
+            f"{thresholds['pression_low']:.2f} à {thresholds['pression_high']:.2f} N/cm²" if pd.notna(thresholds["pression_low"]) and pd.notna(thresholds["pression_high"]) else "N/A",
+        ],
+        "Zone haute / élevée": [
+            f"> {thresholds['force_bw_high']:.2f} BW" if pd.notna(thresholds["force_bw_high"]) else "N/A",
+            f"> {thresholds['force_n_high']:.1f} N" if pd.notna(thresholds["force_n_high"]) else "N/A",
+            f"> {thresholds['pression_high']:.2f} N/cm²" if pd.notna(thresholds["pression_high"]) else "N/A",
+        ],
+    })
+
+    dynamique_df = pd.DataFrame({
+        "Variable": [
+            "Cadence",
+            "Temps de contact",
+            "Temps de vol",
+        ],
+        "Zone basse / faible": [
+            f"< {thresholds['cadence_low']:.1f} pas/min" if pd.notna(thresholds["cadence_low"]) else "N/A",
+            f"< {thresholds['contact_low']:.1f} %" if pd.notna(thresholds["contact_low"]) else "N/A",
+            f"< {thresholds['flight_low']:.1f} %" if pd.notna(thresholds["flight_low"]) else "N/A",
+        ],
+        "Zone attendue": [
+            f"{thresholds['cadence_low']:.1f} à {thresholds['cadence_high']:.1f} pas/min" if pd.notna(thresholds["cadence_low"]) and pd.notna(thresholds["cadence_high"]) else "N/A",
+            f"{thresholds['contact_low']:.1f} à {thresholds['contact_high']:.1f} %" if pd.notna(thresholds["contact_low"]) and pd.notna(thresholds["contact_high"]) else "N/A",
+            f"{thresholds['flight_low']:.1f} à {thresholds['flight_high']:.1f} %" if pd.notna(thresholds["flight_low"]) and pd.notna(thresholds["flight_high"]) else "N/A",
+        ],
+        "Zone haute / élevée": [
+            f"> {thresholds['cadence_high']:.1f} pas/min" if pd.notna(thresholds["cadence_high"]) else "N/A",
+            f"> {thresholds['contact_high']:.1f} %" if pd.notna(thresholds["contact_high"]) else "N/A",
+            f"> {thresholds['flight_high']:.1f} %" if pd.notna(thresholds["flight_high"]) else "N/A",
+        ],
+    })
+
+    symetrie_df = pd.DataFrame({
+        "Variable": [
+            "Asymétrie force talon",
+            "Asymétrie force avant-pied",
+            "Asymétrie COP",
+            "Différence rotation G/D",
+        ],
+        "Zone faible": [
+            f"< {thresholds['asym_talon_low']:.1f} %" if pd.notna(thresholds["asym_talon_low"]) else "N/A",
+            f"< {thresholds['asym_avant_low']:.1f} %" if pd.notna(thresholds["asym_avant_low"]) else "N/A",
+            f"< {thresholds['asym_cop_low']:.1f} %" if pd.notna(thresholds["asym_cop_low"]) else "N/A",
+            f"< {thresholds['rotation_low']:.1f}°" if pd.notna(thresholds["rotation_low"]) else "N/A",
+        ],
+        "Zone attendue / modérée": [
+            f"{thresholds['asym_talon_low']:.1f} à {thresholds['asym_talon_high']:.1f} %" if pd.notna(thresholds["asym_talon_low"]) and pd.notna(thresholds["asym_talon_high"]) else "N/A",
+            f"{thresholds['asym_avant_low']:.1f} à {thresholds['asym_avant_high']:.1f} %" if pd.notna(thresholds["asym_avant_low"]) and pd.notna(thresholds["asym_avant_high"]) else "N/A",
+            f"{thresholds['asym_cop_low']:.1f} à {thresholds['asym_cop_high']:.1f} %" if pd.notna(thresholds["asym_cop_low"]) and pd.notna(thresholds["asym_cop_high"]) else "N/A",
+            f"{thresholds['rotation_low']:.1f} à {thresholds['rotation_high']:.1f}°" if pd.notna(thresholds["rotation_low"]) and pd.notna(thresholds["rotation_high"]) else "N/A",
+        ],
+        "Zone haute / marquée": [
+            f"> {thresholds['asym_talon_high']:.1f} %" if pd.notna(thresholds["asym_talon_high"]) else "N/A",
+            f"> {thresholds['asym_avant_high']:.1f} %" if pd.notna(thresholds["asym_avant_high"]) else "N/A",
+            f"> {thresholds['asym_cop_high']:.1f} %" if pd.notna(thresholds["asym_cop_high"]) else "N/A",
+            f"> {thresholds['rotation_high']:.1f}°" if pd.notna(thresholds["rotation_high"]) else "N/A",
+        ],
+    })
+
+    s1, s2, s3 = st.tabs(["Impact", "Dynamique", "Symétrie"])
+    with s1:
+        st.dataframe(impact_df, hide_index=True, use_container_width=True)
+    with s2:
+        st.dataframe(dynamique_df, hide_index=True, use_container_width=True)
+    with s3:
+        st.dataframe(symetrie_df, hide_index=True, use_container_width=True)
+
+    st.write(
+        "Ces seuils sont individualisés à partir des données Zebris propres à l’athlète "
+        "et modulés par le volume horaire hebdomadaire."
+    )