Referência Técnica e Fórmulas

Implementação Matemática Completa

Guia de Implementação

Esta página fornece fórmulas prontas para copiar e métodos de cálculo passo a passo para todas as métricas do Swim Analytics. Use para implementações personalizadas, verificação ou compreensão mais profunda.

⚠️ Notas de Implementação

  • Todos os tempos devem ser convertidos para segundos para cálculos
  • Pace de natação é inverso (% maior = pace mais lento)
  • Sempre valide entradas para faixas razoáveis
  • Trate casos extremos (divisão por zero, valores negativos)

Métricas Principais de Desempenho

Critical Swim Speed (CSS)

Fórmula:

CSS (m/s) = (D₂ - D₁) / (T₂ - T₁)
CSS Pace/100m (segundos) = (T₄₀₀ - T₂₀₀) / 2

Implementação JavaScript:

function calculateCSS(distance1, time1, distance2, time2) {
  // Converter tempos para segundos se necessário
  const t1 = typeof time1 === 'string' ? timeToSeconds(time1) : time1;
  const t2 = typeof time2 === 'string' ? timeToSeconds(time2) : time2;

  // Calcular CSS em m/s
  const css_ms = (distance2 - distance1) / (t2 - t1);

  // Calcular pace por 100m em segundos
  const pace_per_100m = 100 / css_ms;

  // Converter para formato mm:ss
  const minutes = Math.floor(pace_per_100m / 60);
  const seconds = Math.round(pace_per_100m % 60);

  return {
    css_ms: css_ms,
    pace_seconds: pace_per_100m,
    pace_formatted: `${minutes}:${seconds.toString().padStart(2, '0')}`
  };
}

// Exemplo de uso:
const result = calculateCSS(200, 150, 400, 368);
// Retorna: { css_ms: 0.917, pace_seconds: 109, pace_formatted: "1:49" }

Swim Training Stress Score (sTSS)

Fórmula Completa:

sTSS = (IF³) × Duração (horas) × 100
IF = NSS / FTP
NSS = Distância Total / Tempo Total (m/min)

Implementação JavaScript:

function calculateSTSS(distance, timeMinutes, ftpMetersPerMin) {
  // Calcular Velocidade Normalizada de Natação
  const nss = distance / timeMinutes;

  // Calcular Fator de Intensidade
  const intensityFactor = nss / ftpMetersPerMin;

  // Calcular horas
  const hours = timeMinutes / 60;

  // Calcular sTSS usando fator de intensidade ao cubo
  const stss = Math.pow(intensityFactor, 3) * hours * 100;

  return Math.round(stss);
}

// Exemplo de uso:
const stss = calculateSTSS(3000, 55, 64.5);
// Retorna: 55

// Auxiliar: Converter CSS para FTP
function cssToFTP(cssPacePer100mSeconds) {
  // FTP em m/min = 100m / (pace em minutos)
  return 100 / (cssPacePer100mSeconds / 60);
}

// Exemplo: CSS de 1:33 (93 segundos)
const ftp = cssToFTP(93); // Retorna: 64.5 m/min

SWOLF

Fórmula:

SWOLF = Tempo da Piscina (segundos) + Contagem de Braçadas
SWOLF₂₅ = (Tempo × 25/Comprimento da Piscina) + (Braçadas × 25/Comprimento da Piscina)

Implementação JavaScript:

function calculateSWOLF(timeSeconds, strokeCount) {
  return timeSeconds + strokeCount;
}

function calculateNormalizedSWOLF(timeSeconds, strokeCount, poolLength) {
  const normalizedTime = timeSeconds * (25 / poolLength);
  const normalizedStrokes = strokeCount * (25 / poolLength);
  return normalizedTime + normalizedStrokes;
}

// Exemplo:
const swolf = calculateSWOLF(20, 15);
// Retorna: 35

const swolf50m = calculateNormalizedSWOLF(40, 30, 50);
// Retorna: 35 (normalizado para 25m)

Mecânica de Braçada

Taxa de Braçada (SR)

Fórmula:

SR = 60 / Tempo do Ciclo (segundos)
SR = (Número de Braçadas / Tempo em segundos) × 60

Implementação JavaScript:

function calculateStrokeRate(strokeCount, timeSeconds) {
  return (strokeCount / timeSeconds) * 60;
}

// Exemplo:
const sr = calculateStrokeRate(30, 25);
// Retorna: 72 SPM

Distância Por Braçada (DPS)

Fórmula:

DPS = Distância / Contagem de Braçadas

Implementação JavaScript:

function calculateDPS(distance, strokeCount, pushoffDistance = 0) {
  const effectiveDistance = distance - pushoffDistance;
  return effectiveDistance / strokeCount;
}

// Exemplo (piscina 25m, 5m de impulso):
const dps = calculateDPS(25, 12, 5);
// Retorna: 1.67 m/braçada

Índice de Braçada (SI)

Fórmula:

SI = Velocidade (m/s) × DPS (m/braçada)

Implementação JavaScript:

function calculateStrokeIndex(velocity, dps) {
  return velocity * dps;
}

// Exemplo:
const si = calculateStrokeIndex(1.5, 1.7);
// Retorna: 2.55

Gráfico de Gerenciamento de Desempenho (PMC)

Cálculos de CTL, ATL, TSB

Fórmulas:

CTL hoje = CTL ontem + (TSS hoje - CTL ontem) × (1/42)
ATL hoje = ATL ontem + (TSS hoje - ATL ontem) × (1/7)
TSB = CTL ontem - ATL ontem

Implementação JavaScript:

function updateCTL(previousCTL, todayTSS) {
  return previousCTL + (todayTSS - previousCTL) * (1/42);
}

function updateATL(previousATL, todayTSS) {
  return previousATL + (todayTSS - previousATL) * (1/7);
}

function calculateTSB(yesterdayCTL, yesterdayATL) {
  return yesterdayCTL - yesterdayATL;
}

// Calcular PMC para série de treinos
function calculatePMC(workouts) {
  let ctl = 0, atl = 0;
  const results = [];

  workouts.forEach(workout => {
    ctl = updateCTL(ctl, workout.tss);
    atl = updateATL(atl, workout.tss);
    const tsb = calculateTSB(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
    });
  });

  return results;
}

Recursos Relacionados

Explore a ciência por trás de cada métrica:

Calculadora CSS → Carga de Treino → Pesquisa Científica →