F1 Data Junkie

F1 2011 Review - Ultimate Qualifying Deltas

2012-01-05T00:49:00.003Z

Given the fastest sector times for each driver during qualifying, we can calculate the "ultimate" lap time for each driver as the sum of their fastest sector times. If we then find the difference between this notional ultimate lap time and the fastest qualifying lap time recorded by for each driver, we can get an impression of how close to the limit each driver was performing during qualifying.

Here's the code:

require(RCurl) require(plyr) require(ggplot2) #This is a hack - is there a better way? nullmin=function(d) {if (is.finite(min(d,na.rm=T))) return(min(d,na.rm=T)) else return(NA)} gsqAPI = function(key,query,gid=0){ return( read.csv( paste( sep="",'http://spreadsheets.google.com/tq?', 'tqx=out:csv','&tq=', curlEscape(query), '&key=', key, '&gid=', curlEscape(gid) ), na.strings = "null" ) ) } key='0AmbQbL4Lrd61dEd0S1FqN2tDbTlnX0o4STFkNkc0NGc' ###Calculating how far off ultimate pace each driver is #Calculate the ultimate laptime qualiSectors2011=gsqAPI(key,'select *',5) ultimateQualiLap=ddply(.variables=c("race","driverName"),.data=qualiSectors2011,.fun= function(d) data.frame(d,ultimate=sum(d$sectortime))) #Calculate fastest qualifying time for each driver qdata=gsqAPI(key,"select *",4) minq=ddply(.variables=c("race","team","driverName"),.data=qdata,.fun= function(d) data.frame(minqt=nullmin(min(d$q1time,d$q2time,d$q3time,na.rm=T)))) #Find the fastest overall qualifying time for each race minq=ddply(.variables=c("race"),.data=minq,.fun= function(d) data.frame(d,qualimin=nullmin(d$minqt))) qualiData=unique(merge(minq,ultimateQualiLap,by=c("race","driverName"))) #Order the teams qualiData$team=factor(qualiData$team,levels=c("RBR-Renault","McLaren-Mercedes","Ferrari","Mercedes","Renault","Force India-Mercedes","Sauber-Ferrari","STR-Ferrari","Williams-Cosworth","Lotus-Renault","HRT-Cosworth","Virgin-Cosworth"),ordered=T) #Order the levels in the race factor in terms of calendar order qualiData$race=factor(qualiData$race,levels=c("AUSTRALIA","MALAYSIA","CHINA","TURKEY","SPAIN","MONACO","CANADA","EUROPE","GREAT BRITAIN","GERMANY","HUNGARY","BELGIUM","ITALY","SINGAPORE","JAPAN","KOREA","INDIA","ABU DHABI","BRAZIL"),ordered=T) ggplot(subset(qualiData))+geom_bar( stat = "identity",position="dodge",aes(x=race,y=ultimate-minqt,group=driverName,fill=factor(ifelse(driverNum>13,1+(1+driverNum)%%2,1+driverNum%%2))), se=FALSE)+opts(title="F1 2011 Qualifying - Personal Ultimate Lap Delta",axis.text.x=theme_text(angle=-90))+xlab(NULL)+ylab("Fastest lap time vs ultimate lap delta (s)")+scale_fill_manual(name="Driver Order",values = c("red","blue"))+ facet_wrap(~team)

F1 2011 Review - Qualifying Sector Times Normalised Against Mean Best Sector Times per Team

2012-01-04T00:08:00.000Z

Continuing the series of posts trying to get a handle on whether or not we can get an idea of how teams improved (or not) over the course of the season based on normalised sector times, here are a couple of charts where I took the best sector time per race per team, normalised against the mean of the best sector times per team per race.

The intention of this approach is to try to get away from any biases in the improvement cycle imposed by the times set by the fastest team in each sector that was implicit in the charts in the previous posts. But does this approach make sense? And do the charts reveal anything useful?

F1 2011 Review - Best Qualifying Sector Times By Team

2012-01-03T23:28:00.000Z

Complementing F1 2011 Review - Qualifying Sector Times, in which I plotted LOESS fitted curves to the qualifying times of both drivers in a team across the 2011 Formula One season races, here are a couple of charts that plot fitted curves against the best time recorded by each team for each sector in each race.

Firstly, a breakdown by sector:

Secondly, a breakdown by team:

I've updated the R-code gist if you want to try it out yourself.

F1 2011 Review - Qualifying Sector Times

2012-01-02T23:17:00.001Z

In a comment to F1 2011 Review - Qualifying Progress, James Beck wonders:

Trend lines are interesting. Are they related to performance upgrade package timing (maybe of leading car...) or are they due to track characteristics? I guess the next step would be to decide how we can differentiate between possible explanations.

As a first pass attempt at this, using the data available here, I wonder if we can use sector times to try to distinguish between track dependent improvements and car dependent improvements?

