Skip to main content

Documentation Index

Fetch the complete documentation index at: https://mintlify.com/TracingInsights/tif1/llms.txt

Use this file to discover all available pages before exploring further.

​
Overview

Telemetry data provides detailed insights into driver inputs and car behavior throughout a lap. This guide covers how to work with telemetry data for performance analysis.

​
Accessing Telemetry

Telemetry data is accessed through lap objects: 
import tif1

session = tif1.get_session(2025, "Abu Dhabi Grand Prix", "Qualifying")
ver = session.get_driver("VER")

# Get a specific lap
lap = ver.get_lap(19)

# Access telemetry
telemetry = lap.telemetry
print(f"Telemetry points: {len(telemetry)}")
print(telemetry.head())

​
Telemetry Data Structure

The telemetry DataFrame includes these columns:
ColumnDescriptionUnit
TimeTime from lap startseconds
DistanceDistance from start linemeters
RelativeDistanceNormalized distance0-1
SpeedCar speedkm/h
RPMEngine RPM-
nGearGear number0-8
ThrottleThrottle position0-100%
BrakeBrake status0 (off) or 1 (on)
DRSDRS status0 (closed) or 1 (open)
X, Y, ZPosition coordinatesmeters
AccelerationXLateral accelerationm/s²
AccelerationYLongitudinal accelerationm/s²
AccelerationZVertical accelerationm/s²

​
Speed Analysis

Analyze speed throughout the lap: 
# Get telemetry
lap = ver.get_lap(19)
telemetry = lap.telemetry

# Speed statistics
max_speed = telemetry["Speed"].max()
min_speed = telemetry["Speed"].min()
avg_speed = telemetry["Speed"].mean()

print(f"Speed Statistics:")
print(f"  Max: {max_speed:.1f} km/h")
print(f"  Min: {min_speed:.1f} km/h")
print(f"  Avg: {avg_speed:.1f} km/h")

# Find where max speed occurs
max_speed_idx = telemetry["Speed"].idxmax()
max_speed_distance = telemetry.loc[max_speed_idx, "Distance"]
print(f"  Max speed at {max_speed_distance:.0f}m from start")

​
Throttle and Brake Analysis

Analyze driver inputs: 
# Throttle analysis
full_throttle_time = (telemetry["Throttle"] == 100).sum() / len(telemetry)
print(f"Full throttle: {full_throttle_time * 100:.1f}% of lap")

avg_throttle = telemetry["Throttle"].mean()
print(f"Average throttle: {avg_throttle:.1f}%")

# Brake analysis
braking_time = (telemetry["Brake"] == 1).sum() / len(telemetry)
print(f"Braking: {braking_time * 100:.1f}% of lap")

# Find braking zones
braking_points = telemetry[telemetry["Brake"] == 1]
if len(braking_points) > 0:
    print(f"\nBraking zones: {len(braking_points)} points")
    print(f"First brake at {braking_points['Distance'].iloc[0]:.0f}m")

​
RPM and Gear Analysis

Analyze engine and transmission: 
# RPM analysis
max_rpm = telemetry["RPM"].max()
avg_rpm = telemetry["RPM"].mean()

print(f"RPM Statistics:")
print(f"  Max: {max_rpm:.0f}")
print(f"  Avg: {avg_rpm:.0f}")

# Gear usage analysis
if "nGear" in telemetry.columns:
    gear_usage = telemetry["nGear"].value_counts().sort_index()
    
    print("\nGear Usage:")
    for gear, count in gear_usage.items():
        percentage = (count / len(telemetry)) * 100
        print(f"  Gear {int(gear)}: {percentage:.1f}%")
    
    # Highest gear used
    max_gear = telemetry["nGear"].max()
    print(f"\nHighest gear: {int(max_gear)}")

​
DRS Usage

