Highway Assignment

Volumes

Model volumes and vehicle-miles travel (VMT) were validated against observed data. The observed data for 2019 volumes is taken from the Utah Department of Transportation (UDOT) Average Annual Daily Traffic (AADT) History and associated with their respective model segments. Observed VMT was calculated by multiplying the observed volume by the model segment distances.

Figure 1 shows model and observed values for the region at the all vehicle, medium truck, and heavy truck levels. The comparisons are shown in four different types of charts and tables:

Average Daily Volume by Roadway Class (2a): The daily volume is averaged across all segments within their respective geography and vehicle type.
Total VMT by Roadway Class (2b): For each segment, the daily volume is multiplied by segment distance and then summed across all segments within their respective geography and vehicle type.
Model vs Count Segment Volume (2c): This is a scatter plot of segment daily volume with the x-axis as the observed volume and the y-axis as the model volume. The gray line shows the location of where model and observed volumes are equal. The dashed blue line shows a least-squares linear regression. The further the blue line moved away from the gray line, the further the model is from observed.
Segment Percent Error (2d): This is a scatter plot showing the amount of error (percent difference) between the observed volume and the model volume. The observed volume is the x-axis and the percent error is the y-axis. The gray lines are a bounding box that shows the control target. As volume increases, it is expected that the percent error should decrease.

Code

viewof bCountySelect = Inputs.select(new Map([['Region', 'Region']]), {value: 'All', label: "Geography:"})
//viewof bCountySelect = Inputs.select(new Map([['Region', 'Region'], ['Box Elder County - WFRC',3], ['Weber County - WFRC',57], ['Davis County',11], ['Salt Lake County',35], ['Utah County',49]]), {value: 'All', label: "Geography:"})
viewof bVehType = Inputs.select(new Map([['All Vehicles','All Vehicles'], ['Medium Trucks','Medium Trucks'], ['Heavy Trucks','Heavy Trucks']]), {value: 'All Vehicles', label: "Vehicle Type:"})
//viewof bVehType = Inputs.select(new Map([['All Vehicles','All Vehicles'], ['Passenger Cars', 'Passenger Cars'], ['Medium Trucks','Medium Trucks'], ['Heavy Trucks','Heavy Trucks']]), {value: 'All Vehicles', label: "Vehicle Type:"})

sortOrder = ['Freeway', 'Principal', 'Minor', 'Collector', 'All Roadways'];

volT = transpose(vol)
vmtT = transpose(vmt)
filtered_volData = volT.filter(function(dataL) {
    return bCountySelect == dataL.coFips &&
           bVehType == dataL.vehType;
}).sort((a, b) => sortOrder.indexOf(a.funcClass) - sortOrder.indexOf(b.funcClass));
filtered_vmtData = vmtT.filter(function(dataL){
    return bCountySelect == dataL.coFips &&
           bVehType == dataL.vehType;
}).sort((a, b) => sortOrder.indexOf(a.funcClass) - sortOrder.indexOf(b.funcClass));

volTL = transpose(volLong)
vmtTL = transpose(vmtLong)
filtered_volDataL = volTL.filter(function(dataL) {
    return bCountySelect == dataL.coFips &&
           bVehType == dataL.vehType;
}).sort((a, b) => sortOrder.indexOf(a.funcClass) - sortOrder.indexOf(b.funcClass));
filtered_vmtDataL = vmtTL.filter(function(dataL){
    return bCountySelect == dataL.coFips &&
           bVehType == dataL.vehType;
}).sort((a, b) => sortOrder.indexOf(a.funcClass) - sortOrder.indexOf(b.funcClass));


allvehplotT = transpose(allvehplot)
filtered_allvehplotData = allvehplotT.filter(function(dataL) {
    return bCountySelect == dataL.coFips &&
           bVehType == dataL.vehType;
});

Code

