Skip to content

Without the hype

Writing Heat pumps Energy Economics Reviews Discount & referral codes Calculators About Contact

The A40 West Witney Roundabout: What Slowing Down Costs in CO2

A calculator for the extra fuel and CO2 from cars, vans and lorries braking for the West Witney roundabout on the A40 and accelerating back up to speed, from the DfT’s traffic counts for that stretch.

Since 25 August 2018, traffic on the A40 dual carriageway west of Witney has had to go round a new roundabout by the Downs Road bridge, built to give access to the West Witney housing development. Every car, van and lorry on the A40 now brakes from 60 or 70 mph to roundabout speed, or to a stop, and then burns fuel to get back up to speed. This calculator works out how much fuel and CO2 that costs.

The traffic figures are the Department for Transport’s annual average daily flows for the stretch of the A40 between the B4047 at Minster Lovell and the A415 at Ducklington, which takes in the roundabout (count point 6434). In 2025 that was 15,769 vehicles a day, both directions together, of which 1,158 were lorries.

How it is worked out

A vehicle moving at speed v carries kinetic energy of ½mv². Slowing from approach speed v₁ to roundabout speed v₂ gives up ½m(v₁² − v₂²), and the engine has to put it all back afterwards. A vehicle that has to stop gives up all of it.

Not all of that energy is wasted. When a driver lifts off early and coasts, the vehicle’s own momentum carries it along a stretch of road it would otherwise have used fuel to drive along, so that part does useful work. Only the energy turned into heat in the brakes (or in engine braking) is lost. The calculator takes a share of the slowing as done on the brakes.

The lost energy is then turned into fuel by the engine’s efficiency when accelerating (a petrol car turns about 28% of its fuel’s energy into motion under firm acceleration, a lorry’s diesel nearly 40%), and into litres and CO2 with the government’s conversion factors. Electric cars get most of their braking energy back through regenerative braking, so they lose only the remainder, charged from the grid.

Your figures

aadf = [
  {year: 2018, car: 12538, lgv: 2232, hgv: 948,  bus: 31, mc: 32},
  {year: 2019, car: 12815, lgv: 1907, hgv: 1012, bus: 41, mc: 136},
  {year: 2020, car: 9358,  lgv: 1632, hgv: 906,  bus: 26, mc: 101},
  {year: 2021, car: 10234, lgv: 1869, hgv: 969,  bus: 31, mc: 105},
  {year: 2022, car: 10984, lgv: 2082, hgv: 997,  bus: 33, mc: 116},
  {year: 2023, car: 11740, lgv: 2322, hgv: 1166, bus: 71, mc: 117},
  {year: 2024, car: 11881, lgv: 2363, hgv: 1158, bus: 71, mc: 116},
  {year: 2025, car: 12008, lgv: 2413, hgv: 1158, bus: 71, mc: 120}
]
latest = aadf[aadf.length - 1]
opened = new Date(2018, 7, 25)
// Fuel: energy per litre (net calorific value, E10 petrol and B7 diesel) and kg CO2e per litre (UK government
// conversion factors, average biofuel blend)
fuel = ({
  petrol: {kwhPerLitre: 8.8, co2PerLitre: 2.08},
  diesel: {kwhPerLitre: 9.9, co2PerLitre: 2.51}
})
mph = 0.44704                  // m/s per mph
rotational = 1.05              // wheels, gearbox and engine spinning up add about 5% to the energy of the body
evDriveEfficiency = 0.77       // grid to wheels: charging and battery losses, motor and inverter
classes = [
  {key: "car", name: "Cars and taxis", mass: 1600,  speed: 65, slow: 20, eff: 28, fuelType: "car"},
  {key: "lgv", name: "Vans (LGVs)",     mass: 2400,  speed: 65, slow: 20, eff: 32, fuelType: "diesel"},
  {key: "hgv", name: "Lorries (HGVs)",  mass: 20000, speed: 56, slow: 15, eff: 38, fuelType: "diesel"},
  {key: "bus", name: "Buses and coaches", mass: 12000, speed: 56, slow: 15, eff: 36, fuelType: "diesel"},
  {key: "mc",  name: "Motorcycles",     mass: 280,   speed: 65, slow: 20, eff: 25, fuelType: "petrol"}
]
colours = ({car: "#2f6aa3", lgv: "#4a9a8f", hgv: "#c0713a", bus: "#8a6bb0", mc: "#9a9d95"})

At the roundabout

