Riferimento Tecnico e Formule

Guida all'Implementazione

Questa pagina fornisce formule copia-incolla e metodi di calcolo passo-passo per tutte le metriche Run Analytics. Usale per implementazioni personalizzate, verifica, o comprensione più profonda.

⚠️ Note di Implementazione

Tutti i tempi dovrebbero essere convertiti in secondi per i calcoli
Il ritmo di corsa è inverso (% più alta = ritmo più lento)
Valida sempre gli input per range ragionevoli
Gestisci casi limite (divisione per zero, valori negativi)

Metriche Prestazioni Principali

Critical Run Speed (CRS)

Formula:

CRS (m/s) = (D₂ - D₁) / (T₂ - T₁)

Ritmo CRS/100m (secondi) = (T₄₀₀ - T₂₀₀) / 2

🧪 Calcolatore Interattivo - Testa la Formula

Distanza 1 (metri):

Tempo 1 (mm:ss):

Distanza 2 (metri):

Tempo 2 (mm:ss):

Implementazione JavaScript:

function calculateCRS(distance1, time1, distance2, time2) {
    // Converti tempi in secondi se necessario
    const t1_seconds = typeof time1 === 'string' ? timeToSeconds(time1) : time1;
    const t2_seconds = typeof time2 === 'string' ? timeToSeconds(time2) : time2;
    
    // Calcola CRS in m/s
    const crs_ms = (distance2 - distance1) / (t2_seconds - t1_seconds);
    
    // Converti in ritmo per 100m
    const pace_per_100m = 100 / crs_ms;
    
    return {
        crs_ms: crs_ms,
        pace_per_100m: pace_per_100m,
        pace_per_km: pace_per_100m * 10,
        pace_per_mile: pace_per_100m * 16.09344
    };
}

function timeToSeconds(timeString) {
    const [minutes, seconds] = timeString.split(':').map(Number);
    return minutes * 60 + seconds;
}

Validazione Input:

function validateCRSInputs(d1, t1, d2, t2) {
    // Controlla che d2 > d1
    if (d2 <= d1) throw new Error("Distanza 2 deve essere maggiore di Distanza 1");
    
    // Controlla che t2 > t1
    if (t2 <= t1) throw new Error("Tempo 2 deve essere maggiore di Tempo 1");
    
    // Controlla range ragionevoli
    if (d1 < 50 || d1 > 2000) throw new Error("Distanza 1 fuori range (50-2000m)");
    if (d2 < 100 || d2 > 5000) throw new Error("Distanza 2 fuori range (100-5000m)");
    
    // Controlla che i ritmi siano ragionevoli (non più lenti di 10 min/km)
    const pace1 = t1 / (d1 / 1000);
    const pace2 = t2 / (d2 / 1000);
    if (pace1 > 600 || pace2 > 600) throw new Error("Ritmo troppo lento");
    
    return true;
}

Training Stress Score (TSS)

Formula:

TSS = (Durata_secondi × IF²) / 36

IF = Ritmo_Normalizzato / CRS_Ritmo

Implementazione JavaScript:

function calculateTSS(duration_seconds, normalized_pace, crs_pace) {
    // Calcola Intensity Factor (IF)
    const intensity_factor = normalized_pace / crs_pace;
    
    // Calcola TSS
    const tss = (duration_seconds * Math.pow(intensity_factor, 2)) / 36;
    
    return Math.round(tss);
}

function calculateNormalizedPace(paces, durations) {
    // Per corse a ritmo costante, NP = ritmo medio
    // Per corse con variazioni, usa media ponderata
    let total_weighted_pace = 0;
    let total_duration = 0;
    
    for (let i = 0; i < paces.length; i++) {
        total_weighted_pace += paces[i] * durations[i];
        total_duration += durations[i];
    }
    
    return total_weighted_pace / total_duration;
}

Zone di Allenamento

Formule Zone (basate su CRS):

Zona 1: > 129% CRS (Recupero Attivo)

Zona 2: 114-129% CRS (Base Aerobica)

Zona 3: 106-113% CRS (Aerobico)

Zona 4: 100-105% CRS (Soglia)

Zona 5: < 100% CRS (VO2max)

Implementazione JavaScript:

function calculateTrainingZones(crs_pace_per_km) {
    return {
        zone1: {
            name: "Recupero Attivo",
            min_pace: crs_pace_per_km * 1.29,
            max_pace: Infinity,
            percentage: "129%+"
        },
        zone2: {
            name: "Base Aerobica", 
            min_pace: crs_pace_per_km * 1.14,
            max_pace: crs_pace_per_km * 1.29,
            percentage: "114-129%"
        },
        zone3: {
            name: "Aerobico",
            min_pace: crs_pace_per_km * 1.06,
            max_pace: crs_pace_per_km * 1.13,
            percentage: "106-113%"
        },
        zone4: {
            name: "Soglia",
            min_pace: crs_pace_per_km * 1.00,
            max_pace: crs_pace_per_km * 1.05,
            percentage: "100-105%"
        },
        zone5: {
            name: "VO2max",
            min_pace: 0,
            max_pace: crs_pace_per_km * 1.00,
            percentage: "<100%"
        }
    };
}

function getZoneForPace(pace, zones) {
    for (const [zoneNum, zone] of Object.entries(zones)) {
        if (pace >= zone.min_pace && pace <= zone.max_pace) {
            return {
                zone: zoneNum,
                name: zone.name,
                percentage: zone.percentage
            };
        }
    }
    return null;
}

Performance Management Chart (PMC)

Formule:

CTL_oggi = CTL_ieri + (TSS_oggi - CTL_ieri) / 42

ATL_oggi = ATL_ieri + (TSS_oggi - ATL_ieri) / 7

TSB_oggi = CTL_ieri - ATL_oggi

Implementazione JavaScript:

function calculatePMC(tss_history) {
    let ctl = 0;
    let atl = 0;
    const pmc_data = [];
    
    for (let i = 0; i < tss_history.length; i++) {
        const tss_today = tss_history[i] || 0;
        
        // Calcola CTL (Chronic Training Load) - 42 giorni
        ctl = ctl + (tss_today - ctl) / 42;
        
        // Calcola ATL (Acute Training Load) - 7 giorni  
        atl = atl + (tss_today - atl) / 7;
        
        // Calcola TSB (Training Stress Balance)
        const tsb = ctl - atl;
        
        pmc_data.push({
            date: i,
            tss: tss_today,
            ctl: Math.round(ctl * 10) / 10,
            atl: Math.round(atl * 10) / 10,
            tsb: Math.round(tsb * 10) / 10
        });
    }
    
    return pmc_data;
}

Metriche Biomeccaniche

Meccanica del Passo

Formule:

Frequenza Passo (spm) = Passi / (Tempo_minuti / 2)

Lunghezza Passo (m) = Distanza / Numero_Passi

DPS = Distanza_per_Passo (metri)

Implementazione JavaScript:

function calculateStrideMetrics(distance_m, duration_s, steps) {
    // Calcola frequenza passo (passi per minuto)
    const cadence = (steps / (duration_s / 60));
    
    // Calcola lunghezza passo
    const stride_length = distance_m / steps;
    
    // Calcola DPS (Distance Per Stride)
    const dps = stride_length;
    
    // Calcola velocità da cadenza e lunghezza passo
    const speed_ms = (cadence / 60) * stride_length;
    
    return {
        cadence: Math.round(cadence),
        stride_length: Math.round(stride_length * 100) / 100,
        dps: Math.round(dps * 100) / 100,
        speed_ms: Math.round(speed_ms * 100) / 100
    };
}

Utilità e Conversioni

Conversioni Tempo e Ritmo

Implementazione JavaScript:

// Converti mm:ss in secondi
function timeToSeconds(timeString) {
    const parts = timeString.split(':');
    if (parts.length === 2) {
        return parseInt(parts[0]) * 60 + parseInt(parts[1]);
    } else if (parts.length === 3) {
        return parseInt(parts[0]) * 3600 + parseInt(parts[1]) * 60 + parseInt(parts[2]);
    }
    return 0;
}

// Converti secondi in mm:ss
function secondsToTime(seconds) {
    const mins = Math.floor(seconds / 60);
    const secs = Math.floor(seconds % 60);
    return `${mins}:${secs.toString().padStart(2, '0')}`;
}

// Converti ritmo per km in velocità m/s
function paceToSpeed(pace_per_km_seconds) {
    return 1000 / pace_per_km_seconds;
}

// Converti velocità m/s in ritmo per km
function speedToPace(speed_ms) {
    return 1000 / speed_ms;
}

// Converti miglia in km
function milesToKm(miles) {
    return miles * 1.609344;
}

// Converti km in miglia
function kmToMiles(km) {
    return km / 1.609344;
}