function formatNumber(value, isPercentage=false) {
    if (typeof value === 'undefined') {
        return '';  // or return a default value or message
    }
    
    if (isPercentage) {
        return (Number(value) * 100).toFixed(1) + '%';
    }
    return Number(value.toFixed(0)).toLocaleString();
}

widthsVol = ['100px', '52px', '70px', '70px', '73px', '73px', '63px', '63px']; // Define the widths
widthsVmt = ['100px', '88px', '88px', '88px', '88px'];

Code

html`
<h4>2a. Average Daily Volume by Roadway Class</h4>
<table>
    <thead>
    <tr>
        ${["Roadway Class", "# Segs", "Volume", "Observed", "Difference", "Percent Difference", "RMSE", "Percent RMSE"].map((d, i) => {
            return html`<th style='text-align: ${i === 0 ? "left" : "right"}; padding: 5px; width: ${widthsVol[i]};'>${d}</th>`;
        })}
    </tr>
    </thead>
    <tbody>
        ${filtered_volData.map(row => {
            const isBold = row['funcClass'] === 'All Roadways';
            return html`<tr style='border-bottom: 1px solid lightgrey;'>
                ${["funcClass", "numSegs", "volMod", "volObs", "volDiff", "volDiffPct", "volRmse", "volRmsePct"].map((d, i) => {
                    // Check if the current cell is one of the numeric columns that need formatting
                    let formattedValue;
                    if (i === 5 || i === 7) {
                        formattedValue = formatNumber(row[d], true);  // True for percentage formatting
                    } else if ((i >= 1 && i <= 4) || i==6) {
                        formattedValue = formatNumber(row[d]);
                    } else {
                        formattedValue = row[d];
                    }
                    return html`<td style='text-align: ${i === 0 ? "left" : "right"}; padding: 5px; font-weight: ${isBold ? 'bold' : 'normal'};'>${formattedValue}</td>`;
                })}
            </tr>`;
        })}
    </tbody>
</table>`

Code

keyVol = Legend(bChartVol.scales.color, {title: "Data Source"})

bChartVol = GroupedBarChart(filtered_volDataL, {
    x: d => d.funcClass,
    y: d => d.ViewValue,
    z: d => d.DataSource,
    xDomain: ['Freeway','Principal','Minor','Collector','All Roadways'],
    yLabel: "Average Volume (thousands)",
    zDomain: ['Model','Observed'],
    width: 320,
    height: 175,
    colors: ["#376092", "#77933c"]
})

Code

html`
<h4>2b. Total Daily VMT by Roadway Class</h4>
<table>
    <thead>
    <tr>
        ${["Roadway Class", "Model", "Observed", "Difference", "Percent Difference"].map((d, i) => {
            return html`<th style='text-align: ${i === 0 ? "left" : "right"}; padding: 5px; width: ${widthsVmt[i]};'>${d}</th>`;
        })}
    </tr>
    </thead>
    <tbody>
        ${filtered_vmtData.map(row => {
            const isBold = row['funcClass'] === 'All Roadways';
            return html`<tr style='border-bottom: 1px solid lightgrey;'>
                ${["funcClass", "vmtMod", "vmtObs", "vmtDiff", "vmtDiffPct"].map((d, i) => {
                    // Check if the current cell is one of the numeric columns that need formatting
                    let formattedValue;
                    if (i === 4 || i === 6) {
                        formattedValue = formatNumber(row[d], true);  // True for percentage formatting
                    } else if ((i >= 1 && i <= 3) || i==5) {
                        formattedValue = formatNumber(row[d]);
                    } else {
                        formattedValue = row[d];
                    }
                    return html`<td style='text-align: ${i === 0 ? "left" : "right"}; padding: 5px; font-weight: ${isBold ? 'bold' : 'normal'};'>${formattedValue}</td>`;
                })}
            </tr>`;
        })}
    </tbody>
</table>`

Code

keyVmt = Legend(bChartVmt.scales.color, {title: "Data Source"})

