Optimization of Snowplow Routes for Real-World Conditions

Abstract

During the winter season, snowplowing has a significant effect on road users as it is critical to winter road maintenance and operations. The main goal of this study is to generate optimal routes for snowplowing trucks for efficient road maintenance. In addition to the conventional problem of reducing travel time and distance, this study also incorporates actual operational constraints, such as minimum maintenance standards and driver safety, to improve the overall efficiency of operations. To achieve the objectives, we first implemented the Chinese Postman Problem (CPP) to create Euler circuits from the initial routes and then identified the shortest paths by applying Dijkstra’s algorithm. Then, the Tabu search algorithm was chosen as a metaheuristic algorithm for the optimization process that finds near-optimal solutions by considering operational constraints for snowplow routes. Unsafe turning conditions and minimum maintenance standards were taken into account in the objective function defined for the optimization process. In simulations, the route obtained by our approach was compared to one with the application of CPP only in terms of travel distance, time, turning conditions, and road maintenance priority.

1. Introduction

In Canada, snowplowing is one of the critical services provided by municipalities since snow accumulation on roads reduces surface traction and increases the chances of slippery conditions, which result in serious safety concerns.

Specifically, a slight delay in the snowplowing schedule can lead to thick sheets of ice that worsen the safety of drivers. In extreme cases, blockage of the storm drains for melting snow and ice may cause transportation to halt. Moreover, traffic flow can be reduced to around 40 percent of the free-flow speed on highways due to heavy snowfall [1], and traffic accidents can increase by up to 75 percent in the worst cases [2].

Optimizing the snowplow route plays a vital role in urban planning and sustainability. Optimizing snow plowing routes can facilitate quick and efficient snow removal operations that can reduce traffic delays, especially during rush hours. It also can contribute to reducing the operational time required to clear snow and to attenuating the risk of vehicles drifting off the road, potentially reducing accidents. Moreover, optimal routing improves the environmental sustainability of municipalities by reducing fuel consumption and carbon footprint.

One of the most promising approaches for improving snowplowing service efficiency and reducing costs is to identify optimal routes for snowplow trucks. However, snowplowing is a complex process due to multiple factors that have a direct impact on formulating such optimal routes. These factors include fuel consumption, unsafe maneuvers, and completion time [3] as operational constraints that need to be minimized in order to optimize snowplow routes.

Methodologically, the snowplow route optimization problem is similar to the Chinese Postman Problem (CPP) where every edge has to be serviced exactly once while minimizing the total distance traveled [3]. For this reason, the CPP can provide a good starting point to the route optimization that can be further refined with the help of an additional approach such as a heuristic algorithm to consider operational constraints. The snowplow route optimization problem is considered a combinatorial optimization problem as it seeks to find an optimal solution from a finite set of objects (i.e., a list of nodes) that generates a path to cover them in the shortest time while satisfying the constraints [4].

To deal with this combinatorial problem, optimization algorithms play an important role in designing efficient and optimal routes for snowplowing [3,5]. Malandraki et al. [6] proposed the idea of Maximum Benefit CPP (MBCPP) for the directed graphs. MBCPP relaxed the constraint required by the conventional CPP method, which transverses each edge at least once. In fact, each edge is associated with a service cost for traversal and a deadhead cost for traversal with no service. The objective of this study is to find a tour starting from a depot location and traversing a selected set of edges. Perrier et al. [7] developed a method of optimization based on the hierarchy of the roads. In the study, the high-priority roads were plowed first followed by the lower priorities, which helps meet the road class (priority) requirements.

Kinable et al. analyzed the performance of three different optimization models: mixed-integer programming, constraint programming, and constructive heuristic procedure. The presented models were designed to consider both plowing and salt-spreading operations [8]. Sullivan et al. proposed an iterative method to deal with the vehicle allocation and ice control system. In this study, a heuristic approach was applied to the clusters in the network for reallocating vehicles to achieve more effective ice and snow control than simply increasing the fleet size [9].

