Lap Time Heatmap

A lap time heatmap shows race pace across all drivers and laps. Color coding identifies consistent performers, tire degradation patterns, pit stop strategies, and incidents.

Understanding the Visualization

In a lap time heatmap:

Rows represent drivers (sorted by average pace)
Columns represent lap numbers
Colors indicate lap time performance:
- Green/cooler colors = faster laps
- Red/warmer colors = slower laps
- White/missing = pit stops or deleted laps

These patterns show tire degradation (gradual color shift), pit stop windows (gaps), and incidents (sudden color changes).

Loading the Session

Analyze the 2023 Monaco Grand Prix race to see how drivers performed throughout the event.

import tif1
import matplotlib.pyplot as plt
import seaborn as sns

# Setup plotting
tif1.plotting.setup_mpl(color_scheme='fastf1')

# Load race session
session = tif1.get_session(2023, 'Monaco Grand Prix', 'R')
laps = session.laps

Preparing the Data

Convert lap times to seconds and filter out invalid laps for cleaner visualization.

# Convert lap times to seconds
laps_clean = laps.copy()
laps_clean['LapTimeSeconds'] = laps_clean['LapTime'].dt.total_seconds()

# Filter out invalid laps
laps_clean = laps_clean[~laps_clean['Deleted']]
laps_clean = laps_clean[laps_clean['PitInTime'].isna()]
laps_clean = laps_clean[laps_clean['PitOutTime'].isna()]

# Remove outliers (laps slower than 107% of fastest)
fastest_lap = laps_clean['LapTimeSeconds'].min()
laps_clean = laps_clean[laps_clean['LapTimeSeconds'] < fastest_lap * 1.07]

Creating the Pivot Table

Reshape the data so drivers are rows and lap numbers are columns.

# Create pivot table
heatmap_data = laps_clean.pivot_table(
    index='Driver',
    columns='LapNumber',
    values='LapTimeSeconds',
    aggfunc='first'
)

# Sort drivers by average lap time (fastest at top)
driver_avg = heatmap_data.mean(axis=1).sort_values()
heatmap_data = heatmap_data.loc[driver_avg.index]

Visualizing with Seaborn

Use the seaborn heatmap function to draw the chart.

fig, ax = plt.subplots(figsize=(16, 10))

sns.heatmap(
    heatmap_data,
    cmap='RdYlGn_r',  # Red (slow) to Green (fast)
    vmin=fastest_lap,
    vmax=fastest_lap * 1.07,
    cbar_kws={'label': 'Lap Time (seconds)', 'aspect': 40},
    linewidths=0.5,
    linecolor='#1a1a1a',
    xticklabels=5,  # Show every 5th lap number
    ax=ax
)

# Styling
ax.set_xlabel('Lap Number', fontsize=12, fontweight='bold')
ax.set_ylabel('Driver', fontsize=12, fontweight='bold')
ax.set_title('Monaco Grand Prix - Lap Time Heatmap',
             fontsize=14, fontweight='bold', pad=20)

plt.yticks(rotation=0, fontsize=10)
plt.xticks(fontsize=10)

plt.tight_layout()
plt.show()

Interpreting the Heatmap

When analyzing a lap time heatmap, look for:

Vertical patterns: Consistent colors down a column indicate similar pace across all drivers (for example, safety car periods)
Horizontal patterns: Gradual color shifts across a row show tire degradation or fuel load effects
Gaps: White spaces indicate pit stops
Sudden changes: Abrupt color shifts may indicate incidents, traffic, or mistakes
Consistent greens: Drivers with predominantly green rows had strong, consistent pace

Adding Fuel Correction

To compare true pace, apply fuel correction to account for the decreasing fuel load:

# Simple fuel correction formula
# Assumes ~0.03s per lap improvement per 1kg of fuel burned
max_laps = laps_clean['LapNumber'].max()
laps_clean['FuelCorrected'] = (
    laps_clean['LapTimeSeconds'] -
    (0.03 * (max_laps - laps_clean['LapNumber']))
)

