Teknisk referens & formler

Formel:

JavaScript-implementering:

function calculateCRS(distance1, time1, distance2, time2) {
  // Convert times to seconds if needed
  const t1 = typeof time1 === 'string' ? timeToSeconds(time1) : time1;
  const t2 = typeof time2 === 'string' ? timeToSeconds(time2) : time2;

  // Calculate CRS in m/s
  const css_ms = (distance2 - distance1) / (t2 - t1);

  // Calculate pace per km in seconds
  const pace_per_km = 1000 / css_ms;

  // Convert to mm:ss format
  const minutes = Math.floor(pace_per_km / 60);
  const seconds = Math.round(pace_per_km % 60);

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

// Example usage:
const result = calculateCRS(1200, 252, 3600, 864);
// Returns: { css_ms: 3.922, pace_seconds: 255, pace_formatted: "4:15" }

Komplett formel:

JavaScript-implementering:

function calculateSTSS(distance, timeMinutes, thresholdSpeedMetersPerMin) {
  // Calculate Normalized Run Speed
  const nss = distance / timeMinutes;

  // Calculate Intensity Factor
  const intensityFactor = nss / thresholdSpeedMetersPerMin;

  // Calculate hours
  const hours = timeMinutes / 60;

  // Calculate sTSS using cubed intensity factor
  const stss = Math.pow(intensityFactor, 3) * hours * 100;

  return Math.round(stss);
}

// Example usage:
const stss = calculateSTSS(10000, 50, 235.3);
// Returns: 61

// Helper: Convert CRS pace to speed
function crsPaceToSpeed(crsPacePerKmSeconds) {
  // Speed in m/min = 1000m / (pace in minutes)
  return 1000 / (crsPacePerKmSeconds / 60);
}

// Example: CRS of 4:15 (255 seconds)
const speed = crsPaceToSpeed(255); // Returns: 235.3 m/min

Formel:

JavaScript-implementering:

function calculateVerticalRatio(verticalOscillationCm, strideLengthMeters) {
  const oscillationMeters = verticalOscillationCm / 100;
  return (oscillationMeters / strideLengthMeters) * 100;
}

// Exempel:
const vr = calculateVerticalRatio(8.5, 1.05);
// Returnerar: 8.1%

Formler:

JavaScript-implementering:

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;
}

// Calculate PMC for series of workouts
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;
}

// Example usage:
const workouts = [
  { date: '2025-01-01', tss: 50 },
  { date: '2025-01-02', tss: 60 },
  { date: '2025-01-03', tss: 45 },
  // ... more workouts
];

const pmc = calculatePMC(workouts);
// Returns array with CTL, ATL, TSB for each day

JavaScript-implementering:

function validateWorkoutData(workout) {
  const issues = [];

  // Check for reasonable pace ranges (3:00-8:00 per km)
  const avgPace = (workout.totalTime / workout.totalDistance) * 1000;
  if (avgPace < 180 || avgPace > 480) {
    issues.push(`Ovanligt genomsnittligt tempo: ${secondsToTime(avgPace)} per km`);
  }

  // Check for reasonable cadence (140-200 SPM)
  const avgCadence = calculateCadence(workout.totalStrides, workout.totalTime);
  if (avgCadence < 140 || avgCadence > 210) {
    issues.push(`Ovanlig stegfrekvens: ${Math.round(avgCadence)} SPM`);
  }

  // Check for missing segments (gaps in time)
  if (workout.segments && workout.segments.length > 1) {
    for (let i = 1; i < workout.segments.length; i++) {
      const gap = workout.segments[i].startTime -
                  (workout.segments[i-1].startTime + workout.segments[i-1].duration);
      if (gap > 300) { // 5 minute gap
        issues.push(`Stort gap upptäckt mellan segment ${i} och ${i+1}`);
      }
    }
  }

  return {
    isValid: issues.length === 0,
    issues
  };
}

// Exempel:
const workout = {
  totalDistance: 5000,
  totalTime: 1200, // 20 minuter (4:00/km)
  totalStrides: 3400, // 170 SPM
  segments: [/* kilometer-data */]
};
const validation = validateWorkoutData(workout);
// Returnerar: { isValid: true, issues: [] }