Codur et al. [10] proposed a time-dependent variant of the Hierarchical Chinese Postman Problem (HCCP). Through mixed-integer linear programming, the proposed method minimizes the total travel time while maintaining precedence relationships between edges. The study of Korteweg et al. [11] also presented a method of improving the HCCP by considering the lexicographic criterion which minimizes priority class costs. Ahabchane et al. [12] addressed the issue of road salt spreading during the winter season by presenting a variant of the Slack Induction by String Removals (SISRs) metaheuristic. In this study, an optimization method for the road priority hierarchy was developed by formulating the mixed capacitated general routing problem with demand variation due to traffic or weather conditions.

In the domain of path planning, ref. [13] applied a multi-objective optimization technique to minimize the total distance and collision avoidance where the primary cost and second functions are minimized for path length and collision avoidance, respectively. Most snowplow routing problems, however, focus on reducing travel distance (or fuel consumption) and improving efficiency simultaneously by incorporating operational conditions into one objective function.

Although these studies have addressed some important issues in the snowplow route optimization, complex real-world constraints have not been fully incorporated, and thus a more sophisticated approach is needed to optimize routes while accurately reflecting actual operational conditions. Among the real-world constraints, the Minimum Maintenance Standards (MMS) [14] is the service time that municipalities in Ontario must meet to remove snow according to their defined classes of roadways. Other critical constraints are the number of ways (e.g., one- or two-way street) and turning directions, which can restrict the generation of optimal routes.

Therefore, the goal of this study is to propose an advanced optimal routing strategy for residential snowplowing services while considering various real-world operational constraints that have not been fully considered in the existing studies.

The framework of this study is illustrated in Figure 1. For the initial routing, the CPP [15] and Dijkstra’s algorithm [16] were applied to generate a network topology and the shortest path, respectively. To further optimize the initial routes by considering the actual operational constraints that include the MMS and turning conditions for this study, the modified Tabu search algorithm [17] was used to find near-optimal solutions.

The rest of this paper is organized as follows. Section 2 elaborates data gathering and processing for initial route generation. Section 3 explains the applied methodologies, including the defined objective function, CPP, and Tabu search algorithm. Simulation results are presented in Section 4 along with a comparison between the generated routes. Section 5 provides a summary of findings and recommendations for future work.

2. Data Preparation and Processing

In this section, the steps required for gathering and processing geographic data are outlined, which help generate the initial routes for each truck using the city road network database. The city’s road network was provided as a database file containing the attributes of roads and intersections. However, this database file lacked the longitude and latitude of the intersections, which are the key parameters in calculating turning directions and optimizing routes.

To overcome this problem, OpenStreetMap (OSM) [18] was used. The OSM is an open-source and editable map of the world created by a community of mappers. It provides the longitude and latitude of each intersection and other attributes such as the length of road segments.

The first step in gathering the data is to extract a map of the targeted municipality (Clarington). Such extraction was performed by downloading and filtering out the OSM data in QGIS [19], an open-source GIS software that can support viewing, editing, and analyzing geospatial data.

The entire map of the municipality was downloaded from the OSM database and analyzed in the QGIS environment. Figure 2 shows the QGIS graphical representation of this map, where the dots represent the intersections (nodes), and the lines represent the roads (edges).

The entire map was divided into several sub-areas designated for each truck. This was performed by filtering out individual truck routes based on a comparison of the entire map with the city road network database. Figure 3 illustrates the OSM route for one of the operational trucks and one corresponding to Clarington’s network base. In this case, the whole municipality area was divided into 33 sub-areas for each of the 33 trucks, and a total of 3 depots were located within this area. The single-truck optimization approach was applied for each designated sub-area that was predefined by the city. In addition, the designated areas cover both single and multiple lane routes.