bChartVmt = GroupedBarChart(filtered_vmtDataL, {
    x: d => d.funcClass,
    y: d => d.ViewValue,
    z: d => d.DataSource,
    xDomain: ['Freeway','Principal','Minor','Collector','All Roadways'],
    yLabel: "Total VMT (millions)",
    zDomain: ['Model','Observed'],
    width: 320,
    height: 175,
    colors: ["#376092", "#77933c"]
})

Code

Plot.plot({
  grid: true,
  width: 460,
  height: 300,
  marginRight: 40,
  x: {
    label: "Observed Volume (thousands)",
    domain: [0, maxVal]
  },
  y: {
    label: "Model Volume (thousands)",
    domain: [0, maxVal]
  },
  marks: [
    Plot.dot(filtered_allvehplotData, {
      x: "volObs",
      y: "volMod",
      r: 1,
      fill: "rgb(80, 116, 230)",
      fillOpacity: 0.5,
      stroke: "none"
    }),
    Plot.link([0.6, 0.7, 0.8, 0.9, 1, 1.1, 1.2, 1.3, 1.4], {
      x1: 0,
      y1: 0,
      x2: maxVal,
      y2: (k) => maxVal * k,
      strokeOpacity: (k) => k === 1 ? 1 : 0.2,
      stroke: "gray",
      strokeWidth: (k) => k === 1 ? 2 : 1.5
    }),
    Plot.text([0.6, 0.7, 0.8, 0.9, 1, 1.1, 1.2, 1.3, 1.4], {
      x: maxVal,
      y: (k) => maxVal * k,
      text: ((f) => (k) => k === 1 ? "Equal" : f(k - 1))(d3.format("+.0%")),
      textAnchor: "start",
      dx: 6
    }),
    // New top-aligned labels
    Plot.text([1.4, 1.3, 1.2, 1.1, 1, 0.1, 0.2, 0.3, 0.4], {
      x: (k2) => maxVal * 0.8 * (1-k2),
      y: maxVal,
      text: ((f) => (k2) => k2 === 1 ? "" : f(1-k2))(d3.format("+.0%")), //(k2) => d3.format("+.0%")(1-k2),
      textAnchor: "middle",
      dy: -10, // Adjusts position slightly above the top of the plot
      dx: 392
    }),
    Plot.linearRegressionY(filtered_allvehplotData, {
        x: "volObs",
        y: "volMod",
        stroke: "rgb(80, 116, 230)",
        strokeDasharray: "4 4",  // This creates a dashed line pattern,
        strokeWidth: 2 
    })
  ]
})

Code

