Qualifying Analysis

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

# Load qualifying session
session = tif1.get_session(2025, "Monaco Grand Prix", "Qualifying")
laps = session.laps

# Check which laps belong to which qualifying segment
# The laps DataFrame stores the segment in the "QualifyingSession" column
print(laps["QualifyingSession"].value_counts())

# Get fastest lap per driver
fastest_laps = session.get_fastest_laps(by_driver=True)

# Sort by lap time
fastest_laps_sorted = fastest_laps.sort_values("LapTime")

# Display top 10
print(fastest_laps_sorted[["Driver", "Team", "LapTime", "Compound"]].head(10))

# Get top 10 for pole position battle
top_10 = fastest_laps_sorted.head(10)

# Look up team colors from the drivers table
team_colors = session.drivers_df.set_index("Driver")["TeamColor"]
colors = [f"#{team_colors.get(driver, '808080')}" for driver in top_10["Driver"]]

# Matplotlib needs numeric values, so convert the timedelta lap times to seconds
lap_seconds = top_10["LapTime"].dt.total_seconds()

# Create bar chart
plt.figure(figsize=(12, 6))
plt.barh(top_10["Driver"], lap_seconds, color=colors)
plt.xlabel("Lap Time (s)")
plt.ylabel("Driver")
plt.title("Qualifying Results - Top 10")
plt.gca().invert_yaxis()
plt.tight_layout()
plt.show()

# Get fastest lap per driver per qualifying segment
# Wrap in pd.DataFrame: groupby on the Laps subclass drops the key column names
progression = (
    pd.DataFrame(laps)
    .groupby(["Driver", "QualifyingSession"])
    .agg(LapTime=("LapTime", "min"))
    .reset_index()
)

# Pivot to show progression
progression_pivot = progression.pivot(
    index="Driver",
    columns="QualifyingSession",
    values="LapTime"
)

# Calculate improvements
if "Q1" in progression_pivot.columns and "Q2" in progression_pivot.columns:
    progression_pivot["Q1_to_Q2"] = progression_pivot["Q1"] - progression_pivot["Q2"]

if "Q2" in progression_pivot.columns and "Q3" in progression_pivot.columns:
    progression_pivot["Q2_to_Q3"] = progression_pivot["Q2"] - progression_pivot["Q3"]

print(progression_pivot.head(10))

# Filter drivers who made it to Q3
q3_drivers = progression[progression["QualifyingSession"] == "Q3"]["Driver"].unique()
q3_progression = progression[progression["Driver"].isin(q3_drivers)]

# Plot progression (convert timedelta to seconds for matplotlib)
plt.figure(figsize=(14, 8))
for driver in q3_drivers[:10]:  # Top 10 only
    driver_data = q3_progression[q3_progression["Driver"] == driver]
    plt.plot(driver_data["QualifyingSession"],
             driver_data["LapTime"].dt.total_seconds(),
             marker="o", label=driver)

plt.xlabel("Session")
plt.ylabel("Lap Time (s)")
plt.title("Qualifying Progression - Top 10 Drivers")
plt.legend(bbox_to_anchor=(1.05, 1), loc="upper left")
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

# Compound usage in Q3
q3_laps = laps[laps["QualifyingSession"] == "Q3"]
compound_usage = q3_laps.groupby(["Driver", "Compound"]).size().reset_index(name="Count")

print(compound_usage)

# Visualize
plt.figure(figsize=(12, 6))
sns.countplot(data=q3_laps, x="Driver", hue="Compound", palette="Set2")
plt.xticks(rotation=45)
plt.title("Tire Compound Usage in Q3")
plt.tight_layout()
plt.show()

# Get pole time
pole_time = fastest_laps_sorted["LapTime"].iloc[0]
pole_driver = fastest_laps_sorted["Driver"].iloc[0]

# Calculate gap to pole
fastest_laps_sorted["GapToPole"] = fastest_laps_sorted["LapTime"] - pole_time

# Display
print(f"Pole Position: {pole_driver} - {pole_time.total_seconds():.3f}s")
print("\nGap to Pole:")
print(fastest_laps_sorted[["Driver", "LapTime", "GapToPole"]].head(10))