However, the first challenge was to solve the issue of network disconnectivity. Specifically, the road network in the city’s database is not connected at some points as shown in Figure 3b. This causes problems when generating the shortest paths. Therefore, the OSM was chosen to generate routes because it contains a fully connected map as illustrated in Figure 3a. However, the important attributes from the city road network such as roadway class, number of ways (one- or two-way street), etc., were transferred to the OSM routes. Note that extra edges in the OSM map are considered for traveling purposes only (non-serviced arcs). With a complete set of initial data (OSM routes) for each truck, which is a prerequisite to solving the optimal routing problem, shapefiles were generated to apply the optimization algorithm for 33 trucks. However, this paper presents the case of a single truck to elaborate on all the steps in the proposed method. A dataset of 10,359 edges and 6945 nodes was used in the study.

3. Methodology

This section explains a problem definition and the mathematical formulation of our selected algorithms. First, the problem for snowplow route optimization is described using graph theory, followed by the implementation of algorithms to solve it.

3.1. Problem Description and Objective Function

Snowplow route optimization is essentially a classical route inspection problem that can be explained using the graph theory as follows.

Let $G(V,E)$ be a strongly connected multi-graph, where V is a set of nodes, and E is a set of directed edges. $V=\{v_0,v_1\dots ,v_n\}$ and $E=(v_i,v_j):v_i,v_jϵV,i<j$, where $v_i$ and $v_j$ are the starting and ending node IDs of an edge, respectively, and i and j are the iterators for nodes. Their values depend on the number of nodes (length of network) present in the network for the considered service area. These values are greater than 0 and go up to the maximum number of nodes in the network presented. The limits of i and j are defined as $v_0\le i<v_{n-1}$ and $j=i+1$.

The first term in a node set, $v_0$, is referred as the depot location. In this way, each node set carries a depot location as their first node. In graph theory, a multi-graph is a graph that carries parallel edges (multiple edges). Edges and nodes represent road segments and intersections, respectively, in this article. Each edge $e=(v_i,v_j)ϵE$ is associated with the non-negative travel distance $c_{ij}$. The total travel distance of a route is the summation of each edge’s travel distance, $\sum c_{ij}$. The travel time for each road segment is represented as $t_{ij}$. $T_{ij}=\sum t_{ij}$, describing the accumulated time of the road network (route) that sums up each road segment travel time $t_{ij}$.

The priority of road class for each road segment was also included in the problem. Roads in Class 1 have a higher priority than the rest. Often, the priority class of a road is determined by its traffic volume [8]. As a result, highways have a higher class than residential roads due to their higher traffic volume. However, the class of each road segment used in this study was predefined by the city.

To take into account the MMS, we defined an objective function that yields a higher value for servicing higher-class roads first rather than servicing in reverse order. The calculation of objective function values (i.e., fitness values) for these two opposite cases is illustrated in Figure 4, where the number between two nodes represents the travel distance (travel time) between them.

Aside from meeting the MMS requirement, our optimization function can also penalize the unsafe turns such as left-, U-, and sharp right turns that need to be avoided for safety and operational efficiency. The finalized objective function is divided into three parts. Equation (1) reflects the criteria of maximizing the MMS, whereas Equations (2) and (3) minimize the penalty of unsafe turns and total traveling distance, respectively.

$$Max(\sum X_{ij}·T_{i}j)$$

(1)

$$Min(a·\sum L_t+b·\sum U_t+c·\sum S_t)$$

(2)

$$Min(d·\sum c_{ij})$$

(3)

where a, b, c, and d are coefficients, and their values are determined by calculating the average of different types of turns for all the routes. The average of these turns provides a range of the fitness value and hence, the parameters are set to provide a reasonable penalty to stay within the range of the fitness value. $L_t,U_t$, and $S_t$ are the left, U-turn, and sharp right turns, respectively. The term $\sum X_{ij}·T_{ij}$ refers to the ‘value’ illustrated in Figure 4. $T_{ij}$ is the travel time across a road segment. $X_{ij}$ is the class of a road segment. $X_{ij}ϵP$ is denoted by the range of $P=1,\dots ,p$, where p is the road class with the lowest priority, and the roads in Class 1 have a higher priority than the rest. The term $a·\sum L_t+b·\sum U_t+c·\sum S_t$ represents the turning direction constraint, and $\sum c_{ij}$ is the total distance in kilometers.

