Fórmulas de Potência em Ciclismo

Fórmula:

Cálculo a partir de Vários Esforços:

Requer 2–4 esforços máximos a durações diferentes (por exemplo, 3, 5, 12, 20 minutos).

Implementação em JavaScript:

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

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

  // Regressão linear: trabalho = CP * tempo + 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,        // watts
    Wprime: Math.round(Wprime * 10) / 10 // kJ
  };
}

// Exemplo de utilização:
const efforts = [
  {duration: 180, power: 400},
  {duration: 300, power: 365},
  {duration: 720, power: 310},
  {duration: 1200, power: 285}
];

const result = calculateCP_Linear(efforts);
// Devolve: { CP: 270.0, Wprime: 18.5 }

Ideia Geral:

W' representa a “bateria anaeróbica” – trabalho que podes realizar acima da CP antes da exaustão. W'bal acompanha em tempo real quanto dessa bateria ainda está disponível.

Princípios:

• Quando a potência > CP ⇒ gastas W'
• Quando a potência < CP ⇒ W' recupera gradualmente
• A velocidade de recuperação depende de quão abaixo da CP estás e do tempo

Equação Diferencial Simplificada (modelo Skiba):

Na prática, implementa‑se numericamente com um ciclo sobre os dados de potência de 1 segundo.

O Bike Analytics segue modelos validados na literatura (Monod & Scherrer; Jones 2019) para representar a relação entre potência máxima sustentável e duração do esforço.

Exemplo de Ajuste Exponencial:

Ajustar esta função a vários recordes de potência ao longo do tempo fornece estimativas robustas de CP e W', bem como previsões de tempo até à exaustão para potências específicas.

Fórmula (média móvel exponencial de 42 dias):

Representa a carga de treino crónica (forma). Aumenta lentamente com TSS consistente; cai lentamente em períodos de descanso.

Fórmula (média móvel exponencial de 7 dias):

Representa a carga de treino aguda (fadiga). Reage rapidamente a mudanças de volume/intensidade.

Fórmula:

TSB positivo indica frescura; TSB muito negativo indica fadiga acumulada.

Implementação em JavaScript (CTL/ATL/TSB juntos):

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

  workouts.forEach(workout => {
    // Atualizar CTL (constante de tempo de 42 dias)
    ctl = ctl + (workout.tss - ctl) / 42;

    // Atualizar ATL (constante de tempo de 7 dias)
    atl = atl + (workout.tss - atl) / 7;

    // Calcular TSB (aqui simplificado)
    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 "Risco Elevado";
  if (tsb < -10) return "Treino Intenso";
  if (tsb < 5) return "Ótimo";
  if (tsb < 15) return "Pronto para Competir";
  return "Desadaptação";
}

Fórmula:

Referências de FTP em W/kg:

Exemplo de Cálculo:

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

// Exemplo:
const wpkg = calculateWattsPerKg(275, 70);
// Devolve: 3.93

Fórmula:

Referências de VAM:

Exemplo de Cálculo:

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

// Exemplo:
const vam = calculateVAM(1100, 55);
// Devolve: 1200 m/h

Fórmula aproximada:

Esta aproximação assume densidade do ar, Crr e massa constantes. Útil para estimar W/kg de subidas famosas com base em tempos registados.

Equação de Potência:

Implementação em JavaScript:

function calculatePowerRequired(params) {
  const {
    velocityKph,
    CdA = 0.32,              // m²
    rho = 1.225,             // kg/m³
    mass = 83,               // kg (ciclista + bicicleta)
    gradientPercent = 0,     // %
    Crr = 0.004,             // resistência de rolamento
    accelerationMps2 = 0     // m/s²
  } = params;

  // Converter velocidade para m/s
  const V = velocityKph / 3.6;

  // Converter inclinação em ângulo
  const theta = Math.atan(gradientPercent / 100);

  // Calcular cada componente
  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)
  };
}

// Exemplo: contrarrelógio a 40 km/h
const power_tt = calculatePowerRequired({
  velocityKph: 40,
  CdA: 0.22,
  mass: 83,
  gradientPercent: 0
});
// Devolve: { total: 221, aero: 185, gravity: 0, rolling: 36, kinetic: 0 }

// Exemplo: subida de 8% a 15 km/h
const power_climb = calculatePowerRequired({
  velocityKph: 15,
  CdA: 0.38,
  mass: 75,
  gradientPercent: 8
});
// Devolve: { total: 265, aero: 27, gravity: 244, rolling: 11, kinetic: 0 }