viewof stopShare = Inputs.range([0, 100], {value: 20, step: 1, label: "Vehicles that have to stop (%)"})
viewof brakeShare = Inputs.range([0, 100], {value: 70, step: 5, label: "Slowing done on the brakes, not coasting (%)"})

The rest slow to the roundabout speed in the table below and drive round without stopping.

Cars on the road

viewof evShare = Inputs.range([0, 100], {value: 7, step: 1, label: "Cars that are electric (%)"})
viewof dieselShare = Inputs.range([0, 100], {value: 35, step: 1, label: "Other cars that are diesel (%)"})
viewof regen = Inputs.range([0, 90], {value: 60, step: 5, label: "Braking energy an electric car gets back (%)"})

Fuel and the grid

viewof gridCO2 = Inputs.range([0, 0.5], {value: 0.131, step: 0.001, label: "Grid electricity (kg CO2/kWh)"})
viewof petrolPrice = Inputs.range([80, 250], {value: 172.8, step: 0.1, label: "Petrol (p/litre)"})
viewof dieselPrice = Inputs.range([80, 250], {value: 198.6, step: 0.1, label: "Diesel (p/litre)"})

UK average pump prices in the government’s weekly figures for 2 November 2026.

The vehicles

// One row of typed-in figures for each kind of vehicle; every cell can be typed over
viewof veh = {
  const fields = ["mass", "speed", "slow", "eff"];
  const cell = (c, f) => html`<input type="number" min="0" step=${f === "mass" ? 50 : 1} value=${c[f]} data-k=${c.key} data-f=${f}>`;
  const form = html`<div class="je-table-wrap"><table class="rb-vehicles">
    <thead><tr><th></th><th>Average weight (kg)</th><th>Speed on the A40 (mph)</th><th>Speed round the roundabout (mph)</th>
      <th>Engine efficiency accelerating (%)</th></tr></thead>
    <tbody>${classes.map(c => html`<tr><td>${c.name}</td>${fields.map(f => html`<td>${cell(c, f)}</td>`)}</tr>`)}</tbody>
  </table></div>`;
  const read = () => Object.fromEntries(classes.map(c => [c.key,
    Object.fromEntries(fields.map(f => [f, +form.querySelector(`input[data-k="${c.key}"][data-f="${f}"]`).value || 0]))]));
  form.value = read();
  form.addEventListener("input", () => { form.value = read(); });
  return form;
}

Weights include the driver, passengers and load. The lorry figure is an average across everything the DfT counts as an HGV, from a small rigid truck to a fully laden 44-tonne articulated lorry. Lorries are limited to 56 mph; the car and van speeds are typical of free-flowing traffic on a 70 mph dual carriageway.

perPass = classes.map(c => {
  const v = veh[c.key];
  const v1 = v.speed * mph, v2 = Math.min(v.slow, v.speed) * mph, p = stopShare / 100;
  // kinetic energy given up, averaged over the vehicles that stop and those that don't (kWh)
  const shed = 0.5 * v.mass * rotational * ((1 - p) * (v1 ** 2 - v2 ** 2) + p * v1 ** 2) / 3.6e6;
  const lost = shed * brakeShare / 100;
  const eff = Math.max(v.eff, 1) / 100;
  // fuel used to put the lost energy back: litres of petrol and diesel, and kWh from the grid, per vehicle
  let petrol = 0, diesel = 0, elec = 0;
  if (c.fuelType === "car") {
    const e = evShare / 100, d = (1 - e) * dieselShare / 100, g = (1 - e) * (1 - dieselShare / 100);
    petrol = g * lost / eff / fuel.petrol.kwhPerLitre;
    diesel = d * lost / (eff + 0.04) / fuel.diesel.kwhPerLitre;      // a diesel car is a few points more efficient
    elec = e * lost * (1 - regen / 100) / evDriveEfficiency;
  } else if (c.fuelType === "diesel") diesel = lost / eff / fuel.diesel.kwhPerLitre;
  else petrol = lost / eff / fuel.petrol.kwhPerLitre;
  const co2 = petrol * fuel.petrol.co2PerLitre + diesel * fuel.diesel.co2PerLitre + elec * gridCO2;
  const cost = (petrol * petrolPrice + diesel * dieselPrice) / 100 + elec * 0.25;
  return {...c, shed, lost, petrol, diesel, elec, litres: petrol + diesel, co2, cost};
})
yearly = perPass.map(r => {
  const n = latest[r.key];
  return {...r, daily: n, co2Year: r.co2 * n * 365 / 1000, litresYear: r.litres * n * 365, costYear: r.cost * n * 365};
})
totals = ({
  co2Year: d3.sum(yearly, d => d.co2Year), litresYear: d3.sum(yearly, d => d.litresYear),
  costYear: d3.sum(yearly, d => d.costYear), daily: d3.sum(yearly, d => d.daily)
})
// Every year since the roundabout opened, counting only the days it was open; years after the latest DfT figures
// use the latest
history = {
  const today = new Date(), rows = [];
  for (let y = 2018; y <= today.getFullYear(); y++) {
    const start = y === 2018 ? opened : new Date(y, 0, 1);
    const end = y === today.getFullYear() ? today : new Date(y + 1, 0, 1);
    const days = Math.max(0, (end - start) / 864e5);
    const flow = aadf.find(d => d.year === y) ?? latest;
    for (const r of perPass) rows.push({year: y, key: r.key, name: r.name, days,
      partial: y === 2018 || y === today.getFullYear(), estimated: !aadf.some(d => d.year === y),
      tonnes: r.co2 * flow[r.key] * days / 1000, litres: r.litres * flow[r.key] * days});
  }
  return rows;
}
sinceOpening = ({tonnes: d3.sum(history, d => d.tonnes), litres: d3.sum(history, d => d.litres)})
// For comparison: an average car (about 0.166 kg CO2e a km, UK government factors) and a gas-heated home
// (Ofgem's typical 11,500 kWh of gas a year at 0.182 kg CO2e/kWh)
carKm = 0.166
homeTonnes = 11500 * 0.182 / 1000
fmt = (v, d = 0) => v.toLocaleString("en-GB", {maximumFractionDigits: d, minimumFractionDigits: d})
gbp = v => "£" + fmt(Math.round(v))

