Radsport-Leistungsformeln

Formel:

Rechenbeispiel:

JavaScript-Implementierung:

function calculateTSS(durationSeconds, normalizedPower, ftp) {
  const intensityFactor = normalizedPower / ftp;
  const tss = (durationSeconds * normalizedPower * intensityFactor) / (ftp * 3600) * 100;
  return Math.round(tss);
}

// Beispielnutzung:
const tss = calculateTSS(7200, 235, 250);
// Gibt zurück: 177

Algorithmus (gleitender 30-Sekunden-Durchschnitt):

Warum die 4. Potenz?

Die quartische (4. Potenz) Beziehung spiegelt die nichtlinearen physiologischen Kosten variabler Anstrengungen breiter. Eine Fahrt mit Antritten und Erholungen kostet mehr Energie als konstante Leistung beim gleichen Durchschnitt.

JavaScript-Implementierung:

function calculateNormalizedPower(powerData) {
  // powerData ist Array von 1-Sekunden-Leistungswerten

  // Schritt 1: Berechne gleitende 30-Sekunden-Durchschnitte
  const rollingAvgs = [];
  for (let i = 29; i < powerData.length; i++) {
    const window = powerData.slice(i - 29, i + 1);
    const avg = window.reduce((sum, p) => sum + p, 0) / 30;
    rollingAvgs.push(avg);
  }

  // Schritt 2: Zur 4. Potenz erheben
  const powered = rollingAvgs.map(p => Math.pow(p, 4));

  // Schritt 3: Durchschnitt der 4. Potenzen
  const avgPowered = powered.reduce((sum, p) => sum + p, 0) / powered.length;

  // Schritt 4: 4. Wurzel ziehen
  const np = Math.pow(avgPowered, 0.25);

  return Math.round(np);
}

// Beispielnutzung:
const powerData = [/* 1-Sekunden-Leistungs-Array */];
const np = calculateNormalizedPower(powerData);
// Gibt zurück: NP in Watt

Formel:

Interpretationsbereiche:

Beispielrechnung:

function calculateIF(normalizedPower, ftp) {
  return (normalizedPower / ftp).toFixed(2);
}

// Beispiel:
const if_value = calculateIF(235, 250);
// Gibt zurück: 0.94

Formel:

Interpretation nach Disziplin:

Beispielrechnung:

function calculateVI(normalizedPower, averagePower) {
  return (normalizedPower / averagePower).toFixed(2);
}

// Beispiel:
const vi_road = calculateVI(240, 230);  // Gibt zurück: 1.04
const vi_mtb = calculateVI(285, 235);   // Gibt zurück: 1.21

Formel:

Berechnung aus mehreren Anstrengungen:

Erfordert 2-4 maximale Anstrengungen bei verschiedenen Dauern (z.B. 3, 5, 12, 20 Minuten)

JavaScript-Implementierung:

function calculateCP_Linear(efforts) {
  // efforts = [{duration: seconds, power: watts}, ...]

  const times = efforts.map(e => e.duration);
  const work = efforts.map(e => e.power * e.duration / 1000); // kJ

  // Lineare Regression: work = CP * time + W'
  const n = efforts.length;
  const sumT = times.reduce((a, b) => a + b, 0);
  const sumW = work.reduce((a, b) => a + b, 0);
  const sumTW = times.reduce((sum, t, i) => sum + t * work[i], 0);
  const sumTT = times.reduce((sum, t) => sum + t * t, 0);

  const CP = (n * sumTW - sumT * sumW) / (n * sumTT - sumT * sumT);
  const Wprime = (sumW - CP * sumT) / n;

  return {
    CP: Math.round(CP * 10) / 10,      // Watt
    Wprime: Math.round(Wprime * 10) / 10  // kJ
  };
}

// Beispielnutzung:
const efforts = [
  {duration: 180, power: 400},
  {duration: 300, power: 365},
  {duration: 720, power: 310},
  {duration: 1200, power: 285}
];

const result = calculateCP_Linear(efforts);
// Gibt zurück: { CP: 270.0, Wprime: 18.5 }

Formeln:

Beispiel aus der Praxis:

JavaScript-Implementierung:

function calculateWbalance(powerData, CP, Wprime) {
  // powerData = Array von {time: seconds, power: watts}
  let wbal = Wprime * 1000; // In Joule umwandeln
  const wbalHistory = [];

  for (let i = 1; i < powerData.length; i++) {
    const dt = powerData[i].time - powerData[i-1].time;
    const power = powerData[i].power;

    if (power > CP) {
      // Verbrauch über CP
      const expenditure = (power - CP) * dt;
      wbal -= expenditure;
    } else {
      // Erholung unter CP
      const deltaCP = CP - power;
      const tau = 546 * Math.exp(-0.01 * deltaCP) + 316;
      const recovery = (Wprime * 1000 - wbal) * (1 - Math.exp(-dt / tau));
      wbal += recovery;
    }

    // Sicherstellen, dass W'bal nicht Max überschreitet oder negativ wird
    wbal = Math.max(0, Math.min(wbal, Wprime * 1000));

    wbalHistory.push({
      time: powerData[i].time,
      wbal: wbal / 1000, // kJ
      percent: (wbal / (Wprime * 1000)) * 100
    });
  }

  return wbalHistory;
}

// Beispielnutzung:
const powerData = [
  {time: 0, power: 200},
  {time: 1, power: 210},
  // ... Rest der Fahrdaten
];

const wbalHistory = calculateWbalance(powerData, 270, 18.5);
// Gibt Array von W'bal-Werten über die Zeit zurück

Formeln (Exponentiell gewichtete gleitende Durchschnitte):

Metrik-Definitionen:

• CTL (Chronic Training Load):42-Tage exponentiell gewichteter Durchschnitt - repräsentiert Fitness
• ATL (Acute Training Load):7-Tage exponentiell gewichteter Durchschnitt - bezieht sich auf Ermüdung
• TSB (Training Stress Balance):Form = Fitness - Ermüdung

Rechenbeispiel (7-Tage-Trainingsblock):

TSB-Interpretation:

JavaScript-Implementierung:

function calculatePMC(workouts) {
  // workouts = [{date: "YYYY-MM-DD", tss: number}, ...]
  let ctl = 0, atl = 0;
  const results = [];

  workouts.forEach(workout => {
    // Update CTL (42-Tage Zeitkonstante)
    ctl = ctl + (workout.tss - ctl) / 42;

    // Update ATL (7-Tage Zeitkonstante)
    atl = atl + (workout.tss - atl) / 7;

    // Berechne TSB (CTL von gestern - ATL von heute für traditionelle Berechnung)
    // Der Einfachheit halber hier aktuelle Werte
    const tsb = ctl - atl;

    results.push({
      date: workout.date,
      tss: workout.tss,
      ctl: Math.round(ctl * 10) / 10,
      atl: Math.round(atl * 10) / 10,
      tsb: Math.round(tsb * 10) / 10,
      status: getTSBStatus(tsb)
    });
  });

  return results;
}

function getTSBStatus(tsb) {
  if (tsb < -30) return "High Risk";
  if (tsb < -10) return "Training Hard";
  if (tsb < 5) return "Optimal";
  if (tsb < 15) return "Race Ready";
  return "Detraining";
}

// Beispielnutzung:
const workouts = [
  {date: "2025-01-01", tss: 100},
  {date: "2025-01-02", tss: 50},
  {date: "2025-01-03", tss: 120},
  // ... mehr Workouts
];

const pmc = calculatePMC(workouts);
// Gibt Array mit CTL, ATL, TSB für jeden Tag zurück

Formel:

FTP W/kg Benchmarks:

Beispielrechnung:

function calculateWattsPerKg(power, bodyMassKg) {
  return (power / bodyMassKg).toFixed(2);
}

// Beispiel:
const wpkg = calculateWattsPerKg(275, 70);
// Gibt zurück: 3.93

Formel:

VAM Benchmarks:

Beispielrechnung:

function calculateVAM(elevationGainMeters, timeMinutes) {
  const hours = timeMinutes / 60;
  return Math.round(elevationGainMeters / hours);
}

