Olympic Hockey Tournament Analysis

Analytics for Olympic Hockey

Olympic hockey tournaments feature the world's best players competing on the international stage. With large ice surfaces, different rules, and short tournament formats, analytics can help understand team construction strategies, player performance under pressure, and tournament outcome prediction.

Roster Construction Analytics

import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import KMeans

# Load player data for Olympic eligibility
eligible_players = pd.read_csv('olympic_eligible_players.csv')

# Olympic ice adjustment factor
def calculate_olympic_suitability(row):
    """Score player suitability for Olympic ice"""
    score = 0

    # Speed and skill (critical on big ice) - 30 points
    if row['skating_rating'] >= 8:
        score += 30
    elif row['skating_rating'] >= 7:
        score += 20
    else:
        score += 10

    # International experience - 25 points
    intl_games = row.get('intl_games', 0)
    if intl_games >= 20:
        score += 25
    elif intl_games >= 10:
        score += 18
    elif intl_games >= 5:
        score += 12
    else:
        score += 5

    # NHL performance - 25 points
    if row['nhl_ppg'] >= 1.00:
        score += 25
    elif row['nhl_ppg'] >= 0.80:
        score += 20
    elif row['nhl_ppg'] >= 0.60:
        score += 15
    else:
        score += 10

    # Two-way play - 10 points
    if row['defensive_rating'] >= 7:
        score += 10
    elif row['defensive_rating'] >= 6:
        score += 7
    else:
        score += 4

    # Versatility - 10 points
    if row['positions_played'] >= 2:
        score += 10
    else:
        score += 5

    return score

eligible_players['olympic_score'] = eligible_players.apply(
    calculate_olympic_suitability, axis=1
)

# Roster composition by country
def optimize_roster(country_players, roster_size=23):
    """Select optimal Olympic roster"""
    # Position requirements
    min_goalies = 3
    min_defensemen = 7
    min_forwards = 12

    # Separate by position
    goalies = country_players[country_players['position'] == 'G']
    defensemen = country_players[country_players['position'] == 'D']
    forwards = country_players[country_players['position'].isin(['C', 'LW', 'RW'])]

    # Sort by olympic_score
    best_goalies = goalies.nlargest(min_goalies, 'olympic_score')
    best_defense = defensemen.nlargest(min_defensemen, 'olympic_score')
    best_forwards = forwards.nlargest(
        roster_size - min_goalies - min_defensemen, 'olympic_score'
    )

    roster = pd.concat([best_goalies, best_defense, best_forwards])

    return roster

# Build rosters for top countries
countries = ['CAN', 'USA', 'SWE', 'FIN', 'RUS']

olympic_rosters = {}
for country in countries:
    country_pool = eligible_players[eligible_players['country'] == country]
    roster = optimize_roster(country_pool)
    olympic_rosters[country] = roster

    print(f"\n=== {country} Olympic Roster ===")
    print(roster[['name', 'position', 'nhl_ppg', 'skating_rating',
                  'intl_games', 'olympic_score']].sort_values(
                      'olympic_score', ascending=False))

# Roster strength comparison
roster_strength = pd.DataFrame({
    country: {
        'avg_olympic_score': roster['olympic_score'].mean(),
        'avg_nhl_ppg': roster['nhl_ppg'].mean(),
        'total_intl_games': roster['intl_games'].sum(),
        'avg_skating': roster['skating_rating'].mean()
    }
    for country, roster in olympic_rosters.items()
}).T

print("\n=== Roster Strength Comparison ===")
print(roster_strength.sort_values('avg_olympic_score', ascending=False))

# Line combination optimization
def optimize_forward_lines(forwards_df):
    """Create optimal forward line combinations"""
    forwards_sorted = forwards_df.sort_values('olympic_score', ascending=False)

    lines = {
        'Line 1': forwards_sorted.iloc[0:3],
        'Line 2': forwards_sorted.iloc[3:6],
        'Line 3': forwards_sorted.iloc[6:9],
        'Line 4': forwards_sorted.iloc[9:12]
    }

    for line_name, line_players in lines.items():
        avg_score = line_players['olympic_score'].mean()
        print(f"\n{line_name} (Avg Score: {avg_score:.1f}):")
        print(line_players[['name', 'position', 'nhl_ppg', 'olympic_score']])

    return lines

