NHL Salary Cap Explained

NHL Salary Cap Mechanics

The NHL salary cap is a hard cap system that limits total team spending on player salaries. Understanding cap mechanics, AAV (Average Annual Value), and cap space calculations is essential for building competitive rosters within budget constraints.

Calculating Cap Space

import pandas as pd
import numpy as np

# Load team roster and contract data
roster = pd.read_csv('team_roster_contracts.csv')

# Salary cap parameters
SALARY_CAP_UPPER = 83_500_000  # 2023-24 season
SALARY_CAP_LOWER = 61_700_000
ROSTER_SIZE_MAX = 23

def calculate_cap_space(roster_df, salary_cap=SALARY_CAP_UPPER):
    """Calculate current cap space and cap hit"""

    # Filter active roster (not LTIR)
    active_roster = roster_df[roster_df['status'] != 'LTIR']

    # Calculate total cap hit (AAV sum)
    total_cap_hit = active_roster['cap_hit'].sum()

    # Available cap space
    cap_space = salary_cap - total_cap_hit

    # Cap space per roster spot
    roster_spots_used = len(active_roster)
    roster_spots_available = ROSTER_SIZE_MAX - roster_spots_used

    return {
        'total_cap_hit': total_cap_hit,
        'cap_space': cap_space,
        'cap_space_pct': (cap_space / salary_cap) * 100,
        'roster_spots_used': roster_spots_used,
        'roster_spots_available': roster_spots_available,
        'avg_cap_per_player': total_cap_hit / roster_spots_used
    }

# Calculate team cap situation
cap_info = calculate_cap_space(roster)

print("=== Team Cap Situation ===")
print(f"Total Cap Hit: ${cap_info['total_cap_hit']:,.0f}")
print(f"Cap Space: ${cap_info['cap_space']:,.0f}")
print(f"Cap Space %: {cap_info['cap_space_pct']:.2f}%")
print(f"Roster Spots Used: {cap_info['roster_spots_used']}/{ROSTER_SIZE_MAX}")
print(f"Average Cap Hit per Player: ${cap_info['avg_cap_per_player']:,.0f}")

# Contract breakdown by position
position_breakdown = roster.groupby('position').agg({
    'cap_hit': ['sum', 'mean', 'count']
}).round(0)

position_breakdown.columns = ['Total_Cap', 'Avg_Cap', 'Players']
position_breakdown = position_breakdown.sort_values('Total_Cap', ascending=False)

print("\n=== Cap Hit by Position ===")
print(position_breakdown)

# LTIR analysis
ltir_players = roster[roster['status'] == 'LTIR']
if len(ltir_players) > 0:
    ltir_cap_relief = ltir_players['cap_hit'].sum()
    print(f"\n=== LTIR Cap Relief ===")
    print(f"Total LTIR Cap Relief: ${ltir_cap_relief:,.0f}")
    print(f"Players on LTIR: {len(ltir_players)}")
    print(ltir_players[['player_name', 'cap_hit', 'contract_expiry']])

# Contract expiry analysis
def analyze_contract_expiries(roster_df):
    """Analyze upcoming contract expiries"""
    expiry_summary = roster_df.groupby('contract_expiry').agg({
        'cap_hit': 'sum',
        'player_name': 'count'
    }).rename(columns={'player_name': 'players_expiring'})

    expiry_summary = expiry_summary.sort_index()
    expiry_summary['cap_freed'] = expiry_summary['cap_hit']

    return expiry_summary

expiry_analysis = analyze_contract_expiries(roster)
print("\n=== Contract Expiries ===")
print(expiry_analysis)

# Simulate contract addition
def can_afford_contract(current_cap_space, contract_aav, roster_spots_available):
    """Check if team can afford a new contract"""
    if roster_spots_available <= 0:
        return False, "No roster spots available"

    if contract_aav > current_cap_space:
        overage = contract_aav - current_cap_space
        return False, f"Over cap by ${overage:,.0f}"

    return True, f"Can afford. Remaining cap: ${current_cap_space - contract_aav:,.0f}"

# Test contract scenarios
test_contracts = [
    ('Star Forward', 9_500_000),
    ('Top Defenseman', 7_000_000),
    ('Depth Player', 1_500_000)
]