# Visualize (convert the timedelta gaps to seconds for matplotlib)
plt.figure(figsize=(12, 6))
top_10_gap = fastest_laps_sorted.head(10)
plt.bar(top_10_gap["Driver"], top_10_gap["GapToPole"].dt.total_seconds())
plt.xlabel("Driver")
plt.ylabel("Gap to Pole (s)")
plt.title(f"Gap to Pole Position ({pole_driver})")
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()

# Get fastest sectors per driver
sector_analysis = fastest_laps_sorted[[
    "Driver", "Sector1Time", "Sector2Time", "Sector3Time"
]].copy()

# Find fastest sector time overall
fastest_s1 = laps["Sector1Time"].min()
fastest_s2 = laps["Sector2Time"].min()
fastest_s3 = laps["Sector3Time"].min()

# Calculate delta to fastest
sector_analysis["S1_Delta"] = sector_analysis["Sector1Time"] - fastest_s1
sector_analysis["S2_Delta"] = sector_analysis["Sector2Time"] - fastest_s2
sector_analysis["S3_Delta"] = sector_analysis["Sector3Time"] - fastest_s3

print(sector_analysis.head(10))

# Get top 2 drivers
p1_driver = fastest_laps_sorted["Driver"].iloc[0]
p2_driver = fastest_laps_sorted["Driver"].iloc[1]

# Get their fastest laps
p1_fastest = session.get_driver(p1_driver).get_fastest_lap()
p2_fastest = session.get_driver(p2_driver).get_fastest_lap()

# Get telemetry
p1_tel = session.get_driver(p1_driver).get_lap(
    int(p1_fastest["LapNumber"].iloc[0])
).telemetry
p2_tel = session.get_driver(p2_driver).get_lap(
    int(p2_fastest["LapNumber"].iloc[0])
).telemetry

# Plot speed comparison
plt.figure(figsize=(14, 6))
plt.plot(p1_tel["Distance"], p1_tel["Speed"], label=p1_driver, linewidth=2)
plt.plot(p2_tel["Distance"], p2_tel["Speed"], label=p2_driver, linewidth=2)
plt.xlabel("Distance (m)")
plt.ylabel("Speed (km/h)")
plt.title("Speed Comparison - Pole vs P2")
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

# Filter deleted laps
deleted_laps = laps[laps["Deleted"] == True]

# Count by driver
deleted_by_driver = deleted_laps.groupby("Driver").size().sort_values(ascending=False)

print("Deleted Laps by Driver:")
print(deleted_by_driver.head(10))

# Visualize
plt.figure(figsize=(12, 6))
deleted_by_driver.head(10).plot(kind="bar")
plt.xlabel("Driver")
plt.ylabel("Number of Deleted Laps")
plt.title("Track Limits Violations")
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()

# Calculate standard deviation of lap times per driver
consistency = laps.groupby("Driver")["LapTime"].agg(["mean", "std", "count"])
consistency = consistency[consistency["count"] >= 3]  # At least 3 laps
consistency = consistency.sort_values("std")

print("Most Consistent Drivers:")
print(consistency.head(10))

# Visualize
plt.figure(figsize=(12, 6))
consistency.head(10)["std"].plot(kind="bar")
plt.xlabel("Driver")
plt.ylabel("Lap Time Std Dev (s)")
plt.title("Driver Consistency (Lower is Better)")
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()

def analyze_qualifying(year, gp):
    """Complete qualifying analysis."""
    # Load session
    session = tif1.get_session(year, gp, "Qualifying")
    laps = session.laps

    # Get fastest laps
    fastest = session.get_fastest_laps(by_driver=True).sort_values("LapTime")

    # Results
    results = {
        "pole_position": fastest.iloc[0]["Driver"],
        "pole_time": fastest.iloc[0]["LapTime"],
        "top_10": fastest.head(10)[["Driver", "Team", "LapTime"]].to_dict("records"),
        "deleted_laps": len(laps[laps["Deleted"] == True]),
        "total_laps": len(laps)
    }

    # Gap to pole
    results["gaps"] = (fastest["LapTime"] - results["pole_time"]).head(10).tolist()

    return results

# Use it
results = analyze_qualifying(2025, "Monaco Grand Prix")
print(f"Pole: {results['pole_position']} - {results['pole_time'].total_seconds():.3f}s")
print(f"Total laps: {results['total_laps']}, Deleted: {results['deleted_laps']}")