Lap Time Delta Comparison

This tutorial shows how to create a lap-by-lap delta comparison between two drivers. The chart shows who was faster on each lap and by how much. It also shows performance trends across a race.

Setup

import tif1
from tif1.plotting import get_team_color, setup_mpl
import matplotlib.pyplot as plt

# Setup plotting
setup_mpl(color_scheme='fastf1')

Load Session and Get Lap Data

# Load the race session
session = tif1.get_session(2024, "Monaco", "R")
laps = session.laps

# Select two drivers to compare
driver1 = "VER"
driver2 = "LEC"

# Get laps for both drivers
driver1_laps = laps[laps["Driver"] == driver1][["LapNumber", "LapTime"]].copy()
driver2_laps = laps[laps["Driver"] == driver2][["LapNumber", "LapTime"]].copy()

Calculate Time Deltas

Convert lap times to seconds and calculate the difference for each lap.

# Convert lap times to seconds
driver1_laps["LapTime"] = driver1_laps["LapTime"].dt.total_seconds()
driver2_laps["LapTime"] = driver2_laps["LapTime"].dt.total_seconds()

# Merge on lap number to compare
merged = driver1_laps.merge(
    driver2_laps,
    on="LapNumber",
    suffixes=("_d1", "_d2")
)

# Calculate delta (positive = driver2 faster, negative = driver1 faster)
merged["Delta"] = merged["LapTime_d1"] - merged["LapTime_d2"]

Color Code by Faster Driver

Assign colors based on which driver was faster on each lap.

# Color based on who was faster
merged["Color"] = merged["Delta"].apply(
    lambda x: get_team_color("Red Bull Racing", session) if x < 0
              else get_team_color("Ferrari", session)
)

Create the Bar Chart

Visualize the deltas with a bar chart where bar height shows the time difference.

fig, ax = plt.subplots(figsize=(14, 8))

# Bar chart of deltas
ax.bar(
    merged["LapNumber"],
    merged["Delta"],
    color=merged["Color"],
    width=0.8,
    edgecolor="white",
    linewidth=0.5,
)

# Add zero line for reference
ax.axhline(0, color="white", linestyle="--", linewidth=1, alpha=0.7)

# Labels and title
ax.set_xlabel("Lap Number", fontsize=14)
ax.set_ylabel("Time Delta (seconds)", fontsize=14)
ax.set_title(
    f"{session.event.year} {session.event['EventName']} - Lap Time Delta\n"
    f"{driver1} vs {driver2}",
    fontsize=16,
    fontweight="bold",
    pad=20,
)

Add Legend and Styling

from matplotlib.patches import Patch

# Create legend
legend_elements = [
    Patch(facecolor=get_team_color("Red Bull Racing", session), label=f"{driver1} faster"),
    Patch(facecolor=get_team_color("Ferrari", session), label=f"{driver2} faster"),
]
ax.legend(handles=legend_elements, loc="upper right", fontsize=12)

# Add grid and clean up
ax.grid(True, alpha=0.3, axis="y")
ax.set_ylim(-2, 2)
ax.spines["top"].set_visible(False)
ax.spines["right"].set_visible(False)

plt.tight_layout()
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, merges the two drivers' laps, and plots the deltas
fig, ax = tif1.plot_lap_delta(2024, "Monaco", "R", drivers=["VER", "LEC"])
plt.show()

# Or save straight to a file
# tif1.plot_lap_delta(2024, "Monaco", "R", drivers=["VER", "LEC"], save_path="lap_delta.png")

Bars below zero mean the first driver was faster; bars above zero mean the second driver was faster. The y-axis auto-scales to the data instead of the hardcoded (-2, 2) used above. Bars are colored with the faster driver’s team color.

Interpreting the Chart

Bars above zero: Driver 2 was faster on that lap
Bars below zero: Driver 1 was faster on that lap
Bar height: Magnitude of the time difference in seconds
Color coding: The bar color identifies the faster driver

What to Look For

This visualization helps identify:

Consistency: Who maintains more consistent lap times?
Pace trends: Does one driver get faster or slower as the race progresses?
Tire degradation: Increasing deltas may indicate tire wear
Strategy impact: How do pit stops affect relative performance?
Traffic effects: Sudden spikes often indicate traffic or incidents

Filtering Out Outliers

The native function exposes the same filters as parameters. Drop pit laps with include_pit_laps=False (the default) and remove safety-car laps with a per-driver laptime_cutoff:

import tif1

# Pit laps dropped, laps slower than 110% of the driver's fastest removed
fig, ax = tif1.plot_lap_delta(
    2024, "Monaco", "R",
    drivers=["VER", "LEC"],
    include_pit_laps=False,
    laptime_cutoff=1.1,
)
plt.show()

Restrict the comparison to specific laps with the laps parameter, for example laps=[10, 11, 12].

Comparing Multiple Driver Pairs

To compare different pairs, call the native function with a different drivers list:

import tif1

# Compare any two drivers
fig, ax = tif1.plot_lap_delta(2024, "Monaco", "R", drivers=["HAM", "RUS"])
plt.show()

# The default (drivers=None) picks the top-2 finishers
fig, ax = tif1.plot_lap_delta(2024, "Monaco", "R")
plt.show()

Summary

Lap delta comparisons give a clear, lap-by-lap view of relative performance between drivers. The chart shows patterns, consistency differences, and the effect of race events on driver performance.

Driver Lap Times

Individual driver analysis.

Telemetry Comparison

Detailed telemetry analysis.

Race Pace Analysis

Compare race pace.

Position Changes

Track position changes.

​Setup

​Load Session and Get Lap Data

​Calculate Time Deltas

​Color Code by Faster Driver

​Create the Bar Chart

​Add Legend and Styling

​Complete Example

​Interpreting the Chart

​What to Look For

​Filtering Out Outliers

​Comparing Multiple Driver Pairs

​Summary

​Related Pages