To do this properly, I guess we need to be able to categorise each sector of each track according to one of a limited set of factors that describe the characteristics of each sector, and then map sector times normalised with respect to overall fastest sector times (I wonder if it would also make sense to take into account variance/standard deviation of times across races/sectors too, and control for those? Eg rather than plotting the normalised time relative to fastest time, relating it to sd or some other measure of spread?)

Anyway, as a step towards that (does anyone have a categorisation of track sectors I could play with? If so, add a link in the comments:-) here are a couple of charts relating to the evolution of normalised sector times by team across the season.

First up, times by sector by team:

And here's sector time evolution by team:

I guess what both these charts show is that the relative performance changes from race to race across sectors do not necessarily correlate with each other. If we could categorise each sector for each track in a way that relates to dominant track features for the corresponding sector that might effect car performance, we might get a better idea of whether car updates or track features are influencing performance?

For the F1 sports journalist, might the charts hint towards any particular lines of investigation?

If you want to tinker yourself, here's the R code I used to generate the above charts from source data on Google spreadsheets (I run the code in R-Studio):

F1 2011 Review - Driver and Race Position Charts

2011-12-30T11:23:00.000Z

One problem with the charts shown in F1 2011 Review - Grid vs FInal Classification, Redux is that they're best seen LARGE, on a poster maybe... So I thought I'd unpick the scripts to create a function to display just the individual grid vs. final classification chart for an individual driver or race.

So for example, to display the chart for a given race we can call an R plotting function of the form:

racePosChart=function(df,race){ ggplot(df) + geom_hline(aes(yintercept=24-missing),size=0.5,colour="gray80") + geom_linerange(aes(ymin=grid,ymax=pos,x=driverNum,group=driverName,color=factor(pchange>0,labels=c("Loss","Gain"))),size=0.6) +geom_point(aes(x=driverNum,y=grid),col="gray50",size=1) + geom_point(aes(x=driverNum,y=pos),colour='gray50',size=1,shape=2) + opts(title=paste("F1 2011 ",race," Position Changes Grid-Final Classification"),axis.text.x=theme_text(angle=-90))+xlab(NULL)+ylab("Position") + scale_colour_discrete(name="Position Delta")+ylim(0,24) }

with something like:
racePosChart(subset(raceResults2011,race=="MALAYSIA"))
to generate a chart of the form:

(I tweaked the formula - the race name should also appear in the title. BUT the grid lines arenlt that clear - we really need to add a vertical grid line for each car number as well as adding an x-axis label for each car number.)

And for a plot based around driver, we can use something like:

driverPosChart=function(df){ ggplot(df) + geom_linerange(aes(x=race,ymin=24-missing,ymax=24),colour='gray50') + geom_point(aes(x=race,y=24-missing),colour='gray50',size=1,shape=3) + geom_point(aes(x=race,y=pos),colour='gray50',size=1,shape=2) + geom_linerange(aes(ymin=grid,ymax=pos,x=race,group=driverName,color=factor(pchange>0,labels=c("Loss","Gain"))),size=0.6) + facet_wrap(~driverName)+geom_point(aes(x=race,y=grid),col="gray50",size=1) + opts(title="F1 2011 Position Changes Grid-Final Classification",axis.text.x=theme_text(angle=-90))+xlab(NULL)+ylab("Position") + scale_colour_discrete(name="Position Delta") }

and a call of the form:

driverPosChart(subset(raceResults2011,driverName=="Adrian Sutil"))

to generate a chart like this:

Leaving the facet command in and only passing a single facet value in means that only a single panel is displayed, but the driver name is tastefully rendered in the panel top bar. BUT - the limits are off... The y-range starts at 5, rather than 1, for example. We need to add in something like +ylim(1,24)... I also need to add in grid lines for each race position... Bah:-(

F1 2011 Review - Grid vs FInal Classification, Redux

2011-12-29T18:05:00.003Z

In F1 2011 Review - Grid/Final Classification Deltas I posted a chart, slightly reminiscent of my race summary charts, showing the changes between grid position and final race classification as a coloured line segment (the colour denoting whether places were gained or lost).

One variant of the chart included a marker that represented how many cars were unclassified at the end of the race, but as a whole the chart was very unsatisfactory in the way it depicted this information. It was all but impossible to tell which car was in last position for example.

So here's an improved version of the chart, with a line graying out the unclassified positions. The + mark also identifies the last position in the race, so now it should be possible to identify how close to the back of the field each driver finished... (the circle highlights the grid position):

Here's the code fragment extending the code in the previous post that generates the plot:

ggplot(raceResults2011) + geom_linerange(aes(x=race,ymin=24-missing,ymax=24),colour='gray50') + geom_point(aes(x=race,y=24-missing),colour='gray50',size=1,shape=3) + geom_linerange(aes(ymin=grid,ymax=pos,x=race,group=driverName,color=factor(pchange>0,labels=c("Loss","Gain"))),size=0.6) + facet_wrap(~driverName)+geom_point(aes(x=race,y=grid),col="gray50",size=1) + opts(title="F1 2011 Position Changes Grid-Final Classification",axis.text.x=theme_text(angle=-90))+xlab(NULL)+ylab("Position") + scale_colour_discrete(name="Position Delta")

I also increased the thickness of the position change line by a small amount to make it a little more noticeable. (Note that the chart may be even clearer if we add in a marker highlighting the final classification, as in the chart below; this should do the trick: geom_point(aes(x=race,y=pos),colour='gray50',size=1,shape=2) )

Another view over the data can be generated with a couple of minor tweaks to the R expression above, recasting the chart so that results are displayed by race:

I use car number on the x axis because the drivers across races were not consistent. I also added in a marker to highlight the final classified position (using geom_point(aes(x=driverNum,y=pos),colour='gray50',size=1,shape=2)), in order to distinguish those cars that started and finished a race in the same position.

HEre's the modified R code:

ggplot(raceResults2011) + geom_linerange(aes(x=driverNum,ymin=24-missing,ymax=24),colour='gray50') + geom_point(aes(x=driverNum,y=24-missing),colour='gray50',size=1,shape=3) + geom_point(aes(x=driverNum,y=pos),colour='gray50',size=1,shape=2) + geom_linerange(aes(ymin=grid,ymax=pos,x=driverNum,group=driverName,color=factor(pchange>0,labels=c("Loss","Gain"))),size=0.6) + facet_wrap(~race)+geom_point(aes(x=driverNum,y=grid),col="gray50",size=1) + opts(title="F1 2011 Position Changes Grid-Final Classification",axis.text.x=theme_text(angle=-90))+xlab(NULL)+ylab("Position") + scale_colour_discrete(name="Position Delta")

PS Hmm... it strikes me that for the view by race chart, a horizontal line would serve better to identify the final position cut off point?

ie remove both:
geom_linerange(aes(x=driverNum,ymin=24-missing,ymax=24),colour='gray50')
which puts the uncliassified positions grey line in, and:
geom_point(aes(x=driverNum,y=24-missing),colour='gray50',size=1,shape=3)
which adds the last classified position maker, and replace them with:
geom_hline(aes(yintercept=24-missing),size=0.5,colour="gray80")

The plotting command is thus:

ggplot(raceResults2011) + geom_hline(aes(yintercept=24-missing),size=0.5,colour="gray80") + geom_linerange(aes(ymin=grid,ymax=pos,x=driverNum,group=driverName,color=factor(pchange>0,labels=c("Loss","Gain"))),size=0.6) + facet_wrap(~race)+geom_point(aes(x=driverNum,y=grid),col="gray50",size=1) + opts(title="F1 2011 Position Changes Grid-Final Classification",axis.text.x=theme_text(angle=-90))+xlab(NULL)+ylab("Position") + scale_colour_discrete(name="Position Delta")

It gives a much cleaner graphic, I think?

PS Bah... wrong function, wrong chart - I missed off the final position marker; function should be:

ggplot(raceResults2011) + geom_hline(aes(yintercept=24-missing),size=0.5,colour="gray80") + geom_linerange(aes(ymin=grid,ymax=pos,x=driverNum,group=driverName,color=factor(pchange>0,labels=c("Loss","Gain"))),size=0.6) + facet_wrap(~race)+geom_point(aes(x=driverNum,y=grid),col="gray50",size=1) + geom_point(aes(x=driverNum,y=pos),colour='gray50',size=1,shape=2) + opts(title="F1 2011 Position Changes Grid-Final Classification",axis.text.x=theme_text(angle=-90))+xlab(NULL)+ylab("Position") + scale_colour_discrete(name="Position Delta")

F1 2011 Review - Grid/Final Classification Deltas

2011-12-29T01:26:00.000Z

How does each team fare in terms changes between starting grid position and final classification across the races?

Note that position changes may be due to cars dropping out, although I still haven't found a good way of representing this yet. I guess one approach would be to identify the number of cars that dropped out in each race that started ahead of each car for each race, but I'm not sure how to calculate that (yet....?!)

In the meantime, here's an augmented version of the above chart that identifies the number of cars that were not classified at the end of each race:

Here's another take on position change between grid and final position per driver:

In this case, the line extends from grid position to final classification, and is coloured green for an improvement, red for a drop. The grey circle highlights the grid position, the grey + denotes the number of cars that were unclassified at the end of the race.

The R code used to generate the charts in this post from the raw data in a Google spreadsheet:

F1 2011 Review - Qualifying Progress

2011-12-28T14:58:00.001Z

I've added a little more data to the F1 2011 Year in Review spreadsheet, so here's a quick R script to generate a chart showing how the teams progressed during qualifying.

The following chart shows a loess model over the fastest times recorded by both drivers in the team during qualifying by each team over the 2011 season (so in constructing the model, there are two data points per team for each race):

This chart shows a loess model over the fastest time recorded within each team over all qualifying sessions:

Here's how they were created:

See also: F1 2011 Review - Another Look at Fastest Laptime Evolution

F1 2011 Review - Another Look at Fastest Laptime Evolution

2011-12-27T23:52:00.001Z

Following on from F1 2011 Progress Throughout the Year, I've had a bit of a tinker (see the comments to that post) and pushed on the graphical reporting a little to try to get a better picture of how the teams improved their relative laptimes over the course of the season.

The following chart shows a loess model of the minimum laptimes recorded by each team as a percentage of the fastest overall laptime recorded for each race:

This approach may mask which team set the actual fastest lap for each race, of course. So to see the evolution of actual fastest laptimes recorded by each team as a percentage of the overall fastest lap set in each race, we need a more literal plot (results are thresholded to only show results within 108% of the fastest laptime set in each race):

So - a useful plot, or not (e.g. in the sense of writing an end of year review?)? Is the fastest relative laptime set per team actually a useful indicator of a team's progress, or not? Would it be useful to generate this sort of chart following each race during a season, as an indicator of team progress?

Next up, comparing the fastest laptimes between two arbitrary teams... err.. maybe...?!

PS Err, not, actually. Instead, F1 2011 Review - Qualifying Progress

F1 2011 Progress Throughout the Year

2011-12-27T00:30:00.000Z

Prompted by a comment from @sidepodcast, I thought I'd try to come up with some ways of tracking how the teams made progress over the course of 2011. This is still a work in progress, but here are some early thoughts based on fastest lap time recorded by the teams in each car recorded across the season.

The charts I've been exploring rely on taking the fastest overall laptime for each race, and then using this to scale the fastest laptime of every car in the race according the formula:

scaled time for car N = fastest lap time for car N / fastest overall laptime

The fastest car thus has scaled laptime of 1.0, and slower cars have a scaled laptime of greater than 1.

Looking at the times for a particular team, we get scatterplots that look something like this:

Looking at these times, we see that Mercedes appeared to be off the pace compared to the fastest lapping car in Australia, had a reasonable run from Malaysia to Turkey, fell back in Spain but then steadily improved (relative to the fastest lapping car) in the run through to Japan (with a blip in Singapore), then fell back but held steady over the last four races.

We could instead connect the points to generate a line chart, but the impression we get as a result is rather ragged and it can be hard to detect any meaningful trend across the season:

If we group the drivers in each team to get two samples (usually!) for the fastlap time for each race, and then generate a simple linear model/best fit line through this data, we can generate a visualisation that may help us identify a general trend in performance of each team based on a comparison with the fastest lap times recorded overall. These trend lines then suggest how much progress each team makes in the wider scheme of things - that is, compared to the fastest lapping car in each race. (Note that we may get a different picture if we compared the laptimes of one team with the fastest laptime recorded by another team... which I guess I could leave as an exercise for the reader?!;-))