# Tournament simulation
def simulate_olympic_tournament(rosters):
    """Monte Carlo simulation of tournament outcomes"""
    n_simulations = 10000
    results = {country: 0 for country in rosters.keys()}

    for _ in range(n_simulations):
        # Simplified: team strength based on average roster score
        team_strengths = {
            country: roster['olympic_score'].mean() + np.random.normal(0, 5)
            for country, roster in rosters.items()
        }

        # Winner is team with highest strength this simulation
        winner = max(team_strengths, key=team_strengths.get)
        results[winner] += 1

    # Convert to probabilities
    probabilities = {
        country: (wins / n_simulations) * 100
        for country, wins in results.items()
    }

    return probabilities

tournament_odds = simulate_olympic_tournament(olympic_rosters)

print("\n=== Olympic Gold Medal Probabilities ===")
for country, prob in sorted(tournament_odds.items(),
                           key=lambda x: x[1], reverse=True):
    print(f"{country}: {prob:.1f}%")

# Historical Olympic performance analysis
olympic_history = pd.read_csv('olympic_hockey_history.csv')

# Player age analysis
age_analysis = olympic_history.groupby('medal').agg({
    'player_age': 'mean',
    'nhl_ppg_prior': 'mean',
    'tournament_ppg': 'mean'
})

print("\n=== Historical Age and Performance by Medal ===")
print(age_analysis)

# Key player archetypes for Olympic success
def identify_player_archetype(row):
    """Classify player type for Olympic roster"""
    if row['nhl_ppg'] >= 1.0 and row['skating_rating'] >= 8:
        return 'Elite Star'
    elif row['intl_games'] >= 20 and row['defensive_rating'] >= 7:
        return 'Veteran Two-Way'
    elif row['skating_rating'] >= 8 and row['age'] <= 26:
        return 'Speed/Skill'
    elif row['physical_rating'] >= 7:
        return 'Physical Presence'
    else:
        return 'Depth Player'

eligible_players['archetype'] = eligible_players.apply(
    identify_player_archetype, axis=1
)

# Ideal roster composition
print("\n=== Optimal Archetype Distribution ===")
print(eligible_players.groupby(['country', 'archetype']).size().unstack(fill_value=0))

library(tidyverse)
library(scales)

# Load eligible players
eligible_players <- read_csv("olympic_eligible_players.csv")

# Calculate Olympic suitability score
calculate_olympic_suitability <- function(skating_rating, intl_games,
                                         nhl_ppg, defensive_rating,
                                         positions_played) {
  score <- 0

  # Speed/skill (30)
  score <- score + case_when(
    skating_rating >= 8 ~ 30,
    skating_rating >= 7 ~ 20,
    TRUE ~ 10
  )

  # International experience (25)
  score <- score + case_when(
    intl_games >= 20 ~ 25,
    intl_games >= 10 ~ 18,
    intl_games >= 5 ~ 12,
    TRUE ~ 5
  )

  # NHL performance (25)
  score <- score + case_when(
    nhl_ppg >= 1.00 ~ 25,
    nhl_ppg >= 0.80 ~ 20,
    nhl_ppg >= 0.60 ~ 15,
    TRUE ~ 10
  )

  # Two-way play (10)
  score <- score + case_when(
    defensive_rating >= 7 ~ 10,
    defensive_rating >= 6 ~ 7,
    TRUE ~ 4
  )

  # Versatility (10)
  score <- score + ifelse(positions_played >= 2, 10, 5)

  return(score)
}

eligible_players <- eligible_players %>%
  rowwise() %>%
  mutate(
    olympic_score = calculate_olympic_suitability(
      skating_rating, intl_games, nhl_ppg,
      defensive_rating, positions_played
    )
  ) %>%
  ungroup()

# Build optimal rosters
optimize_roster <- function(country_players, roster_size = 23) {
  goalies <- country_players %>%
    filter(position == "G") %>%
    slice_max(olympic_score, n = 3)

  defensemen <- country_players %>%
    filter(position == "D") %>%
    slice_max(olympic_score, n = 7)

  forwards <- country_players %>%
    filter(position %in% c("C", "LW", "RW")) %>%
    slice_max(olympic_score, n = roster_size - 10)

  bind_rows(goalies, defensemen, forwards)
}

# Build rosters for top countries
countries <- c("CAN", "USA", "SWE", "FIN", "RUS")