print("\n=== Contract Addition Scenarios ===")
for player_type, aav in test_contracts:
    affordable, message = can_afford_contract(
        cap_info['cap_space'],
        aav,
        cap_info['roster_spots_available']
    )
    status = "✓" if affordable else "✗"
    print(f"{status} {player_type} (${aav:,.0f}): {message}")

library(tidyverse)
library(scales)

# Load roster data
roster <- read_csv("team_roster_contracts.csv")

# Salary cap parameters
SALARY_CAP_UPPER <- 83500000
SALARY_CAP_LOWER <- 61700000
ROSTER_SIZE_MAX <- 23

# Calculate cap space
calculate_cap_space <- function(roster_data, salary_cap = SALARY_CAP_UPPER) {
  active_roster <- roster_data %>% filter(status != "LTIR")

  total_cap_hit <- sum(active_roster$cap_hit)
  cap_space <- salary_cap - total_cap_hit
  roster_spots_used <- nrow(active_roster)

  list(
    total_cap_hit = total_cap_hit,
    cap_space = cap_space,
    cap_space_pct = (cap_space / salary_cap) * 100,
    roster_spots_used = roster_spots_used,
    roster_spots_available = ROSTER_SIZE_MAX - roster_spots_used,
    avg_cap_per_player = total_cap_hit / roster_spots_used
  )
}

cap_info <- calculate_cap_space(roster)

cat("=== Team Cap Situation ===\n")
cat(sprintf("Total Cap Hit: $%s\n", format(cap_info$total_cap_hit, big.mark = ",")))
cat(sprintf("Cap Space: $%s\n", format(cap_info$cap_space, big.mark = ",")))
cat(sprintf("Cap Space %%: %.2f%%\n", cap_info$cap_space_pct))
cat(sprintf("Roster Spots: %d/%d\n", cap_info$roster_spots_used, ROSTER_SIZE_MAX))

# Position breakdown
position_breakdown <- roster %>%
  group_by(position) %>%
  summarise(
    total_cap = sum(cap_hit),
    avg_cap = mean(cap_hit),
    players = n()
  ) %>%
  arrange(desc(total_cap))

cat("\n=== Cap Hit by Position ===\n")
print(position_breakdown)

# Contract expiry analysis
expiry_analysis <- roster %>%
  group_by(contract_expiry) %>%
  summarise(
    cap_freed = sum(cap_hit),
    players_expiring = n()
  ) %>%
  arrange(contract_expiry)

cat("\n=== Contract Expiries ===\n")
print(expiry_analysis)

# Visualize cap allocation
ggplot(roster %>% filter(status != "LTIR"),
       aes(x = reorder(player_name, -cap_hit), y = cap_hit, fill = position)) +
  geom_col() +
  geom_hline(yintercept = SALARY_CAP_UPPER / ROSTER_SIZE_MAX,
             linetype = "dashed", color = "red") +
  scale_y_continuous(labels = dollar_format(scale = 1e-6, suffix = "M")) +
  coord_flip() +
  labs(title = "Team Salary Cap Distribution",
       subtitle = "Red line shows average cap per player",
       x = "Player", y = "Cap Hit",
       fill = "Position") +
  theme_minimal() +
  theme(axis.text.y = element_text(size = 8))

# Cap space over time (with contract expiries)
cap_projection <- expiry_analysis %>%
  arrange(contract_expiry) %>%
  mutate(
    cumulative_cap_freed = cumsum(cap_freed),
    projected_cap_space = cap_info$cap_space + cumulative_cap_freed
  )

ggplot(cap_projection, aes(x = contract_expiry, y = projected_cap_space)) +
  geom_line(size = 1.2, color = "steelblue") +
  geom_point(size = 3) +
  geom_hline(yintercept = 0, linetype = "dashed", color = "red") +
  scale_y_continuous(labels = dollar_format(scale = 1e-6, suffix = "M")) +
  labs(title = "Projected Cap Space Over Time",
       subtitle = "Based on contract expiries",
       x = "Year", y = "Cap Space") +
  theme_minimal()

Cap Recapture and Buyouts

Teams have mechanisms to manage problematic contracts including buyouts (spreading cap hit over double the remaining years at reduced amounts) and contract terminations. Understanding these tools is critical for cap management.