Analyze DRS (Drag Reduction System) usage: 
if "DRS" in telemetry.columns:
    # DRS open percentage
    drs_open_time = (telemetry["DRS"] == 1).sum() / len(telemetry)
    print(f"DRS open: {drs_open_time * 100:.1f}% of lap")
    
    # DRS zones
    drs_points = telemetry[telemetry["DRS"] == 1]
    if len(drs_points) > 0:
        drs_start = drs_points["Distance"].iloc[0]
        drs_end = drs_points["Distance"].iloc[-1]
        print(f"DRS zone: {drs_start:.0f}m - {drs_end:.0f}m")
        
        # Speed gain with DRS
        speed_with_drs = drs_points["Speed"].mean()
        print(f"Average speed with DRS: {speed_with_drs:.1f} km/h")

​
Position and Acceleration Data

Analyze car position and G-forces: 
if "X" in telemetry.columns:
    print("\nPosition Data Available:")
    print(f"  X range: {telemetry['X'].min():.1f} to {telemetry['X'].max():.1f}m")
    print(f"  Y range: {telemetry['Y'].min():.1f} to {telemetry['Y'].max():.1f}m")

if "AccelerationY" in telemetry.columns:
    # Longitudinal acceleration (forward/braking)
    max_accel = telemetry["AccelerationY"].max()
    max_braking = telemetry["AccelerationY"].min()
    
    print(f"\nAcceleration Statistics:")
    print(f"  Max acceleration: {max_accel:.2f} m/s² ({max_accel / 9.81:.2f}g)")
    print(f"  Max braking: {max_braking:.2f} m/s² ({abs(max_braking) / 9.81:.2f}g)")

if "AccelerationX" in telemetry.columns:
    # Lateral acceleration (cornering)
    max_lateral = max(abs(telemetry["AccelerationX"].max()),
                     abs(telemetry["AccelerationX"].min()))
    print(f"  Max lateral: {max_lateral:.2f} m/s² ({max_lateral / 9.81:.2f}g)")

​
Comparing Two Laps

Compare telemetry between different laps: 
import matplotlib.pyplot as plt

# Get two laps from the same driver
lap1 = ver.get_lap(10)
lap2 = ver.get_lap(20)

tel1 = lap1.telemetry
tel2 = lap2.telemetry

# Compare speed traces
plt.figure(figsize=(12, 6))
plt.plot(tel1["Distance"], tel1["Speed"], label="Lap 10")
plt.plot(tel2["Distance"], tel2["Speed"], label="Lap 20")
plt.xlabel("Distance (m)")
plt.ylabel("Speed (km/h)")
plt.title("Speed Comparison - VER")
plt.legend()
plt.grid(True)
plt.show()

# Calculate speed difference
if len(tel1) == len(tel2):
    speed_diff = tel2["Speed"] - tel1["Speed"]
    print(f"Average speed difference: {speed_diff.mean():.2f} km/h")

​
Comparing Drivers

Compare telemetry between different drivers: 
# Get fastest laps for two drivers
ver = session.get_driver("VER")
ham = session.get_driver("HAM")

ver_fastest = ver.get_fastest_lap()
ham_fastest = ham.get_fastest_lap()

ver_lap_num = ver_fastest["LapNumber"].iloc[0]
ham_lap_num = ham_fastest["LapNumber"].iloc[0]

ver_lap = ver.get_lap(int(ver_lap_num))
ham_lap = ham.get_lap(int(ham_lap_num))

ver_tel = ver_lap.telemetry
ham_tel = ham_lap.telemetry

# Compare speed profiles
print("Speed Comparison (Fastest Laps):")
print(f"  VER max speed: {ver_tel['Speed'].max():.1f} km/h")
print(f"  HAM max speed: {ham_tel['Speed'].max():.1f} km/h")

# Compare throttle application
ver_full_throttle = (ver_tel["Throttle"] == 100).sum() / len(ver_tel) * 100
ham_full_throttle = (ham_tel["Throttle"] == 100).sum() / len(ham_tel) * 100

print(f"\nThrottle Comparison:")
print(f"  VER full throttle: {ver_full_throttle:.1f}%")
print(f"  HAM full throttle: {ham_full_throttle:.1f}%")

​
Corner Analysis

Identify and analyze corners: 
import numpy as np

# Find corners (where speed drops significantly)
telemetry = lap.telemetry

# Calculate speed changes
telemetry["SpeedChange"] = telemetry["Speed"].diff()

# Identify braking zones (corners)
braking_threshold = -10  # km/h per sample
corners = telemetry[telemetry["SpeedChange"] < braking_threshold]