olympic_rosters <- countries %>%
  set_names() %>%
  map(~{
    eligible_players %>%
      filter(country == .x) %>%
      optimize_roster()
  })

# Display rosters
walk2(names(olympic_rosters), olympic_rosters, ~{
  cat(sprintf("\n=== %s Olympic Roster ===\n", .x))
  print(.y %>%
    select(name, position, nhl_ppg, skating_rating, intl_games, olympic_score) %>%
    arrange(desc(olympic_score)))
})

# Roster strength comparison
roster_strength <- olympic_rosters %>%
  map_dfr(~{
    tibble(
      avg_olympic_score = mean(.x$olympic_score),
      avg_nhl_ppg = mean(.x$nhl_ppg),
      total_intl_games = sum(.x$intl_games),
      avg_skating = mean(.x$skating_rating)
    )
  }, .id = "country") %>%
  arrange(desc(avg_olympic_score))

cat("\n=== Roster Strength Comparison ===\n")
print(roster_strength)

# Simulate tournament outcomes
simulate_olympic_tournament <- function(rosters, n_sims = 10000) {
  results <- tibble(country = names(rosters), wins = 0)

  for (i in 1:n_sims) {
    team_strengths <- rosters %>%
      map_dbl(~mean(.x$olympic_score) + rnorm(1, 0, 5))

    winner <- names(which.max(team_strengths))
    results <- results %>%
      mutate(wins = ifelse(country == winner, wins + 1, wins))
  }

  results %>%
    mutate(probability = (wins / n_sims) * 100) %>%
    arrange(desc(probability))
}

tournament_odds <- simulate_olympic_tournament(olympic_rosters)

cat("\n=== Olympic Gold Medal Probabilities ===\n")
print(tournament_odds %>% select(country, probability))

# Visualize roster strengths
ggplot(roster_strength,
       aes(x = reorder(country, avg_olympic_score),
           y = avg_olympic_score, fill = country)) +
  geom_col() +
  geom_text(aes(label = sprintf("%.1f", avg_olympic_score)),
            hjust = -0.2) +
  coord_flip() +
  labs(title = "Olympic Hockey Roster Strength",
       subtitle = "Based on Olympic Suitability Score",
       x = "Country", y = "Average Olympic Score") +
  theme_minimal() +
  theme(legend.position = "none")

# Historical analysis
olympic_history <- read_csv("olympic_hockey_history.csv")

age_analysis <- olympic_history %>%
  group_by(medal) %>%
  summarise(
    avg_age = mean(player_age),
    avg_nhl_ppg_prior = mean(nhl_ppg_prior),
    avg_tournament_ppg = mean(tournament_ppg)
  )

cat("\n=== Historical Age and Performance by Medal ===\n")
print(age_analysis)

# Player archetype classification
eligible_players <- eligible_players %>%
  mutate(
    archetype = case_when(
      nhl_ppg >= 1.0 & skating_rating >= 8 ~ "Elite Star",
      intl_games >= 20 & defensive_rating >= 7 ~ "Veteran Two-Way",
      skating_rating >= 8 & age <= 26 ~ "Speed/Skill",
      physical_rating >= 7 ~ "Physical Presence",
      TRUE ~ "Depth Player"
    )
  )

# Archetype distribution by country
archetype_dist <- eligible_players %>%
  filter(country %in% countries) %>%
  count(country, archetype) %>%
  pivot_wider(names_from = archetype, values_from = n, values_fill = 0)

cat("\n=== Optimal Archetype Distribution ===\n")
print(archetype_dist)

# Visualize medal probability
ggplot(tournament_odds, aes(x = reorder(country, probability),
                           y = probability, fill = country)) +
  geom_col() +
  geom_text(aes(label = sprintf("%.1f%%", probability)),
            hjust = -0.2) +
  coord_flip() +
  labs(title = "Olympic Gold Medal Probability",
       subtitle = "Based on 10,000 tournament simulations",
       x = "Country", y = "Win Probability (%)") +
  theme_minimal() +
  theme(legend.position = "none")

Olympic Ice and Tournament Strategy

The larger Olympic ice surface (15 feet wider than NHL) fundamentally changes optimal roster construction. Speed and skill become more valuable, while physical grinding styles are less effective. Teams need mobile defensemen and fast, skilled forwards who can control space on the bigger sheet.