// Beispiel:
const vam = calculateVAM(1100, 55);
// Gibt zurück: 1200 m/h

Formel:

Beispielrechnung:

function estimateWkgFromVAM(vam, gradientPercent) {
  return (vam / 100 / (gradientPercent + 3)).toFixed(2);
}

// Beispiel:
const wkg = estimateWkgFromVAM(1200, 8);
// Gibt zurück: 4.36

Vollständige Formel:

Komponentenformeln:

Konstanten & Variablen:

• CdA= Luftwiderstandsbeiwert × Stirnfläche (m²)
  • Typische Rennrad-Bremsgriffe: 0,35-0,40 m²
  • Unterlenker: 0,32-0,37 m²
  • TT-Position: 0,20-0,25 m²
• ρ= Luftdichte (1,225 kg/m³ auf Meereshöhe, 15°C)
• V= Geschwindigkeit (m/s)
• m= Gesamtmasse (Fahrer + Fahrrad, kg)
• g= Schwerkraft (9,81 m/s²)
• θ= Steigungswinkel (Bogenmaß oder Grad umgerechnet)
• Crr= Rollwiderstandskoeffizient (~0,004 für gute Rennreifen)
• a= Beschleunigung (m/s²)

Rechenbeispiel (Flache Straße TT):

JavaScript-Implementierung:

function calculatePowerRequired(params) {
  const {
    velocityKph,
    CdA = 0.32,              // m²
    rho = 1.225,             // kg/m³
    mass = 83,               // kg (rider + bike)
    gradientPercent = 0,     // %
    Crr = 0.004,             // rolling resistance
    accelerationMps2 = 0     // m/s²
  } = params;

  // Convert velocity to m/s
  const V = velocityKph / 3.6;

  // Convert gradient to angle
  const theta = Math.atan(gradientPercent / 100);

  // Calculate each component
  const P_aero = CdA * 0.5 * rho * Math.pow(V, 3);
  const P_gravity = mass * 9.81 * Math.sin(theta) * V;
  const P_rolling = Crr * mass * 9.81 * Math.cos(theta) * V;
  const P_kinetic = mass * accelerationMps2 * V;

  return {
    total: Math.round(P_aero + P_gravity + P_rolling + P_kinetic),
    aero: Math.round(P_aero),
    gravity: Math.round(P_gravity),
    rolling: Math.round(P_rolling),
    kinetic: Math.round(P_kinetic)
  };
}

// Example: TT at 40 km/h
const power_tt = calculatePowerRequired({
  velocityKph: 40,
  CdA: 0.22,
  mass: 83,
  gradientPercent: 0
});
// Returns: { total: 221, aero: 185, gravity: 0, rolling: 36, kinetic: 0 }

// Example: 8% climb at 15 km/h
const power_climb = calculatePowerRequired({
  velocityKph: 15,
  CdA: 0.38,
  mass: 75,
  gradientPercent: 8
});
// Returns: { total: 265, aero: 27, gravity: 244, rolling: 11, kinetic: 0 }

JavaScript-Implementierung:

// Time conversions
function hoursToSeconds(hours) {
  return hours * 3600;
}

function minutesToSeconds(minutes) {
  return minutes * 60;
}

function secondsToHours(seconds) {
  return seconds / 3600;
}

function formatDuration(seconds) {
  const hours = Math.floor(seconds / 3600);
  const minutes = Math.floor((seconds % 3600) / 60);
  const secs = Math.round(seconds % 60);
  return `${hours}:${minutes.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`;
}

// Speed conversions
function kphToMps(kph) {
  return kph / 3.6;
}

function mpsToKph(mps) {
  return mps * 3.6;
}

// Energy conversions
function joulesToKJ(joules) {
  return joules / 1000;
}

function kJToJoules(kJ) {
  return kJ * 1000;
}

function wattsToKJ(watts, durationSeconds) {
  return (watts * durationSeconds) / 1000;
}

// Examples:
formatDuration(7265);        // Returns: "2:01:05"
kphToMps(40);                // Returns: 11.11 m/s
wattsToKJ(250, 3600);        // Returns: 900 kJ (1 hour at 250W)