# Create heatmap with fuel-corrected times
heatmap_fuel = laps_clean.pivot_table(
    index='Driver',
    columns='LapNumber',
    values='FuelCorrected',
    aggfunc='first'
)

# Sort and plot
driver_avg_fuel = heatmap_fuel.mean(axis=1).sort_values()
heatmap_fuel = heatmap_fuel.loc[driver_avg_fuel.index]

fig, ax = plt.subplots(figsize=(16, 10))
sns.heatmap(
    heatmap_fuel,
    cmap='RdYlGn_r',
    vmin=heatmap_fuel.min().min(),
    vmax=heatmap_fuel.min().min() * 1.07,
    cbar_kws={'label': 'Fuel-Corrected Lap Time (s)', 'aspect': 40},
    linewidths=0.5,
    linecolor='#1a1a1a',
    xticklabels=5,
    ax=ax
)

ax.set_xlabel('Lap Number', fontsize=12, fontweight='bold')
ax.set_ylabel('Driver', fontsize=12, fontweight='bold')
ax.set_title('Monaco GP - Fuel-Corrected Lap Times',
             fontsize=14, fontweight='bold', pad=20)

plt.tight_layout()
plt.show()

Parameters

The native function exposes the same filters as parameters. laptime_cutoff fixes the color scale, from fastest to fastest * cutoff. include_deleted and include_pit_laps keep those laps when True. cmap and xticklabels control the styling:

import tif1

# Defaults match the chart above
fig, ax = tif1.plot_laptime_heatmap(2023, 'Monaco Grand Prix', 'R')
plt.show()

# Custom color scale and tick spacing
fig, ax = tif1.plot_laptime_heatmap(
    2023, 'Monaco Grand Prix', 'R',
    cmap='viridis',
    xticklabels=3,
    laptime_cutoff=1.10,
)
plt.show()

Complete Example

The whole workflow above is wrapped in a single native function:

import tif1
import matplotlib.pyplot as plt

# One call: loads the race, pivots the data, and draws the heatmap
fig, ax = tif1.plot_laptime_heatmap(2023, 'Monaco Grand Prix', 'R')
plt.show()

# Or save straight to a file
# tif1.plot_laptime_heatmap(2023, 'Monaco Grand Prix', 'R', save_path="laptime_heatmap.png")

Advanced Variations

Compare Specific Drivers

Focus on a subset of drivers for detailed comparison:

# Select the 5 fastest drivers by average lap time
top_drivers = driver_avg.index[:5]
laps_top = laps_clean[laps_clean['Driver'].isin(top_drivers)]

heatmap_top = laps_top.pivot_table(
    index='Driver',
    columns='LapNumber',
    values='LapTimeSeconds',
    aggfunc='first'
)

# Plot with larger cells for better visibility
fig, ax = plt.subplots(figsize=(16, 6))
sns.heatmap(heatmap_top, cmap='RdYlGn_r', linewidths=1, ax=ax)
ax.set_title('Top 5 Finishers - Lap Time Comparison')
plt.tight_layout()
plt.show()

Annotate with Lap Times

Add actual lap time values to cells for precise analysis:

fig, ax = plt.subplots(figsize=(20, 10))

sns.heatmap(
    heatmap_data,
    cmap='RdYlGn_r',
    vmin=fastest_lap,
    vmax=fastest_lap * 1.07,
    annot=True,  # Show values
    fmt='.1f',   # Format to 1 decimal place
    cbar_kws={'label': 'Lap Time (seconds)'},
    linewidths=0.5,
    ax=ax
)

plt.tight_layout()
plt.show()

Next Steps

Combine with tire strategy visualization to correlate pace with compounds
Analyze specific stint performance by filtering lap ranges
Compare heatmaps across different races to identify track-specific patterns
Use clustering algorithms to group drivers with similar pace profiles

​Understanding the Visualization

​Loading the Session

​Preparing the Data

​Creating the Pivot Table

​Visualizing with Seaborn

​Interpreting the Heatmap

​Adding Fuel Correction

​Parameters

​Complete Example

​Advanced Variations

​Compare Specific Drivers

​Annotate with Lap Times

​Next Steps