Formler för cykelkraft

Formel:

Arbetat exempel:

JavaScript-implementering:

funktion beräknaTSS(durationSeconds, normalizedPower, FTP) {
  const intensityFactor = normalizedPower / FTP;
  const TSS = (durationSeconds * normalizedPower * intensityFactor) / (FTP * 3600) * 100;
  return Math.round(TSS);
}

// Exempel på användning:
const TSS = beräknaTSS(7200, 235, 250);
// Returnerar: 177

Algoritm (30-sekunders rullande medelvärde):

Varför den 4:e makten?

Det kvartiga (4:e potens) förhållandet återspeglar den icke-linjära fysiologiska kostnaden för variabla ansträngningar. En tur med överspänningar och återhämtning kostar mer energi än jämn kraft vid samma genomsnitt.

JavaScript-implementering:

function calculateNormalizedPower(powerData) {
  // powerData är en matris med 1-sekunds effektvärden

  // Steg 1: Beräkna 30-sekunders rullande medelvärden
  const rollingAvgs = [];
  for (låt i = 29; i < powerData.length; i++) {
    const window = powerData.slice(i - 29, i + 1);
    const avg = window.reduce((summa, p) => summa + p, 0) / 30;
    rollingAvgs.push(avg);
  }

  // Steg 2: Höj till 4:e potens
  const powered = rollingAvgs.map(p => Math.pow(p, 4));

  // Steg 3: Genomsnitt av 4:e potenser
  const avgPowered = powered.reduce((summa, p) => summa + p, 0) / powered.length;

  // Steg 4: Ta 4:e roten
  const np = Math.pow(avgPowered, 0,25);

  return Math.round(np);
}

// Exempel på användning:
const powerData = [/* 1-sekunds power array */];
const np = calculateNormalizedPower(powerData);
// Returnerar: NP i watt

Formel:

Tolkningsintervall:

Exempel på beräkning:

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

// Exempel:
const if_value = calculateIF(235, 250);
// Returnerar: 0,94

Formel:

Tolkning efter disciplin:

Exempel på beräkning:

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

// Exempel:
const vi_väg = beräknaVI(240, 230);  // Returnerar: 1,04
const vi_mtb = beräknaVI(285, 235);   // Returnerar: 1,21

Formler (exponentiellt vägda glidande medelvärden):

Metriska definitioner:

• CTL (kronisk träningsbelastning):42-dagars exponentiellt vägt medelvärde - representerar kondition
• ATL (akut träningsbelastning):7-dagars exponentiellt vägt medelvärde - representerar trötthet
• TSB (träning av stressbalans):Form = Fitness - Trötthet

Arbetat exempel (7-dagars träningsblock):

TSB Tolkning:

JavaScript-implementering:

function calculatePMC(workouts) {
  // träningspass = [{datum: "ÅÅÅÅ-MM-DD", TSS: nummer}, ...]
  låt CTL = 0, ATL = 0;
  const resultat = [];

  workouts.forEach(workout => {
    // Uppdatera CTL (42-dagars tidskonstant)
    CTL = CTL + (träningspass.TSS - CTL) / 42;

    // Uppdatera ATL (7-dagars tidskonstant)
    ATL = ATL + (träningspass.TSS - ATL) / 7;

    // Beräkna TSB (gårdagens CTL - dagens ATL för traditionell beräkning)
    // För enkelhetens skull här med aktuella värden
    const TSB = CTL - ATL;

    results.push({
      datum: workout.date,
      TSS: träning.TSS,
      CTL: Math.round(CTL * 10) / 10,
      ATL: Math.round(ATL * 10) / 10,
      TSB: Math.round(TSB * 10) / 10,
      status: getTSBStatus(TSB)
    });
  });

  returnera resultat;
}

function getTSBStatus(TSB) {
  IF (TSB < -30) returnerar "Hög risk";
  IF (TSB < -10) returnera "Tränar hårt";
  IF (TSB < 5) returnera "Optimal";
  IF (TSB < 15) returnerar "Race Ready";
  returnera "Utbildning";
}

// Exempel på användning:
konstant träning = [
  {datum: "2025-01-01", TSS: 100},
  {datum: "2025-01-02", TSS: 50},
  {datum: "2025-01-03", TSS: 120},
  // ... fler träningspass
];

const PMC = beräknaPMC(träningspass);
// Returnerar array med CTL, ATL, TSB för varje dag

Komplett formel:

Komponentformler:

Konstanter och variabler:

• CdA= Drakoefficient × frontarea (m²)
  • Typiska motorcykelhuvar: 0,35-0,40 m²
  • Fall: 0,32-0,37 m²
  • TT-läge: 0,20-0,25 m²
• ρ= Luftdensitet (1,225 kg/m³ vid havsnivå, 15°C)
• V= Hastighet (m/s)
• m= Total massa (ryttare + cykel, kg)
• g= Tyngdkraften (9,81 m/s²)
• θ= Gradientvinkel (radianer eller grader konverterade)
• Crr= Rullmotståndskoefficient (~0,004 för bra vägdäck)
• a= Acceleration (m/s²)

Arbetat exempel (Flat Road TT):

JavaScript-implementering:

function calculatePowerRequired(params) {
  const {
    hastighet Kph,
    CdA = 0,32, //m²
    rho = 1,225, // kg/m³
    massa = 83, // kg (ryttare + cykel)
    gradientProcent = 0, // %
    Crr = 0,004, // rullmotstånd
    accelerationMps2 = 0 // m/s²
  } = params;

  // Konvertera hastighet till m/s
  const V = hastighet Kph / 3,6;

  // Konvertera gradient till vinkel
  const theta = Math.atan(gradientPercent / 100);

  // Beräkna varje komponent
  const P_aero = CdA * 0,5 * rho * Math.pow(V, 3);
  const P_gravity = massa * 9,81 * Math.sin(theta) * V;
  const P_rolling = Crr * massa * 9,81 * Math.cos(theta) * V;
  const P_kinetic = massa * accelerationMps2 * V;

  returnera {
    totalt: 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)
  };
}

// Exempel: TT i 40 km/h
const power_tt = calculatePowerRequired({
  hastighet Kph: 40,
  CdA: 0,22,
  vikt: 83,
  gradientProcent: 0
});
// Returnerar: { totalt: 221, aero: 185, gravitation: 0, rullande: 36, kinetisk: 0 }

// Exempel: 8% klättring i 15 km/h
const power_climb = calculatePowerRequired({
  hastighet Kph: 15,
  CdA: 0,38,
  vikt: 75,
  gradientProcent: 8
});
// Returnerar: { totalt: 265, aero: 27, gravitation: 244, rullande: 11, kinetisk: 0 }