Highway Assignment

Volumes

The validation results for the Highway Assignment portion of the model are shown in this section. 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. The traffic model data is taken from segment summary report for the 2019 base year model: WFv920_BY_2019_Summary_SEGID.csv. The results are divided into three sections:

Summary Comparison
Detailed Comparison
Map Comparison

Summary Comparison

The summary comparison shows region and county-wide differences between model and observed for Average Daily Volume and Vehicle-Miles Traveled (VMT) by vehicle type. The values for Box Elder and Weber counties are only the portions within the MPO planning area. Validation was checked comparing the average daily volume at the region and county levels. Figure 1, below, contains an interactive view of model vs observed differences by roadway class and vehicle type.

Code

viewof bSummaryFuncClass = Inputs.select(new Map([['All Roadways','All Roadways'], ['Freeway','Freeway'], ['Principal','Principal'], ['Minor', 'Minor'], ['Collector', 'Collector']]), {value: 'All Roadways', label: "Roadway Class:"})
viewof bSummaryVehType = 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:"})
viewof bSummaryDiffType = Inputs.select(new Map([['Percent Difference','DiffPct'], ['Difference','Diff']]), {value: 'DiffPct', label: "Display:"})

Code

volDiffLongT = transpose(volDiffLong)
vmtDiffLongT = transpose(vmtDiffLong)

volDiffLongT_filtered = volDiffLongT.filter(function(dataL) {
    return bSummaryFuncClass == dataL.funcClass &&
           bSummaryVehType == dataL.vehType &&
           (('vol' + bSummaryDiffType) == dataL.View);
})
vmtDiffLongT_filtered = vmtDiffLongT.filter(function(dataL) {
    return bSummaryFuncClass == dataL.funcClass &&
           bSummaryVehType == dataL.vehType &&
           (('vmt' + bSummaryDiffType) == dataL.View);
})

vvp = transpose(vvpct)
vvpL = transpose(vvpctLong)
vvaL = transpose(vvabsLong)
vvaLR = transpose(vvabsLongR)

Code

import {DivergingBarChart} from "@d3/diverging-bar-chart"

function getXDomainVol(bSummaryDiffType) {
    if (bSummaryDiffType === "Diff") {
        return [max_abs_value_volDiff * -1, max_abs_value_volDiff];
    } else {
        //return [max_abs_value_volDiffPct * -1, max_abs_value_volDiff]; // -100% to 100%
        return [-100, 100]
    }
}

function getXDomainVmt(bSummaryDiffType) {
    if (bSummaryDiffType === "Diff") {
        return [max_abs_value_vmtDiff * -1, max_abs_value_vmtDiff];
    } else {
        //return [max_abs_value_vmtDiffPct * -1, max_abs_value_vmtDiff]; // -100% to 100%
        return [-1,1]
    }
}

Code

chartVolDiff = DivergingBarChart(volDiffLongT_filtered, {
    x: d => d.ViewValue,
    y: d => d.coFips,
    xFormat: bSummaryDiffType === "Diff" ? "+,d" : "+.1%",
    xLabel: "Model vs Observed Differences",
    width: 440,
    xDomain: bSummaryDiffType === "Diff" ? [max_abs_value_volDiff * -1, max_abs_value_volDiff] : [-1, 1], //[max_abs_value_volDiffPct * -1, max_abs_value_volDiffPct],
    yDomain:  ['Region','Box Elder County - WFRC','Weber County - WFRC','Davis County','Salt Lake County','Utah County'],
    colors: d3.schemeRdBu[3]
})

Code

chartVmtDiff = DivergingBarChart(vmtDiffLongT_filtered, {
    x: d => d.ViewValue,
    y: d => d.coFips,
    xFormat: bSummaryDiffType === "Diff" ? "+,d" : "+.1%",
    xLabel: "Model vs Observed Differences",
    width: 440,
    xDomain: bSummaryDiffType === "Diff" ? [max_abs_value_vmtDiff * -1, max_abs_value_vmtDiff] : [-1, 1], //[max_abs_value_vmtDiffPct * -1, max_abs_value_vmtDiffPct],
    yDomain:  ['Region','Box Elder County - WFRC','Weber County - WFRC','Davis County','Salt Lake County','Utah County'],
    colors: d3.schemeRdBu[3]
})

Figure 1: Highway Assignment Summary Comparison

At the region level model volume is 1.7% higher than observed volume. The four more urban counties (Weber, Davis, Salt Lake, and Davis) were all within approximately 5% of observed volumes with Salt Lake County being the closest. Weber and Davis were slightly lower and Utah County was slightly higher. Box Elder County is more rural than the other counties. Box Elder model volumes are about 10% lower than observed. Time did not allow for further calibration of the volumes in Box Elder area to account for the larger differences.

One important observation at the Collector and All Vehicles level is that Utah County shows a much higher difference than the other counties. Upon further investigation of observed Collector volumes in Utah County, many roadway segments had very low volumes compared to what was expected. Utah County is one of the highest growth areas in the region. For this reason, we expect that the observed count data may be underrepresenting actual volumes. We also anticipate observed volumes in Utah County to improve in the near-term. Within the last several years, a large investment in continuous count station in Utah County has been made. The new counters will add additional information to generate observed volumes for all roadway segments.

The largest differences in model vs observed volumes occur in the Medium Truck and Heavy Truck vehicle types. A good amount of time was spent attempting to bring model truck volumes closer to observed. However, due to the limited data sources for truck information, further need to investigate observed truck volumes, and a desire to not over-calibrate the model, further calibration was stopped. Truck modeling remains a future priority for model improvement.

Detailed Comparison

The model vs observed details in this section are presented by volume and Vehicle-Miles Traveled (VMT) through the comparison of model and observed data facility type by region and also by county. Figure 2 allows for the interactive visual comparison of model and observed values for the region and each county for all vehicles, cars, medium trucks, and heavy trucks. 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 red 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 red 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 red 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'], ['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'], ['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 2: Model vs Observed Volume and VMT Comparison

As shown in Figure 2 (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 2 (Region, Medium Trucks) and Figure 2 (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 3 through Figure 5 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 3: Segment-Level Model vs Observed Volume Comparison – All Vehicles

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

Figure 5: 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
    })
  ]
})