Other best fit models are, of course, possible - here's the LOESS algorithm

Here are the charts showing the best fit lines for each team (note that outlier times have been excluded from the best fit line calculation (err, I think?!), first a simple linear model:

Then using LOESS:

See also: F1 2011 Review - Another Look at Fastest Laptime Evolution for an improved chart that plots the fastest laptime recorded by each team for each race.

Note: whilst I was collecting timing data over the course of the year, I cheated for this post and grabbed the data from the formula1.com results pages. Here's the Python script I used to scrape the data (data as a spreadsheet).

I then used R via RStudio and the ggplot2 library to generate the plots:

require(ggplot2)
#load in the CSV filed saved from the spreadsheet
#Note: we could load it in direct from the spreadsheet
#fastestLaps2011x <- read.csv("~/code/f1/fastestLaps2011.csv")

#Find the fastest times in each race
mintimes=tapply(fastestLaps2011x$stime,fastestLaps2011$race,min)
#Add the fastest time in each race to each row
fastestLaps2011x$min=sapply(fastestLaps2011x$race,function(d) mintimes[d])
#Calculate the fastest lap time ratio 
fastestLaps2011x$minstimepc=fastestLaps2011x$stime/fastestLaps2011$min

#Order the levels in the race factor in terms of calendar order
fastestLaps2011x$race=factor(fastestLaps2011$race,levels=c("AUSTRALIA","MALAYSIA","CHINA","TURKEY","SPAIN","MONACO","CANADA","EUROPE","GREAT BRITAIN","GERMANY","HUNGARY","BELGIUM","ITALY","SINGAPORE","JAPAN","KOREA","INDIA","ABU DHABI","BRAZIL"),ordered=T)

#Order the teams
fastestLaps2011x$team=factor(fastestLaps2011$team,levels=c("RBR-Renault","McLaren-Mercedes","Ferrari","Mercedes","Renault","Force India-Mercedes","Sauber-Ferrari","STR-Ferrari","Williams-Cosworth","Lotus-Renault","HRT-Cosworth","Virgin-Cosworth"),ordered=T)

#Command used to generate the Mercedes scatterplot
ggplot(subset(fastestLaps2011x,driverNum==7 | driverNum==8)) + geom_point(aes(x=race,y=minstimepc,col=factor(driverNum))) + opts(title="F1 2011 - Fastest Lap Comparison (Mercedes)",axis.text.x=theme_text(angle=-90)) + scale_colour_discrete(name="Driver Number") + xlab(NULL) + ylab("Fastest laptime as % of fastest overall laptime") + ylim(1.00,1.1)

#Command used to generate the Mercedes line plot
ggplot(subset(fastestLaps2011x,driverNum==7 | driverNum==8)) + geom_line(aes(x=race,y=minstimepc,col=factor(driverNum),group=driverNum)) + opts(title="F1 2011 - Fastest Lap Comparison (Mercedes)",axis.text.x=theme_text(angle=-90)) + scale_colour_discrete(name="Driver Number") + xlab(NULL) + ylab("Fastest laptime as % of fastest overall laptime") + ylim(1.00,1.1)

#Command used to generate the Mercedes scatterplot plot and simple linear model
ggplot(subset(fastestLaps2011x,driverNum==7 | driverNum==8)) + geom_point(aes(x=race,y=minstimepc,col=factor(driverNum))) + opts(title="F1 2011 - Fastest Lap Comparison (Mercedes)",axis.text.x=theme_text(angle=-90)) + scale_colour_discrete(name="Driver Number") + xlab(NULL) + ylab("Fastest laptime as % of fastest overall laptime") + ylim(1.00,1.1) + stat_smooth(method="lm",aes(x=race,y=minstimepc,group=team,col=factor(team)), se=FALSE)

#Command used to generate the Mercedes scatterplot plot and loess best fit
ggplot(subset(fastestLaps2011x,driverNum==7 | driverNum==8)) + geom_point(aes(x=race,y=minstimepc,col=factor(driverNum))) + opts(title="F1 2011 - Fastest Lap Comparison (Mercedes)",axis.text.x=theme_text(angle=-90)) + scale_colour_discrete(name="Driver Number") + xlab(NULL) + ylab("Fastest laptime as % of fastest overall laptime") + ylim(1.00,1.1) + stat_smooth(method="loess",aes(x=race,y=minstimepc,group=team,col=factor(team)), se=FALSE)

#Command used to generate team based linear models 
ggplot(fastestLaps2011x)+stat_smooth(method="lm",aes(x=race,y=minstimepc,group=team,col=factor(team)), se=FALSE)+ylim(0.99,1.10)+opts(title="F1 2011 Fastest Laptime Evolution",axis.text.x=theme_text(angle=-90))+scale_colour_manual(name="Teams",values = c("blue","darkgray","red","lightsteelblue3","goldenrod3","darkorange","gray8","firebrick4","midnightblue","darkgreen","gray0","darkred")) + xlab(NULL) + ylab("Fastest laptime as % of fastest overall laptime")

#Command used to generate team based loess models 
ggplot(fastestLaps2011x)+stat_smooth(method="loess",aes(x=race,y=minstimepc,group=team,col=factor(team)), se=FALSE)+ylim(0.99,1.10)+opts(title="F1 2011 Fastest Laptime Evolution",axis.text.x=theme_text(angle=-90))+scale_colour_manual(name="Teams",values = c("blue","darkgray","red","lightsteelblue3","goldenrod3","darkorange","gray8","firebrick4","midnightblue","darkgreen","gray0","darkred")) + xlab(NULL) + ylab("Fastest laptime as % of fastest overall laptime")

F1 2011 Brazil Reports...

2011-11-28T00:35:00.000Z

...are on http://f1datajunkie.posterous.com/...

e.g. Brazil race report

I'll be posting about the visualisations I've been putting into the various reports on this blog over the coming weeks...

F1 2011 India Qualifying Report

2011-10-29T12:39:00.002+01:00

My stats graphics qualifying report for the 2011 Formula One Indian Grand Prix qualifying session can be found at: F1 2011 India - Qualifying Stats Graphics Report

F1 2011 India Practice - Stats Graphs Reports

2011-10-29T09:31:00.000+01:00

I've started doing something new for this weekend - programmatically generating reports from timing data...

You can see a copy of the Indian Free Practice sessions at: October 29, 2011 F1 2011 India - Practice Sessions Stats Graphics Report

F1 2011 Korea Race - Position Density

2011-10-23T15:20:00.002+01:00

A new chart type, worked up to help @sidepodcast's Mr C try to remember want went on during the Korea race so he could make his "driver of the day" pick for the race review podcast.

The idea behind this chart is that we plot how much time each car spent in each race position, the idea being that if the car did not spend the whole race in the same position, then the driver had an interesting race...

Of course, it might be the case that the driver was caught in a battle for the whole race without making (or losing) places, so to complement the above, here's a chart that shows how much time was spent within a certain time distance of the car in the race position in front, and the car in the race position behind, taken over the whole of the race.

So for example, car 2 spent quite a lot of time attacking, car 3 spent a fair amount of time defending, car 1 was safe from attackers for a lot of the race, car 4 was busy in attack and defence. Cars 16 and 20 also seemed quite busy?

Looking at the two charts together, car 14 maybe worth having a look at too in terms of 'race interestingness", as do cars 18 and 19, which have quite big spreads in terms of position density?

F1 2011 Korea Race Summary Chart, Laptime Distribution and Podium Battle Charts

2011-10-16T10:49:00.003+01:00

A quick review of the F1 200 Korean Grand Prix.

Race Summary Chart:

(Bah - need to tweak the legend:-(

Laptime Distributions:

Here are the laptimes as a heatmap:

Race Battle Charts for first, second and third positions:

Sidepodcast "Driver of the day" layout experiement:

F1 2011 Korea FP3 and Qualifying

2011-10-15T10:21:00.000+01:00

Here's how the teams made use of FP3:

And here's how their speeds/times compared in qualifying:

F1 2011 Korea FP1 and FP2 Session Utilisation

2011-10-14T10:12:00.000+01:00

Here's how the teams made use of Free Practice 1 and Free Practice 2 during the 2011 Korean Grand Prix race weekend:

To Do - Track Evolution

2011-10-12T09:40:00.001+01:00

A features post on the Official F1 site briefly reviews the idea of track evolution: Track evolution - the change from green to mean.

The press-released FIA timing data doesn't provide sector times for P1-3,and only provides best lap sector times from qualifying and the race, so we can't use that data to get much of a feel for track evolution. However, I have been pondering some simple stint models, and I guess 'trackEvolution' is one of the factors that might play a role in that?

In other news, for those of you lucky enough to be able to gain access to academic literature, this might be of interest: Automatic Track Generation for High-End Racing Games Using Evolutionary Computation, Loiacono, D. Cardamone, L. Lanzi, P.L., IEEE Trans Computational Intelligence and AI in Games, Sept. 2011, 3(3), pp. 245-259

F1 2011 Japan Race Laptime Distributions

2011-10-09T22:23:00.001+01:00

A couple of overviews of the laptime distributions for the 2011 Japanese Grand Prix. Firstly, by car:

Note that we can get an at a glance view that indicates how many pitstops each car was involved with an how much time was lost comparatively during the pitstops.

And by lap:

This view shows when pit stops were kicking in (though not by which car) as well as 'notable' circuit-wide activity, such as the presence of the safety car.

See also: F1 2011 Japan Race Summary Chart and P1-3 Battle Charts

F1 2011 Japan Race Summary Chart and P1-3 Battle Charts

2011-10-09T10:59:00.001+01:00

Here's an (unchecked) version of the Race Summary Chart for the 2011 Japanese Formula One Grand Prix...

Here's the battle chart for first:

And for second:

And for third:

(About the race battle charts)

NOTE TO SELF: I really need to add in titles for these, and also generate a legend to identify teams/drivers...

F1 2011 Japan Qualifying - Sector Speed/Time Comparison

2011-10-08T15:53:00.004+01:00

A quick comparison of sector speeds/times (based on the technique demonstrated in F1 2011 Singapore Qualifying - Sector Times and Speeds):

Nodes are coloured by team (using colour values identified in F1 2011 Singapore - Race Battle Charts), with symbol shape depicting driver (circle: driver 1, triangle: driver 2)

(Click on column heading to sort table by that column.))

F1 2011 Japan Practice

2011-10-08T12:39:00.001+01:00

A quick round-up of practice utilisation and raw laptime distribution:

I'll pop stats images relating to the weekend in this gallery.

F1 2011 Singapore - Race Battle Charts

2011-10-07T00:19:00.000+01:00

Whist chatting to someone the other day about F1 data visualiastions, it was suggested to me that I look for some sort of depiction of "aggressiveness" that could be used to compare driver behaviours. The resolution of data that I have insofar as it relates to overtaking is very patchy indeed, limited essentially to checking the position of drivers at the end of each lap.

(This isn't quite as simple as seeing if the race position has changed. Suppose the race positions of cars 1 to 4 are 1234 at the end of one lap, and 3214 at the end of the second. Car 2 hasn't changed position in terms of race position, but they may have been overtaken by car 3 and also overtaken car 1. In addition, some position changes may result from a car ahead pitting, or the car of interest pitting. If the car ahead pits when 30s ahead, leaves the pits 1 second ahead and then gets overtaken on the out lap, will the timing data allow us to put down an change of position due to a racing overtake, as opposed to a position change resulting from a pitstop? And so on...)

Anyway, the comment did remind me of the race battle charts that I experimented with a few months ago. The idea of these charts was to look at the state of a race from the perspective of a a particular driver. The chart showed the position of the car of interest, along with with time to the car in front and behind the target car on track, as well as the time to the car in front and behind in terms of race position.

Here's a way of creating those charts in R, for example looking at Hamilton's race from Singapore:

library(RCurl) gsqAPI = function(key,query,gid=0){ return( read.csv( paste( sep="",'http://spreadsheets.google.com/tq?', 'tqx=out:csv','&tq=', curlEscape(query), '&key=', key, '&gid=', curlEscape(gid) ) ) ) } a=gsqAPI('0AmbQbL4Lrd61dHIzU3dveE5XbkpQS0NCMi1vazY1MVE','select *',10) a$posdelta=c(0,diff(a$pos)) a$stop=by(a, 1:nrow(a), function(row) if (row$pitstop==1) row$pitstop else NA) x=3 mycolours=c(26,26,178,178,33,33,270,270,142,142,254,254,13,128,128,630,630,139,139,501,501,32,32) mycolourfn=function(x) colours()[mycolours[x]] myshapes=c(1,2,1,2,1,2,1,2,1,2,1,2,5,1,2,1,2,1,2,1,2,1,2,1,2) myshapefn=function(x) myshapes[x] plot(-5*posdelta~lap,data=subset(a,car==x),col=mycolourfn(car),ylim=c(-20,20),pch=myshapefn(car))+points(timeToPosInFront~lap,data=subset(a,car==x),pch=3,col=5)+points(timeToPosBehind~lap,data=subset(a,car==x),pch=4,col=5)+points(timeToTrackInFront~lap,data=subset(a,car==x),pch=5,col=8)+points(timeToTrackBehind~lap,data=subset(a,car==x),pch=6,col=8)+points(-20*stop~lap,data=subset(a,car==x),pch=0,col=2)

Here's the result, for car 3 - Hamilton:

Perhaps not surprisingly, not many people liked these charts, in part because of the clutter, in part because it was hard to see what was going on very clearly. (Here are a couple of tips for reading the chart, which I modified slightly in the above case. The circles represent the target car; when the circle lays on the x-axis, the race position hasn't changed from the previous lap. For the circles, the y-value is 5 times the change in race position from the previous lap (a value of +5 shows the car improved it's position by 1 place compared to the previous lap). The blue pluses above the x-axis show the time to the car in the race position ahead, the gray diampnds above the line the time to the car ahead on track. The blue crosses below the x-axis are the time to the car in the race position behind, and the gray triangles the time to the car immediately behind on track. The red squares show a pitstop. Reading the chart, we can easily see how in the stint between laps 40 and 50 or so, the car in race position ahead was closed in on for a couple of laps before it started getting away again, while the car in race position behind was being easily left behind. Round about lap 55, we see there is at least one car on track between the target car and the car in race position ahead. We also note that pitstops generally result in a change of position for the worse on the following lap.)

Whilst reflecting on the R formula for plotting the battle chart, it struck me that rather than focus on a target car, we could instead focus on the car in a race position. This results in a set of charts that allow us to look at the battle for a particular race position over the lifetime of the race. In the following examples, the colour of the target car identifies the team, and the shape of the symbol used to denote the position car (in the main, the symbol that lays along the x axis) is the first or second car in the team. If you get your eye in with the colours used for the different teams, you should be able to work out which cars are being described...

Here's an example showing the race from second (which happened to be Button throughout the race):

Here's the code that generated that view:

x=2 plot(-5*posdelta~lap,data=subset(a,pos==x),col=mycolourfn(car),ylim=c(-20,20),pch=myshapefn(car))+points(timeToPosInFront~lap,data=subset(a,pos==x),pch=3,col=8)+points(timeToPosBehind~lap,data=subset(a,pos==x),pch=4,col=8)

If we set x=3 for position 3, and rerun the plot, we get:

In this case, we see a variety of cars were in third place over the course of the race: Ferrari driver 1 (red circle), Red bull driver 2 (dark blue triangle), Force India driver 2 (light blue triangle). The light grey plusses above the line are time to position in front, and the light gray corsses below the line are the time to the car in the race position behind. If the target car is above the x-axis, that shows (divided by 5) how many places they gained to take the position compared to the previous lap, and below the line how many places they lost compared to the previous lap to take the position.

To get a feel for lower down the points, here's the race for 10th:

On the to do list: sort out chart titles and axis labels, work up a key, and maybe sort out better colour mappings. (If you want to play along, pop a list of suggested colours using the chart at http://research.stowers-institute.org/efg/R/Color/Chart/ I should use to describe each team;-)

PS via a comment, I am alerted to the Intelligent F1 blog. Built around a model that predicts race behaviour, this like s like a great site to go for involved and thought through race based analyses built around actual timing data and model based predictions.

F1 2011 Singapore - Race Summary Chart and Laptime Heatmap

2011-09-25T16:42:00.000+01:00

Hot of the press (and half an hour later than it should have been:-(, here's the Race Summary Chart for the 2011 Singapore Formula One Grand Prix:

(Red dot: grid position; black dot - final position; plus/horizontal tick mark - position at end of lap 1; vertical line - range of positions held during race.)

And here's the laptime heat map:

(Hot red colours are faster laps, yellow laps are slower ones, and indicate PIT activity or the presence of a safety car.)

If we colour the map according to the difference in laptime for each car given it's current and previous lap time, we see the pit and safety car activity more clearly:

(Note to self: work out how to do colour palette mapping in a non-linear way. Also pick out fastest laps and purple laps.)

F1 2011 Singapore Qualifying - Sector Times and Speeds

2011-09-25T00:27:00.005+01:00

Whilst FP2 is typically the session we can get a feel for long run stint times, and as a result, maybe some idea of race pace, the qualifying session is the first session for which we get official FIA timing sheets detailing sector times and speeds.

Here's a summary view over the sector times and speeds taken from the qualifying sessions:

How to read it: at first glance, this graphic might seem rather difficult to read, so here are some pointers. Each box compares two pieces of data for each of the 24 drivers (that is in each chart, each circle represents one of the 24 drivers). The data that we plot is taken from the set of best sector times and speeds achieved by each driver during qualifying. If you look down the diagonal that goes top left to bottom right, you will see a label - Sector1, Sector 2, and so on. That label defines the x-axis category along a row, and the y-axis gategory up and down the corresponding column. If we look at the second box along the top row, it this represents Sector 2 times along the x-axis and Sector 1 times on the y-axis. If we look at the third box down the rightmost column, it represents the trap speed on the x-axis and the Sector 3 time on the y-axis.

We can use this chart to get a feel for how speeds and sector times correlate over the track. (That is, the extent to which the fastest cars get the quickest times - which is not always the case...) If each got exactly the same time in each sector as it did in the first sector, then if we plotted the sector 1 times against the sector 2 or sector 3 times, the points would all lay along a diagonal line. If the sector time was a simple function of the speed (so if sectorTime = k x sectorSpeed), we would also get the points laying on a diagonal line. The extent to which points fall off the diagonal gives us an indication as to how much the cars vary in perfromance across each sector.

In the images shown it's not obvious which car corresponds to which circle (though we could at a push work it out from the timing sheets).

To try to make the graph a little easier to read, I experimented with adding a little colour, in this case corresponding to the teams.

Here we can see a little (but only a little!) more clearly how the teams are distributed in terms of performance. SO for example, we see the faint yellow symbols (Red Bull) have very quick sector times (sector1, sector2, sector3), but they are really quite slow according to the inter1 speed trap, middling on inter2 and speed trap speeds, and pretty fast at the finish.

To check our reading of the charts, we can sort the results according to sector time or speed trap by clicking on the sortable table column headers below:

If there are any other insights you think you can get from the above charts, please add them on the comments. If you have any ideas of charts you might one to look at in more detail, and how they might be improved to make them clearer to "read", please post suggestions (and maybe even R code?!;-) in the comments too:-)

PS Here's how the chart was generated (R code):

### @export "data-constants" sskey='0AmbQbL4Lrd61dHIzU3dveE5XbkpQS0NCMi1vazY1MVE' ### @export "data-import" require(RCurl) require(lattice) gsqAPI = function(key,query,gid){ return( read.csv( paste( sep="", 'http://spreadsheets.google.com/tq?', 'tqx=out:csv', '&tq=', curlEscape(query), '&key=', key, '&gid=', curlEscape(gid) ) ) ) } qualidata=gsqAPI(sskey,'select *',gid='7') qualidata=subset(qualidata,sector1 > 0 & sector2 > 0 & sector3 > 0) pairs(qualidata[c(4,5,6,10,11,12,13)], col=qualidata$team)

What I think this sort of chart may be useful for is getting an at-a-glimpse overview of where the major differences in respective performance lay, under the assumption that those sectors may be the sectors that will make an actual difference to the race...

The question now is, how can we zoom in to any particular chart shown in the lattice grid above, and look at each point labeled with the corresponding driver's name...?