html`<div class="rb-tiles">
  <div class="rb-tile"><div class="k">CO2 a year</div><div class="v">${fmt(totals.co2Year)} t</div>
    <div class="s">as much as heating ${fmt(totals.co2Year / homeTonnes)} homes with gas, or driving an average car ${fmt(totals.co2Year * 1000 / carKm / 1e6, 1)} million km</div></div>
  <div class="rb-tile"><div class="k">Fuel a year</div><div class="v">${fmt(totals.litresYear / 1000)}k litres</div>
    <div class="s">about ${fmt(totals.litresYear / 365)} litres every day, costing drivers ${gbp(totals.costYear)} a year</div></div>
  <div class="rb-tile"><div class="k">Since it opened</div><div class="v">${fmt(sinceOpening.tonnes)} t</div>
    <div class="s">of CO2 from ${fmt(sinceOpening.litres / 1e6, 1)} million litres of fuel, 25 August 2018 to today</div></div>
  <div class="rb-tile"><div class="k">Per car</div><div class="v">${fmt(perPass[0].co2 * 1000)} g</div>
    <div class="s">each time round, and ${fmt(perPass[2].co2 * 1000)} g for each lorry</div></div>
</div>`

{
  const cols = ["Vehicle", "Vehicles a day (2025)", "Energy lost per vehicle (kWh)", "Fuel per vehicle (ml)",
                "CO2 per vehicle (g)", "CO2 a year (tonnes)", "Fuel a year (litres)", "Share of the CO2"];
  return html`<div class="je-table-wrap"><table class="rb-table">
    <thead><tr>${cols.map(c => html`<th>${c}</th>`)}</tr></thead>
    <tbody>${yearly.map(r => html`<tr>
      <td>${r.name}</td><td data-label="${cols[1]}">${fmt(r.daily)}</td><td data-label="${cols[2]}">${fmt(r.lost, 3)}</td>
      <td data-label="${cols[3]}">${fmt(r.litres * 1000)}</td><td data-label="${cols[4]}">${fmt(r.co2 * 1000)}</td>
      <td data-label="${cols[5]}">${fmt(r.co2Year, 1)}</td><td data-label="${cols[6]}">${fmt(r.litresYear)}</td>
      <td data-label="${cols[7]}">${fmt(100 * r.co2Year / (totals.co2Year || 1))}%</td></tr>`)}
      <tr class="rb-total"><td>All traffic</td><td data-label="${cols[1]}">${fmt(totals.daily)}</td><td></td><td></td><td></td>
        <td data-label="${cols[5]}">${fmt(totals.co2Year, 1)}</td><td data-label="${cols[6]}">${fmt(totals.litresYear)}</td><td></td></tr>
    </tbody></table></div>`;
}

“Energy lost” is the kinetic energy turned into heat in the brakes, for an average vehicle of each kind, counting the share that stop. The fuel column is what it takes to put that energy back.

CO2 each year since the roundabout opened

