Formler for sykkelkraft

Formel:

Eksempel:

JavaScript-implementering:

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

// Eksempel:
const tss = calculateTSS(7200, 235, 250);
// Returnerer: 177

Algoritme (30-sekunders glidende gjennomsnitt):

Hvorfor fjerde potens?

Forholdet i fjerde potens gjenspeiler den ikke-lineære fysiologiske belastningen av varierende innsats. En tur med rykk og restitusjon koster mer energi enn jevn kraft ved samme gjennomsnitt.

JavaScript-implementering:

function calculateNormalizedPower(powerData) {
  // powerData er en array med 1-sekunds kraftverdier

  // Trinn 1: Beregn 30-sekunders glidende gjennomsnitt
  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);
  }

  // Trinn 2: Opphøy i 4. potens
  const powered = rollingAvgs.map(p => Math.pow(p, 4));

  // Trinn 3: Gjennomsnitt av 4. potenser
  const avgPowered = powered.reduce((sum, p) => sum + p, 0) / powered.length;

  // Trinn 4: Ta fjerderoten
  const np = Math.pow(avgPowered, 0.25);

  return Math.round(np);
}

// Eksempel:
const powerData = [/* 1-sekunds kraft-array */];
const np = calculateNormalizedPower(powerData);
// Returnerer: NP i watt

Formel:

Tolkningsområder:

Eksempel:

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

// Eksempel:
const if_value = calculateIF(235, 250);
// Returnerer: 0.94

Formel:

Tolkning etter disiplin:

Eksempel:

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

// Eksempel:
const vi_road = calculateVI(240, 230);  // Returnerer: 1.04
const vi_mtb = calculateVI(285, 235);   // Returnerer: 1.21

Formler (Eksponensielt veide glidende gjennomsnitt):

Definisjoner:

• CTL (Chronic Training Load): 42-dagers eksponensielt vektet gjennomsnitt – representerer form/fitness
• ATL (Acute Training Load): 7-dagers eksponensielt vektet gjennomsnitt – representerer tretthet
• TSB (Training Stress Balance): Overskudd = Form - Tretthet

Eksempel (7-dagers treningsblokk):

Tolkning av TSB:

JavaScript-implementering:

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

  workouts.forEach(workout => {
    // Oppdater CTL (42 dagers tidskonstant)
    ctl = ctl + (workout.tss - ctl) / 42;

    // Oppdater ATL (7 dagers tidskonstant)
    atl = atl + (workout.tss - atl) / 7;

    // Beregn TSB (gårdsdagens CTL - dagens ATL for tradisjonell beregning)
    // For enkelhets skyld bruker vi gjeldende verdier her
    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 "Høy risiko";
  if (tsb < -10) return "Hard trening";
  if (tsb < 5) return "Optimalt";
  if (tsb < 15) return "Klar for ritt";
  return "Formfall";
}

// Eksempel:
const workouts = [
  {date: "2025-01-01", tss: 100},
  {date: "2025-01-02", tss: 50},
  {date: "2025-01-03", tss: 120},
  // ... flere økter
];

const pmc = calculatePMC(workouts);
// Returnerer array med CTL, ATL, TSB for hver dag

Fullstendig formel:

Formler for hver komponent:

Konstanter og variabler:

• CdA = Luftmotstandskoeffisient × frontareal (m²)
  • Vanlig landeveissykkel (hendlene): 0,35–0,40 m²
  • I bukken: 0,32–0,37 m²
  • Tempoposisjon: 0,20–0,25 m²
• ρ = Lufttetthet (1,225 kg/m³ ved havnivå, 15 °C)
• V = Hastighet (m/s)
• m = Total masse (rytter + sykkel, kg)
• g = Tyngdeakselerasjon (9,81 m/s²)
• θ = Stigningsvinkel (radianer eller grader konvertert)
• Crr = Rullemotstandskoeffisient (~0,004 for gode landeveisdekk)
• a = Akselerasjon (m/s²)

Eksempel (Tempo på flat vei):

JavaScript-implementering:

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

  // Konverter hastighet til m/s
  const V = velocityKph / 3.6;

  // Konverter stigning til vinkel
  const theta = Math.atan(gradientPercent / 100);

  // Beregn hver komponent
  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)
  };
}

// Eksempel: Tempo i 40 km/t
const power_tt = calculatePowerRequired({
  velocityKph: 40,
  CdA: 0.22,
  mass: 83,
  gradientPercent: 0
});
// Returnerer: { total: 221, aero: 185, gravity: 0, rolling: 36, kinetic: 0 }

// Eksempel: 8 % klatring i 15 km/t
const power_climb = calculatePowerRequired({
  velocityKph: 15,
  CdA: 0.38,
  mass: 75,
  gradientPercent: 8
});
// Returnerer: { total: 265, aero: 27, gravity: 244, rolling: 11, kinetic: 0 }