Plot.plot({
  grid: true,
  width: 460,
  height: 300,
  marginRight: 40,
  x: {
    label: "Observed Volume (thousands)",
    domain: [0, maxVal]
  },
  y: {
    label: "Percent Error",
    domain: [-2, 2],
    tickFormat: d3.format(".0%")
  },
  marks: [
    Plot.dot(filtered_allvehplotData, {
      x: "volObs",
      y: "volErrorPct",
      r: 1,
      fill: "rgb(80, 116, 230)",
      fillOpacity: 0.5,
      stroke: "none"
    }),
    Plot.ruleY([2], {
      x1: 0,
      x2: 1,
      stroke: "gray",
      strokeWidth: 2
    }),
    Plot.ruleX([1], {
      y1: 1,
      y2: 2,
      stroke: "gray",
      strokeWidth: 2
    }),
    Plot.ruleY([1], {
      x1: 1,
      x2: 2.5,
      stroke: "gray",
      strokeWidth: 2
    }),
    Plot.ruleX([2.5], {
      y1: 0.5,
      y2: 1.0,
      stroke: "gray",
      strokeWidth: 2
    }),
    Plot.ruleY([0.5], {
      x1: 2.5,
      x2: 5,
      stroke: "gray",
      strokeWidth: 2
    }),
    Plot.ruleX([5], {
      y1: 0.25,
      y2: 0.50,
      stroke: "gray",
      strokeWidth: 2
    }),
    Plot.ruleY([0.25], {
      x1: 5,
      x2: 10,
      stroke: "gray",
      strokeWidth: 2
    }),
    Plot.ruleX([10], {
      y1: 0.20,
      y2: 0.25,
      stroke: "gray",
      strokeWidth: 2
    }),
    Plot.ruleY([0.20], {
      x1: 10,
      x2: 25,
      stroke: "gray",
      strokeWidth: 2
    }),
    Plot.ruleX([25], {
      y1: 0.15,
      y2: 0.20,
      stroke: "gray",
      strokeWidth: 2
    }),
    Plot.ruleY([0.15], {
      x1: 25,
      x2: 50,
      stroke: "gray",
      strokeWidth: 2
    }),
    Plot.ruleX([50], {
      y1: 0.10,
      y2: 0.15,
      stroke: "gray",
      strokeWidth: 2
    }),
    Plot.ruleY([0.10], {
      x1: 50,
      x2: 300,
      stroke: "gray",
      strokeWidth: 2
    }),
    Plot.ruleY([-2], {
      x1: 0,
      x2: 1,
      stroke: "gray",
      strokeWidth: 2
    }),
    Plot.ruleX([1], {
      y1: -1,
      y2: -2,
      stroke: "gray",
      strokeWidth: 2
    }),
    Plot.ruleY([-1], {
      x1: 1,
      x2: 2.5,
      stroke: "gray",
      strokeWidth: 2
    }),
    Plot.ruleX([2.5], {
      y1: -0.5,
      y2: -1.0,
      stroke: "gray",
      strokeWidth: 2
    }),
    Plot.ruleY([-0.5], {
      x1: 2.5,
      x2: 5,
      stroke: "gray",
      strokeWidth: 2
    }),
    Plot.ruleX([5], {
      y1: -0.25,
      y2: -0.50,
      stroke: "gray",
      strokeWidth: 2
    }),
    Plot.ruleY([-0.25], {
      x1: 5,
      x2: 10,
      stroke: "gray",
      strokeWidth: 2
    }),
    Plot.ruleX([10], {
      y1: -0.20,
      y2: -0.25,
      stroke: "gray",
      strokeWidth: 2
    }),
    Plot.ruleY([-0.20], {
      x1: 10,
      x2: 25,
      stroke: "gray",
      strokeWidth: 2
    }),
    Plot.ruleX([25], {
      y1: -0.15,
      y2: -0.20,
      stroke: "gray",
      strokeWidth: 2
    }),
    Plot.ruleY([-0.15], {
      x1: 25,
      x2: 50,
      stroke: "gray",
      strokeWidth: 2
    }),
    Plot.ruleX([50], {
      y1: -0.10,
      y2: -0.15,
      stroke: "gray",
      strokeWidth: 2
    }),
    Plot.ruleY([-0.10], {
      x1: 50,
      x2: 300,
      stroke: "gray",
      strokeWidth: 2
    })
  ]
})

Figure 1: Model vs Observed Volume and VMT Comparison

As shown in Figure 1 (Region, All Vehicles), the volume and VMT of all vehicles at the region-wide level closely matches the validation targets. Volume for all roadways is only 1.7% higher than observed and VMT for all roadways is only 1.5% higher than observed.

As shown in Figure 1 (Region, Medium Trucks) and Figure 1 (Region, Heavy Trucks), the model currently overpredicts Medium and Heavy trucks. A good amount of effort was spent attempting to bring model truck volumes closer to observed. However, due to truck data limitations and other model resource considerations, further calibration was stopped. Truck modeling remains a future priority for model improvement.

In addition to the charts, the maps in Figure 2 through Figure 4 shows a comparison of segment level model vs observed volumes by vehicle types. Blue represents model lower than observed and red represents model volume higher than observed.

Figure 2: Segment-Level Model vs Observed Volume Comparison – All Vehicles

Figure 3: Segment-Level Model vs Observed Volume Comparison – Medium Trucks