As another variable considered for the snowplow route optimization, the heading angle of a snowplowing truck can be calculated using the geographical information of longitude and latitude associated with each node and the cosine laws. When a truck reaches an intersection (node), its turning direction can be determined by calculating the angle between this node (i.e., current position of the truck) and the next node to which the truck is going.

$$\mathrm{Turning}\mathrm{Type}=\left\{\begin{array}{ccc}\mathrm{left},& if45\le \alpha \le 155& \\ \mathrm{U},& if155<\alpha \le 205& \\ \mathrm{sharp}\mathrm{right},& if205<\alpha \le 240& \\ \mathrm{right},& if240<\alpha \le 315& \\ \mathrm{straight},& if315<\alpha \le 360or0\le \alpha <45\end{array}\right.$$

(4)

From Figure 5, $VectorA$ represents the vector from Node a to Node b, and $VectorB$ represents the vector from Node b to Node c. Then, cosine laws are used to calculate the resulting angle between the two vectors (i.e., $\alpha$ in a counterclockwise direction) which is defined as the turning angle. For each turn, $\alpha$ is calculated to identify the turning type. In Figure 5, $\alpha 1$, $\alpha 2$, and $\alpha 3$ are the examples shown for left turn, right turn, and straight heading, respectively.

As the next step, the heading angles are categorized into different types of turns, i.e., left-, U-, sharp right-, right-, and straight turns defined based on the angle ranges in Equation (4). A combined result of Equations (1)–(3) determines the fitness value of this study.

3.2. Chinese Postman Problem

After translating the snowplow problem into the language of graph theory and defining the objective function and constraints, the next step is to tackle the Chinese Postman Problem, one of the well-known problems in graph theory.

A truck for snowplowing needs to travel along every edge in a graph while taking the shortest route possible. If a graph is Eulerian, all the nodes are of even degree; if a graph is Eulerian and each edge is traversed exactly once, it becomes a closed Eulerian circuit. A closed Eulerian circuit is the shortest circuit. However, snowplow routing problems are often complex in that some of the edges could be traversed more than once.

Given a connected undirected weighted graph G, the CPP computes a minimum cost-closed path that contains all edges at least once. However, in most cases, the graphs are not Eulerian, so CPP is useful for converting a non-Eulerian to an Eulerian graph. The CPP checks every node in a graph and adds an extra edge (i.e., act of traversing an edge without service) to the odd degree nodes to make them even. The steps of the CPP used in this study are presented in Algorithm 1. Let I be the set of vertices $v_i$ for which the number of incoming arcs exceeds that of outgoing arcs by $s_i$ and J, the set of vertices $v_j$ for which outgoing arcs outnumber incoming arcs by $d_j$. Moreover, let $a_{IJ}$ be the length of the shortest distance path from $v_i$ to $v_j$. The CPP problem can be mathematically formulated as follows:

$$Minimize(\sum _I\sum _J{a}_{IJ}·z_{IJ})$$

(5)

where $v_iϵI$ and $v_jϵJ$.

Subject to

$$\sum _{v_JϵJ}{z}_{IJ}=s_i$$

(6)

$$\sum _{v_iϵI}{z}_{IJ}=d_j$$

(7)

$$z_{IJ}\ge 0$$

(8)

where the optimal $z_{IJ}$ values represent the number of extra times each arc has to be traversed.

Algorithm 1 Chinese Postman Problem—Steps

Input: $Anundirecctedconnectedgraph$$G=(V,E)$      Output: $A\left(CPP\right)tourT=(n_1,e_1,n_2,e_2,\dots ,n_{i+1}=n)$ $Step1:DetermineifGisEulerian$ $Step2:ifGisEulerian,obtainanEuler-tourT$ $Step3:ifGisnotEulerian,findaminimum-costaugmentationofGusing$ $Dijkstr{a}^{’}stoconstructanEulerianmultigraph{G}^{\prime }andletTbeanEulertourof{G}^{\prime }$ $Stop$

The best approach for adding extra edges is to check every odd degree node and find the shortest path between these nodes. If exactly two of the vertices are odd, Dijkstra’s algorithm is used to identify the shortest path between these two nodes. Then, extra edges are added in the circuit to accommodate the shortest path from Dijkstra’s algorithm and make the odd degree nodes even. As a result, the vehicle will have to go around the edges of this path twice and all other edges once. However, if more than two vertices are odd, what is required is to find the shortest paths between the odd degree node pairs. In this way, the odd degree nodes become even, and the minimal extra edges are added to the route.

Figure 6 shows a simple example of converting a non-Eulerian graph to a Eulerian one. Figure 6a presents a non-Eulerian graph, while Figure 6b shows the minimum-weight expansion of the non-Eulerian graph to make it Eulerian. In the figure, every double (red) edge in the graph represents a backtrack. From the assumption that Node 1 is the starting and ending node for the closed tour, a possible solution obtained by applying the CPP algorithm is $T=(1,2,4,5,6,5,7,3,4,3,2,1)$ with a total length of 24 by summing up the length of all traveled edges (i.e., the total distance traveled between nodes).

3.3. Dijkstra’s Algorithm

To find the shortest path between nodes (intersections), Dijkstra’s algorithm was implemented [20]. Dijkstra’s algorithm maintains a set of nodes whose final shortest-path weights from the source (depot location in our case) have already been determined. This algorithm repeatedly selects a node with the minimum shortest path estimate and relaxes all edges, leaving the selected node. Since Dijkstra’s algorithm solves a single-source shortest-path problem on a weighted and directed graph, it corresponds exactly to the snowplowing routing problem described in this study. The pseudocode of Dijkstra’s algorithm is presented below (Algorithm 2).

Algorithm 2 Dijkstra’s Algorithm

Input: $graph,startNode,targetNode$      Output: $path$ for$nodeingraph$do     $node.score:=inf;$     $node.score:=false;$ end for $startNode.score:=0;$ while$True$do     $currentNode:=nodeWithLowestScore\left(graph\right)$     $currentNode.visited=true;$     for $nextNodeincurrentNode.neighbors$ do         if $nextNode.visited==false$ then            $newScore:=calculateScore(currentNode,nextNode);$            if $newScore<nextNode.score$ then                $nextNode.score:=newScore;$                $nextNode.routeToNode:=currentNode;$            end if         end if     end for     if $currentNode==targetNode$ then         $returnbuildPath\left(targetNode\right);$     end if     if $nodeWithLowestScore\left(graph\right).score==inf$ then         $throwNoPathFound;;$     end if end while

3.4. Tabu Search Algorithm

After applying the CPP algorithm, the modified Tabu search algorithm [21] was used to optimize the routes using the objective function and constraints.

This algorithm is a metaheuristic optimization technique for optimizing model parameters. Like other metaheuristics techniques, it starts with an initial solution and proceeds iteratively by searching for immediate neighborhoods. Tabu search differs from local search in that it uses a memory to guide the search process.

One aspect of the memory use concerns a move between two adjacent solutions (also known as neighborhood). In order to avoid cycling or sticking in the local solution, space moves are declared Tabu for a specified number of iterations. In recent years, Tabu search has been applied successfully to many combinatorial optimization problems, especially in routing [21,22]. Algorithm 3 illustrates the pseudocode of the modified Tabu search algorithm applied in our study [21].

The Tabu search algorithm has three main memory structures that include the short-term memory, long-term memory, and the Tabu list [23]. Each factor fulfills its own defined task to reach the optimal solution.

Among them, the short-term memory performs the intensification, which prevents the algorithm from regenerating a previously generated solution. The long-term memory diversifies a solution by performing the exploration process. In addition, it generates a new solution to prevent being stuck in the sub-optimal dead end. The Tabu list keeps a record of previously visited solutions and facilitates the short-term memory to match the current solution with the previous one.

As seen in Algorithm 3, we consider a $currentsolution$ (which is initialized with an input from the CPP algorithm) and compute a set of neighborhood solutions N ($currentSolution$) in each iteration. A neighborhood solution can be obtained through the permutation process with the current solution by swapping node positions (neighborhood).

Algorithm 3 Tabu Search algorithm

Input: $Aninitialsolutionoftruckroutes,maximumiterationnumber,lengthoftabu$      Output: $Thepossibleimprovedtruckroutes$ $Step1:Initialization$ $Set$      Current solution = Initial solution      Current value = Initial value      Best solution = Initial solution      Best value = a large number      Maximum number of iteration = a large number $Step2:Forwardupdatingobjectivefunctionvalue$ for$iterationnumber=1:maximumiterationnumber$do     while $Bestvalue\ge Currentvalue$ do         $Randomlygeneratedifferentneighborhoodsolutionsbasedon$         $thecurrentsolutionusingpermutation$         Permutation Process         $Currentsolution=Bestfoundsolutionnotintabu$         $Currentvalue=objectivefunction\left(currentsolution\right)$         if $Bestvalue\ge CurrentvalueandCurrentsolutionnotintabulist$ then             $Bestsolution=Currentsolution$             $Bestvalue=Currentvalue$             $addcurrentsolutiontotabulist$         end if     end while end for

When going from one solution to a neighborhood solution (move), the aim is to maximize the improvement of the objective function value (move value). Hence, the neighborhood solutions will be considered in decreasing order of their move value, and the non-Tabu neighbor solution with the best move value is chosen as the next current solution [22]. A solution is called Tabu if it has already appeared in the Tabu list. Therefore, the Tabu rule will be ignored if the neighborhood solution is Tabu but better than the current best solution.

The fitness value of each solution is calculated, and the best solution amongst the newly generated solutions is selected for the next iteration of the permutation. During the process, only nodes that are connected to the same edge are changed. In this way, the whole circuit remains connected, and a jump from one node to another disconnected node can be avoided.

Once the best solution is selected among the newly generated neighborhoods, it is verified whether this solution is better than the initial one. If a better solution is found, the permutation process is repeated to find another set of different neighborhoods; otherwise, a different combination of routes is searched through the process of merging and separating 243 edges. In the simulation, the fitness converged after 100 iterations, so this iteration number was set as a stopping criterion.

In Algorithm 3, the length of Tabu refers to the number of solutions stored in the Tabu list in each iteration. After randomly generating 24 different neighborhood solutions, the top five solutions are stored in the Tabu list, and the best solution among the randomly generated solutions is used for the next iteration.

4. Results and Discussion

This section discusses the network topology created using initial routes and analyses results obtained from the CPP algorithm. Then, we discuss the best routes generated from the optimization process by applying the Tabu search and Dijkstra’s algorithms with MMS and turning direction constraints.

4.1. Network Topology Generation

Network topology creation is the process of translating the city network database into IDE (Integrated Development Environment) readable format. This step was achieved using the NetworkX library [24], OSM, and QGIS. A map of Clarington was extracted from the OSM in the QGIS environment. QGIS exports shapefiles that the Networkx library can read and convert into graphs with nodes and edges in Python [25]. The generated graphs were used to implement the developed algorithms.

Figure 7 illustrates a network topology in Python graphing for one of the service trucks. The labeled numbers in the figure nodes indicate their IDs. Note that the attributes in the city road network database were transferred to the network topology during the creation of the graphs using the NetworkX library.

4.2. Results Obtained Using CPP and Dijkstra’s Algorithm

Following the creation of the network topology, Euler circuits for each truck’s route are constructed by applying the CPP algorithm. The CPP algorithm begins by identifying all odd degree nodes in a graph, and then it converts each odd degree node to an even degree node by adding parallel edges (backtracks) to create a Eulerian graph. The workflow of the CPP algorithm is described as follows. CPP first computes all possible pairs of odd degree nodes as shown in Figure 8. Red nodes in the network represent odd degree nodes. Edges with light gray represent possible pairs of odd degree nodes, while black edges are the actual edges of the network.

Second, the shortest path between odd degree nodes is calculated by applying Dijkstra’s algorithm [21,26] in order to minimize the backtracking distance and, therefore, reduce the overall circuit distance (find the shortest path). Note that the distance increases during the creation of a Eulerian circuit, but Dijkstra’s algorithm helps in minimizing it.

The final step in the CPP algorithm is to create a Eulerian circuit by adding backtracks obtained from the second step to the original circuit. Once we have the information about the possible shortest backtracks, the original network is updated by embedding the backtracked edges that are highlighted in blue in Figure 9.

By comparing Figure 8 and Figure 10, we can analyze that each blue (backtracked or in some cases, non-serviced edges) edge is connected to red (odd degree) nodes, which makes every odd degree node an even degree resulting in the overall Eulerian circuit.

4.3. Results of Optimization Algorithm

Optimal routes were obtained through the optimization process with the modified Tabu search algorithm and the assumed values, including the MMS listed in

Table 1. The variables used for the optimization and their assumed values.

Variable	Assumed Value
Truck speed	35 km/h
Service area	Clarington
Number of trucks	1
MMS: applicable time for road class 1	1 h for simulation (original time: 4 h)
MMS: Applicable time for road class 2	2 h for simulation (original time: 6 h)
MMS: Applicable time for road class 3	3 h for simulation (original time: 12 h)
MMS: Applicable time for road class 4	4 h for simulation (original time: 16 h)
MMS: Applicable time for road class 5	5 h for simulation (original time: 24 h)
Number of lanes	Both single and multi-lanes covered

.

For the MMS, roadways should be serviced within the required (designated) time. The original time required by the MMS is shown in the table’s parentheses. However, since only one truck‘s service area was considered for the simulation, each time of the MMS was shortened to obtain reasonable results. For example, the original MMS time for road class is 4 h, but 1 h was assumed for simulation purposes.

Snowplowing trucks generally cover highways and municipal roads. The speed limit of municipal roads is 50 km/h in Clarington. However, the driving speed of trucks drops during snowplowing operations. Consequently, the assumed truck speed for simulations was 35 km/h.

As snowplow trucks are required to service roadways with single lanes and two-way roads, we considered both types of roads. If a road has two lanes (i.e., one for going and the other for coming back), it is presented with two edges covering both directions. For the generation of two lanes in the simulation, the same edge was duplicated, and then the nodes were swapped. For example, if an edge is starting from Node ‘a’ and ending at Node ‘b’, the second lane or the opposite direction lane starts from Node ‘b’ and ends at Node ‘a’. In this manner, all the attributes, such as distance, time, etc., remain the same, but the direction is reversed. The proposed method is also able to travel on non-serviced edges (deadhead travel).

To evaluate the optimization process, it is necessary to calculate the fitness value of the objective function in each iteration for every route. The route with the highest fitness value qualifies for the next iteration. After running the simulation several times, it was observed that the fitness value stayed nearly constant after 10 iterations; hence, for less computational cost, the stopping criteria was set to 10 iterations.

The routes obtained from the CPP method (Route 1) without optimization and the CPP with optimization (Route 2) are compared with respect to several criteria presented in

Table 2. Comparison between routes obtained from simulations.

Routes	Route 1: CPP	Route 2: CPP + Optimization
Fitness	−20	60
Total travel Time	1 h 17 min	1 h 15 min
Total travel distance (km)	63.4	62.9
Left Turns	21	22
U-turns	12	9
Sharp Right Turns	0	0
Number of roads (edges) failing to the MMS	4	3

.

Specifically, Route 1’s sequence was generated from the CPP and Dijkstra’s algorithm, while Route 2’s was with the combination of CPP, Dijkstra, and Tabu search algorithms. The Tabu search algorithm finds near-optimal solutions by swapping neighboring nodes (intersections) in every iteration of the permutation process. In this study, we swapped the nodes that are connected to at least three edges (roads).

The fitness value calculated from the objective function is affected by the MMS value and the number of left-, U-, and sharp right turns. By combining Equations (1)–(3), the objective function is designed such that a higher value of MMS and lower values of three unsafe turns and total distance would provide optimal solutions.

From Table 2, we can note that Route 2 offers a slightly better solution in terms of total travel time and distance than Route 1. Despite having one more left-turn, Route 2 has fewer U-turns and fewer roads that do not meet the MMS than Route 1.

Therefore, Route 2 provides a more economical and safer solution by reducing the travel distance/time and undesirable turns, as well as satisfying the MMS. The higher fitness value of Route 2 is indicative of satisfaction with the above comprehensive aspects (i.e., overall performance) that incorporate both traditional concerns (the shortest travel distance with the fewest backtracks) and actual operational constraints (eliminating unfavorable turning directions and meeting the MMS’s required service time).

Figure 11 compares the route sequences of Route 1 and Route 2. In the figure, edges visited once are illustrated in black, while the ones visited twice (backtracks) are shown in red. Note that this figure is a screenshot of an animation showing the initial routing, and therefore some of the edges (light gray) are not yet traversed. As we can see, there is a sequence difference in that Route 1 attempts to cover the upper part first, while Route 2 begins with the lower part.

In Figure 12, roads (edges) served within the designated service time are labeled one, and those that do not meet this requirement have a label of zero.

In the generated optimal route, a departure node for travel was chosen based on the shortest distance to the depot (i.e., the shortest distance to reach the designated service area).

Figure 13 indicates the locations of the departure node and depot that allow for the shortest distance between them in the considered service area.

5. Conclusions

The main objective of this study is to optimize residential snowplowing routes by considering the real-world operational constraints. For this, an initial network topology for each truck’s service area was generated using GIS data extracted from the OSM in the QGIS environment.

The city network’s attributes were then transferred to the initial network topology. The initial network topology containing the actual attributes was processed in Python by using the NetworkX library that converts the generated shapefiles to the IDE compatible graphing format. Then, the CPP algorithm was first applied to the initial routes for the generation of complete Eulerian circuits for each truck. This was achieved by adding backtracks to every odd degree node. In parallel with the CPP, Dijkstra’s algorithm was adopted to minimize the distance of backtracks by finding the shortest distance between the odd degree node pairs.

The Tabu search algorithm was also implemented to generate optimal routes by changing the immediate neighborhoods. In each iteration of the Tabu search algorithm, the fitness value of every route was calculated. Then, the route with the highest fitness value was chosen to generate further routes in the next iteration.

The objective function defined for the optimization took into account both MMS and turning direction. Namely, by increasing the fitness value, the road class priority for service can be met and the unsafe turning directions can be penalized.

Therefore, the generated optimal solutions represent the routes that ensure the shortest travel distance with the minimum deadheads and satisfy the required operational constraints including the MMS and unpreferred turns.

Due to our study being a simulation-based work, it is necessary to validate the proposed algorithm through field tests as a future extension that consider real-time traffic conditions and on-site weather conditions.

Future work will create new optimal routes by reassigning the existing routes to trucks, considering the workload balance between truck drivers as well as the operational constraints in the optimization process. In addition, the generated routes of the developed algorithms can be compared to those by other improved classical path planning algorithms, which can assist in understanding the advantages and disadvantages of the proposed methods.