print(f"Identified {len(corners)} braking points")

# Minimum speed corners (slowest corners)
if len(corners) > 0:
    # Group nearby points into corners
    corner_starts = []
    prev_dist = -1000
    
    for dist in corners["Distance"]:
        if dist - prev_dist > 200:  # New corner (>200m gap)
            corner_starts.append(dist)
        prev_dist = dist
    
    print(f"\nIdentified {len(corner_starts)} corners:")
    for i, dist in enumerate(corner_starts[:5], 1):
        corner_data = telemetry[
            (telemetry["Distance"] >= dist - 50) &
            (telemetry["Distance"] <= dist + 50)
        ]
        min_speed = corner_data["Speed"].min()
        print(f"  Corner {i} at {dist:.0f}m: min speed {min_speed:.1f} km/h")

​
Time Loss Analysis

Identify where time is lost between laps: 
# Compare two laps with similar telemetry point counts
lap1 = ver.get_lap(10)
lap2 = ver.get_lap(20)

tel1 = lap1.telemetry
tel2 = lap2.telemetry

# Resample to same distance points if needed
import pandas as pd

# Create common distance grid
dist_grid = np.linspace(0, tel1["Distance"].max(), 1000)

# Interpolate both laps to common grid
speed1 = np.interp(dist_grid, tel1["Distance"], tel1["Speed"])
speed2 = np.interp(dist_grid, tel2["Distance"], tel2["Speed"])

# Calculate speed difference
speed_diff = speed2 - speed1

# Find biggest losses
loss_threshold = -5  # km/h
loss_zones = dist_grid[speed_diff < loss_threshold]

if len(loss_zones) > 0:
    print(f"Speed loss zones:")
    for dist in loss_zones[:5]:
        loss = speed_diff[dist_grid == dist][0]
        print(f"  {dist:.0f}m: {loss:.1f} km/h slower")

​
Complete Telemetry Analysis Example

import tif1
import numpy as np

# Load session
session = tif1.get_session(2025, "Abu Dhabi Grand Prix", "Qualifying")
ver = session.get_driver("VER")

# Get fastest lap
fastest = ver.get_fastest_lap()
lap_num = fastest["LapNumber"].iloc[0]
lap = ver.get_lap(int(lap_num))
tel = lap.telemetry

print(f"VER FASTEST LAP TELEMETRY ANALYSIS")
print("=" * 60)

# 1. Speed analysis
print(f"\n1. SPEED")
print(f"   Max: {tel['Speed'].max():.1f} km/h")
print(f"   Min: {tel['Speed'].min():.1f} km/h")
print(f"   Avg: {tel['Speed'].mean():.1f} km/h")

# 2. Throttle analysis
full_throttle_pct = (tel["Throttle"] == 100).sum() / len(tel) * 100
print(f"\n2. THROTTLE")
print(f"   Full throttle: {full_throttle_pct:.1f}% of lap")
print(f"   Average: {tel['Throttle'].mean():.1f}%")

# 3. Brake analysis
braking_pct = (tel["Brake"] == 1).sum() / len(tel) * 100
print(f"\n3. BRAKING")
print(f"   Braking: {braking_pct:.1f}% of lap")

# 4. RPM analysis
print(f"\n4. RPM")
print(f"   Max: {tel['RPM'].max():.0f}")
print(f"   Avg: {tel['RPM'].mean():.0f}")

# 5. DRS usage
if "DRS" in tel.columns:
    drs_pct = (tel["DRS"] == 1).sum() / len(tel) * 100
    print(f"\n5. DRS")
    print(f"   Open: {drs_pct:.1f}% of lap")

# 6. Acceleration
if "AccelerationY" in tel.columns:
    max_accel = tel["AccelerationY"].max()
    max_brake = tel["AccelerationY"].min()
    print(f"\n6. ACCELERATION")
    print(f"   Max accel: {max_accel:.2f} m/s² ({max_accel/9.81:.2f}g)")
    print(f"   Max brake: {max_brake:.2f} m/s² ({abs(max_brake)/9.81:.2f}g)")

​
Next Steps

Build docs developers (and LLMs) love

Get started for freeTalk to us