Figure 4: Segment-Level Model vs Observed Volume Comparison – Heavy Trucks

Looking at the All Vehicles map, the model volumes are lower than observed for by more than 7,500 vehicles per day for the east side of I-215 and by more than 15,000 vehicles per day for I-15 through northern Utah County. Model volumes are higher than observed volumes by more than 15,000 vehicles for I-15 in southern Salt Lake County and for I-15 in Utah County between Springville and Spanish Fork. When looking at these areas by vehicle type, volumes for both Medium Trucks and Heavy Trucks are slightly greater than observed. Overall, the volume differences between model and observed are relatively minor.

The lower arterial model vs observed volumes of Heavy Trucks on 9000 South in Salt Lake County was further investigated. The Heavy Truck observed volume for this roadway seemed much higher than expected for this roadway. The lower volumes are likely due to the observed data and not anything in the model.

Average Travel Time

The model’s average travel time was compared to observed data between (how many) various origin and destination locations throughout the model space. Observed travel times came from the Google API for various times throughout 2019. All observed data was collected on Tuesday through Thursday. Due to a data collection issue, observed average travel times were only available for the WFRC area. Model data came from the final network skims that report travel times between every TAZ by period.

The validation results for average travel time are shown in the following figures. Looking at the EV period and knowing that evening speeds are similar to freeflow, we can deduce that in general the model’s freeflow speeds are about 10% faster than observed. In addition, a pattern exists in the AM, MD, and PM periods where shorter trips (under 20 minutes) have shorter travel times than observed and longer trips (30-60 minutes) have longer travel times than observed. This suggests that the volume-delay function (VDF) curves are slightly too aggressive on higher end facility types (freeways and arterials). Overall, while these charts show an acceptable range of error, improvements to freeflow speeds and to the VDF curves are adjustments we will consider making in future models.

Code

viewof vPeriod = Inputs.select(new Map([['AM','AM'], ['Midday','MD'], ['PM','PM'], ['Evening', 'EV']]), {value: 'AM', label: "Period:"})

timeT = transpose(time)

timeT_filtered = timeT.filter(function(dataTme) {
    return vPeriod == dataTme.Period;
})

Code

calculateSlope = (data, xKey, yKey) => {
  const sumX = d3.sum(data, d => d[xKey]);
  const sumY = d3.sum(data, d => d[yKey]);
  const sumXY = d3.sum(data, d => d[xKey] * d[yKey]);
  const sumX2 = d3.sum(data, d => d[xKey] ** 2);
  
  return sumXY / sumX2;
};

slope = calculateSlope(timeT_filtered, "tmeObs", "tmeMod");

// Step 2: Define the end point for the regression line based on the slope
xMax = 60;
yMax = slope * xMax;

html`<h4>Model vs Observed Times</h4>`

Code

Plot.plot({
  grid: true,
  width: 460,
  height: 300,
  marginRight: 40,
  x: {
    label: "Observed Time (minutes)",
    domain: [0, xMax],
    ticks: 8,
    tickFormat: d3.format(".0f")
  },
  y: {
    label: "Model Time (minutes)",
    domain: [0, xMax]
  },
  marks: [
    Plot.dot(timeT_filtered, {
      x: "tmeObs",
      y: "tmeMod",
      r: 1,
      fill: "rgb(80, 116, 230)",
      fillOpacity: 0.5,
      stroke: "none"
    }),
    Plot.line([{ x: 0, y: 0 }, { x: xMax, y: yMax }], {
      x: "x",
      y: "y",
      stroke: "rgb(80, 116, 230)",
      strokeDasharray: "4 4",
      strokeWidth: 2
    }),
    Plot.line([{ x: 0, y: 0 }, { x: xMax, y: xMax }], {
      x: "x",
      y: "y",
      stroke: "gray",
      strokeWidth: 1,
      strokeDasharray: "2 2"  // optional dashed line style for the x=y line
    })
  ]
})

:::