Plot.plot({
  className: "rb-plot",
  width,
  height: 320,
  marginLeft: 50,
  x: {label: null, tickFormat: d => String(d), type: "band"},
  y: {label: "tonnes of CO2", grid: true},
  color: {domain: classes.map(c => c.name), range: classes.map(c => colours[c.key]), legend: true},
  marks: [
    Plot.barY(history, {x: "year", y: "tonnes", fill: "name", order: classes.map(c => c.name), tip: true,
      title: d => `${d.name}, ${d.year}${d.partial ? ` (${fmt(d.days)} days)` : ""}\n${fmt(d.tonnes, 1)} tonnes of CO2`}),
    Plot.ruleY([0])
  ]
})

2018 counts only the four months after the roundabout opened, and this year only the days so far. The dip in 2020 and 2021 is the pandemic. Years after 2025 use the 2025 traffic figures until the DfT publishes newer ones.

How the answer depends on approach speed

speedCurve = d3.range(30, 71, 1).map(s => {
  const total = d3.sum(classes, c => {
    const v = veh[c.key], r = perPass.find(p => p.key === c.key);
    const speed = c.key === "hgv" || c.key === "bus" ? Math.min(s, v.speed) : s;
    const p = stopShare / 100, v1 = speed * mph, v2 = Math.min(v.slow, speed) * mph, v0 = v.speed * mph, vs = Math.min(v.slow, v.speed) * mph;
    const now = (1 - p) * (v0 ** 2 - vs ** 2) + p * v0 ** 2, then = (1 - p) * (v1 ** 2 - v2 ** 2) + p * v1 ** 2;
    return now > 0 ? r.co2 * then / now * latest[c.key] * 365 / 1000 : 0;
  });
  return {speed: s, total};
})
Plot.plot({
  className: "rb-plot",
  width,
  height: 300,
  marginLeft: 50,
  marginBottom: 44,
  x: {label: "Car speed on the A40 approaching the roundabout (mph) →", labelAnchor: "center", labelOffset: 38},
  y: {label: "tonnes of CO2 a year", grid: true},
  marks: [
    Plot.ruleY([0]),
    Plot.line(speedCurve, {x: "speed", y: "total", stroke: "#2f6aa3", strokeWidth: 2.5}),
    Plot.dot(speedCurve.filter(d => d.speed === veh.car.speed), {x: "speed", y: "total", r: 5, fill: "#2f6aa3",
      stroke: "var(--rb-bg)", strokeWidth: 2}),
    Plot.tip(speedCurve, Plot.pointerX({x: "speed", y: "total", title: d => `${d.speed} mph\n${fmt(d.total)} tonnes a year`}))
  ]
})

Kinetic energy rises with the square of speed, so the faster traffic arrives, the more each slowdown wastes. A lower speed limit on the approach would cut the CO2 from the roundabout, though it would add some journey time.

What it leaves out

• Idling. Drivers waiting to join the roundabout burn fuel standing still. A car idling uses roughly a litre an hour, so a few seconds’ wait adds little next to the acceleration.
• The extra distance. Going round a roundabout is a few tens of metres longer than driving straight on.
• Lower speed through the junction. While a vehicle is going slowly it pushes less air out of the way, which saves a little fuel. The share on the brakes above partly allows for this.
• Hybrids. They get back some of their braking energy, like electric cars. They are counted with petrol cars here, so if many drivers on the A40 have hybrids the true figure is a little lower.
• Traffic turning off. The DfT count is for the whole stretch from Minster Lovell to Ducklington. Most of it is through traffic, but a few vehicles turning at the roundabout itself would have slowed for a junction anyway.

Sources

• Traffic: Department for Transport road traffic statistics, count point 6434, A40 from the B4047 to the A415, annual average daily flow, 2018 to 2025. The DfT counted it by hand in 2019 and 2023 and estimated the other years.
• The roundabout: Oxfordshire County Council’s traffic order for “a new roundabout on the A40 dual-carriageway adjacent to Downs Road overbridge”, and the Oxford Times on its opening on 25 August 2018.
• Fuel CO2 and the grid: the UK government’s greenhouse gas conversion factors (petrol and diesel with the average biofuel blend, about 2.08 and 2.51 kg CO2e a litre; grid electricity 0.131 kg CO2e a kWh in the 2026 set).
• Fuel prices: the Department for Energy Security and Net Zero’s weekly road fuel prices, UK averages on 2 November 2026: unleaded petrol 172.8p and diesel 198.6p a litre. Pump prices move week to week, so put in your own.