Lap Times Distribution Visualization

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

# Enable Matplotlib patches for plotting timedelta values and load
# tif1's dark color scheme
tif1.plotting.setup_mpl(mpl_timedelta_support=True, color_scheme='fastf1')

# Load the race session
race = tif1.get_session(2023, "Azerbaijan", 'R')
laps = race.laps

# Get all the laps for the point finishers only
# race.drivers returns driver numbers, so translate them to abbreviations first
point_finishers = [race.get_driver(i)["Abbreviation"] for i in race.drivers[:10]]
print(f"Point finishers: {point_finishers}")

# Pick quick laps only (filter out slow laps)
driver_laps = laps.pick_drivers(point_finishers).copy()

# Filter out slow laps - remove deleted laps and pit laps
driver_laps = driver_laps[~driver_laps["Deleted"]]
driver_laps = driver_laps[~driver_laps["PitOutTime"].notna()]
driver_laps = driver_laps[~driver_laps["PitInTime"].notna()]

# Remove outliers (laps > 110% of fastest lap per driver)
# Use transform to keep every column; groupby().apply() drops the grouping column
fastest_per_driver = driver_laps.groupby("Driver")["LapTime"].transform("min")
driver_laps = driver_laps[driver_laps["LapTime"] < fastest_per_driver * 1.10]
driver_laps = driver_laps.reset_index(drop=True)

# point_finishers already holds the abbreviations in finishing order
finishing_order = point_finishers
print(f"Finishing order: {finishing_order}")

# Create the figure
fig, ax = plt.subplots(figsize=(10, 5))

# Seaborn doesn't have proper timedelta support,
# so we convert timedelta to float (in seconds)
driver_laps["LapTime(s)"] = driver_laps["LapTime"].dt.total_seconds()

# First create the violin plots to show the distributions
sns.violinplot(data=driver_laps,
               x="Driver",
               y="LapTime(s)",
               hue="Driver",
               inner=None,
               density_norm="area",
               order=finishing_order,
               palette=tif1.plotting.get_driver_color_mapping(session=race),
               legend=False
               )

# Then use the swarm plot to show the actual laptimes
sns.swarmplot(data=driver_laps,
              x="Driver",
              y="LapTime(s)",
              order=finishing_order,
              hue="Compound",
              palette=tif1.plotting.get_compound_mapping(session=race),
              hue_order=["SOFT", "MEDIUM", "HARD"],
              linewidth=0,
              size=4,
              )

# Set axis labels
ax.set_xlabel("Driver")
ax.set_ylabel("Lap Time (s)")

# Add title
plt.suptitle("2023 Azerbaijan Grand Prix Lap Time Distributions")

# Remove spines for cleaner look
sns.despine(left=True, bottom=True)

plt.tight_layout()
plt.show()

import tif1

# Top 10 point finishers (default)
fig, ax = tif1.plot_laptimes_distribution(2023, "Azerbaijan", 'R')
plt.show()

# More drivers, relaxed outlier cutoff
fig, ax = tif1.plot_laptimes_distribution(
    2023, "Azerbaijan", 'R',
    n_drivers=15,
    laptime_cutoff=1.15,
)
plt.show()

import tif1
import matplotlib.pyplot as plt

# One call: loads the race, filters the laps, and draws violin + swarm plots
fig, ax = tif1.plot_laptimes_distribution(2023, "Azerbaijan", 'R')
plt.show()

# Or save straight to a file
# tif1.plot_laptimes_distribution(2023, "Azerbaijan", 'R', save_path="laptimes_distribution.png")

# Larger figure for more drivers
fig, ax = plt.subplots(figsize=(14, 6))

# Adjust swarm plot marker size
sns.swarmplot(
    data=driver_laps,
    x="Driver",
    y="LapTime(s)",
    order=finishing_order,
    hue="Compound",
    palette=tif1.plotting.get_compound_mapping(session=race),
    size=6,  # Larger markers
    alpha=0.8,  # Add transparency
    edgecolor='gray',  # Add marker outline
    linewidth=0.5
)

# Show only soft tire laps
soft_laps = driver_laps[driver_laps["Compound"] == "SOFT"]

sns.violinplot(data=soft_laps,
               x="Driver",
               y="LapTime(s)",
               hue="Driver",
               order=finishing_order,
               palette=tif1.plotting.get_driver_color_mapping(session=race),
               legend=False
               )

# Compare qualifying vs race pace
quali = tif1.get_session(2023, "Azerbaijan", 'Q')
quali_laps = quali.laps.copy()

# Seaborn needs numeric values, so convert the timedelta lap times to seconds
quali_laps["LapTime(s)"] = quali_laps["LapTime"].dt.total_seconds()

# Create side-by-side comparison
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 6))

# Qualifying distribution
sns.violinplot(data=quali_laps, x="Driver", y="LapTime(s)", ax=ax1)
ax1.set_title("Qualifying")

# Race distribution
sns.violinplot(data=driver_laps, x="Driver", y="LapTime(s)", ax=ax2)
ax2.set_title("Race")

plt.tight_layout()
plt.show()

# Calculate statistics per driver
stats = driver_laps.groupby("Driver")["LapTime(s)"].agg([
    ('mean', 'mean'),
    ('median', 'median'),
    ('std', 'std'),
    ('min', 'min'),
    ('max', 'max')
])

print(stats.sort_values('median'))

# Find most consistent drivers (lowest standard deviation)
consistency = driver_laps.groupby("Driver")["LapTime(s)"].std().sort_values()
print(f"Most consistent driver: {consistency.index[0]}")
print(f"Standard deviation: {consistency.iloc[0]:.3f}s")