The Locomotive Routing Problem

Transcription

1 The Locomotive Routing Problem Balachandran Vaidyanathan 1 Department of Industrial and Systems Engineering 303 Weil Hall, University of Florida Gainesville, FL vbala@ufl.edu Ravindra K. Ahuja Department of Industrial and Systems Engineering 303 Weil Hall, University of Florida Gainesville, FL ahuja@ufl.edu James B. Orlin Sloan School of Management Massachusetts Institute of Technology Cambridge, MA jorlin@mit.edu (Revised: August 17th, 2008) 1 Now at FedEx Express, 3680 Hacks Cross Road, Memphis, TN 38125

2 The Locomotive Routing Problem Balachandran Vaidyanathan 2, Ravindra K. Ahuja 3, and James B. Orlin 4 Abstract Given a schedule of trains, the locomotive planning (or scheduling) problem (LPP) is to determine the minimum cost assignment of locomotive types to trains that satisfies a number of business and operational constraints. Once this is done, the railroad has to determine the sequence of trains to which each locomotive is assigned by unit number so that it can be fueled and serviced as necessary. We refer to this problem as the locomotive routing problem (LRP). The LRP is a very large scale combinatorial optimization problem, and the general version that we consider has previously been unstudied and unsolved in the research literature. In this paper, we develop robust optimization methods to solve the LRP. There are two major constraints that need to be satisfied by each locomotive route: (1) locomotive fueling constraints, which require that every unit visits a fueling station at least once for every F miles of travel, and (2) locomotive servicing constraints, which require that every unit visits a service station at least once for every S miles of travel. The output of the LPP is not directly implementable because the LPP does not consider these fueling and servicing constraints. The LRP considers these constraints and its output is therefore implementable. We model the LRP by considering alternative fueling and servicingfriendly train paths (or strings) between servicing stations on the network. We formulate the LRP as an integer programming problem on a suitably constructed space-time network and show that this problem is NP-complete. This integer programming problem has millions of decision variables. We develop a fast aggregation-disaggregation based algorithm to solve the problem within a few minutes of computational time to near-optimality. Finally, we present computational results and extensive case studies of our algorithms on real data provided by a major Class I US railroad. 1. INTRODUCTION Rail transport is an energy-efficient and capital-intensive means of mechanized land transport of people and cargo. Locomotives, which are power units that pull trains, represent one of the biggest capital investments of railroads. Each locomotive unit represents a one-time investment of at least a million dollars, and also incurs periodic fueling and maintenance costs of several thousand dollars a year. A locomotive (or power) plan provides an assignment of locomotives to each train in the schedule, and railroads use these plans as blueprints to manage their operations efficiently. However, locomotive plans that are currently being used at railroads are lacking in several areas. The plans being used do not satisfy many operational constraints and also completely neglect fueling and servicing requirements. This has a negative impact on operations. While a certain amount of adjustment in real-time to account for unplanned events like bad weather is inevitable, poor locomotive plans force dispatchers to make more adjustments than essential. In our research in this paper, we develop methods to create locomotive plans that satisfy all operational constraints (including fueling and servicing constraints) thereby providing a reliable and implementable blueprint for railroad operations. Hence, although railroads still need to make adjustments for real-time disruptions, our research ensures they will not have to make adjustments due to deficiencies in the locomotive plan. 2 Dept. of Industrial and Systems Engineering, University of Florida, Gainesville, FL Now at FedEx Express, 3680 Hacks Cross Road, Memphis, TN Dept. of Industrial and Systems Engineering, University of Florida, Gainesville, FL Sloan School of Management, Massachusetts Institute of Technology, Cambridge, MA

3 The locomotive planning (or scheduling) problem (LPP) is to assign locomotive types to trains in a cyclic train schedule while honoring several operational constraints and minimizing the overall cost of assignment. In the recent literature, Ahuja et al. [2005] and Vaidyanathan et al. [2007], study the locomotive planning problem. Ahuja et al. [2005] formulated the LPP as a mixed-integer programming problem and solved it using techniques from Very Large Scale Neighborhood Search (VLSN), linear programming-based relaxation heuristics, and integer programming. Vaidyanathan et al. [2007] extended this approach on several dimensions by adding new constraints to the planning problem required by railroads and by developing additional formulations necessary to transition solutions of the models to practice. The models for the LPP assigned locomotive types to trains in a weekly repeating train schedule ensuring that every train gets sufficient pulling power, locomotive flows are balanced, and several other operational constraints are satisfied; however, the models did not account for the fueling and servicing feasibility of individual locomotive units. In this paper, we develop methods that address the constraints of the LPP while also routing locomotive units on fueling and servicing friendly routes. The LRP models the routing of each locomotive unit on a cyclic sequence of trains so that it can be fueled and serviced as necessary, while satisfying all other business and operational constraints considered in the LPP. We refer to the sequence of trains on which a locomotive unit travels as its locomotive route. Fueling feasibility requires that each locomotive route has sufficient fueling opportunities to ensure that the locomotive does not run out of fuel (out-of-fuel event). This translates into the constraint that every locomotive needs to have a fueling opportunity at least once for every F miles (e.g., 900 miles) of travel. Similarly, servicing feasibility requires that each locomotive route has sufficient servicing opportunities, and this translates into the constraint that every locomotive needs to have a servicing opportunity at least once for every S miles (e.g., 3,000 miles) of travel. If all the stations in the network supported fueling and servicing, any feasible solution to the LPP would be feasible for the LRP (more precisely, one could take the solution for the LPP, and use flow decomposition as in Ahuja et al [1993] to obtain routes for individual locomotive units). However, typically only 50% of the stations on the train network support fueling and 30% of the stations support servicing. Hence, solutions of the LPP typically cannot be easily transformed into feasible solutions for the LRP. Indeed, to the best of our knowledge, the LRP remains practically unstudied and unsolved, and our paper reports the first attempt to solve this problem. Various locomotive scheduling models have appeared in the literature but none of these studies directly considers the fueling and servicing requirements of locomotives. The paper by Cordeau et al. [1998] presents an excellent survey of existing locomotive planning models and algorithms for the LPP. There are two kinds of locomotive planning models: Single and Multiple. Single locomotive planning models assume that there is only one type of locomotive available for assignment. These models can be formulated as minimum cost flow problems with side constraints. Some papers on single locomotive planning models are due to Wright [1989], Forbes et al. [1991], Booler [1980, 1995], and Fischetti and Toth [1997]. Single locomotive planning models are better suited for some European railroads rather than North American railroads since most North American railroads assign multiple locomotive types to trains. Multiple locomotive planning models have been studied by Florian et al. [1976], Ramani [1981], Smith and Sheffi [1988], Chih et al. [1990], Nou et al. [1997], Cordeau et al. [1998], and Ziarati et al. [1997, 1999]. The most comprehensive and recent multiple locomotive planning models are due to Ahuja et al. [2005] and Vaidyanathan et al. [2007]. The only research that considers maintenance requirements is due to Maroti and Kroon [2005]. They consider the problem of routing locomotive units that require maintenance in the next one to three days and propose a multi-commodity flow model to solve this problem. They do not address fueling issues. Their approach is a posteriori, and tries to satisfy maintenance constraints for locomotive units close to their service thresholds. Our approach integrates locomotive plans with the fueling and servicing requirements. 2

4 The LPP (Ahuja et al. [2005], Vaidyanathan et al. [2007]) is analogous to the well-studied airline fleet assignment problem (Abara [1989], Talluri [1996], and Rexing et al. [2000]). The LRP is analogous to the well-studied aircraft maintenance routing problem (Clarke et al. [1997], Gopalan and Talluri [1998], Barnhart et al. [1998], and Talluri [1998]). Integrating airline fleet assignment and maintenance routing into a single problem makes the problem very hard to solve. Hence, the popular approach adopted in the airline industry is sequential; i.e., the fleet assignment problem is solved first to fix the assignment of aircraft types to flight legs, and the aircraft routing problem is solved next to route individual aircraft units. Several researchers have worked on the aircraft routing problem. Clarke et al. [1997] present a mathematical formulation for the aircraft routing problem and discuss its similarity with the asymmetric traveling salesman problem. Gopalan and Talluri [1998], and Talluri [1998] describe methods to generate aircraft routings that satisfy the four-day maintenance requirement. In another study with a different objective, Feo and Bard [1989] study the maintenance location problem to find the minimum number of maintenance stations required to meet the specified 4-day maintenance requirements for a proposed flight schedule. The only study that considers the integrated fleet assignment and aircraft routing problem is due to Barnhart et al. [1998]. They use a branch-and-price based approach to solve the integrated airline fleet assignment and aircraft routing problem. Their integrated model is quite complex and accordingly, their solution technique is time consuming. They report computation times of three to four hours on relatively small problems (i.e., from the railroad perspective) involving flights. The existing methods for solving the aircraft routing problem are not directly extendible to the LRP. There are several complexities in locomotive routing that are not present in aircraft routing. Three of the added complexities are the following: (a) fueling constraints are needed in rail transportation, but not for air transportation because all airports have fueling capabilities; (b) flight legs on an airline network are assigned to only one aircraft, whereas trains on a railroad network are usually assigned several locomotive units; and (c) aircrafts have more opportunities for repositioning to satisfy servicing constraints (such as moving an aircraft at night if it is idle), and repositioning is less disruptive in the air industry. Even if the approach by Barnhart et al. [1998] were extendible to the LRP, we are addressing much larger problems than their approach could handle. Here we adopt a two-stage decomposition approach to solve the LRP. In the first stage, we solve the LPP, using existing methods, to obtain an assignment of locomotive types to trains (locomotive schedule). In the second stage, we use the methods described in this paper to solve the LRP and route locomotive units on fueling and servicing friendly cyclic routes (locomotive routes). While solving the LRP, we fix the assignment of locomotive types to trains based on the output of the LPP, and we use the flexibility of varying the connections of locomotives between trains (train connections) to achieve fueling and servicing feasibility. We illustrate the importance of train connections through the following example. Consider a locomotive that arrives at a station on train A after traveling 500 miles since its last fueling event. Let this locomotive have the option to connect to either train B or train C. Suppose that train B has a length of 300 miles and terminates at a fueling location, and that train C has a length of 500 miles and also terminates at a fueling location. If the locomotive connects from train A to C, then the total length of travel between fueling opportunities becomes 1,000 miles (> 900 miles) and leads to an out-of-fuel event en route. On the other hand, if the same locomotive connects from train A to B, the total length of travel between fueling opportunities is 800 miles, and the locomotive route is fueling feasible. This example only considers a single connection between two trains; however, fueling and servicing feasibility is usually dependant on more than one connection between a set of trains. We formalize this notion by using the concept of strings (first described in Barnhart et al. [1998]). Strings enable us to account for the fueling and servicing feasibility of locomotive assigned to a sequence of trains. By construction, each locomotive route is made up of a sequence of strings. 3

5 After we fix the assignment of locomotive types to trains, the LRP can be solved as an independent problem for each locomotive type. The LRP can be formulated as a set partitioning problem with side constraints, with a variable for each of an exponential number of strings. A commonly used method to handle the complexity of such a problem relies on the dynamic generation of decision variables using column generation embedded in a branch-and-bound framework. This approach, also called branch-andprice, has found wide application in solving aircraft routing problems and crew scheduling problems. For branch-and-price to be successful: (1) one needs to efficiently generate columns on the fly by solving a sub-problem, and (2) one needs to devise a branching scheme that does not complicate the structure of the sub-problem. While it is possible to efficiently generate fuel-friendly strings or service-friendly stings dynamically, we were unable to find efficient approaches for dynamically generating strings that are simultaneously fuel-friendly and service-friendly. Also, while there are efficient branching schemes for the aircraft routing under the valid assumption that each flight leg is assigned one aircraft, this assumption is invalid for locomotive routing. Accordingly, we did not adopt the branch-and-price approach, and instead choose to explicitly enumerate decision variables (which needs to be carried out once). In order to handle the size and complexity of the problem, we develop an aggregation based two stage algorithm. Our solution approach for the LRP involves the following steps. First, we enumerate alternative fueling and servicing feasible paths (or strings) between service stations in the train network using dynamic programming. Once we enumerate the strings, we formulate an integer program called string decomposition problem (SDP) on a suitably defined space-time network to decompose the locomotive schedule into flows on strings. The output of the SDP can then be assembled into fueling and servicing friendly cycles using the standard polynomial-time cycle decomposition algorithm (see, for example, Ahuja et al. [1993]). However, the SDP is NP-Complete, and our instances have several million decision variables. We develop an aggregation-disaggregation based method to solve this problem efficiently. Our aggregation-disaggregation method involves two steps. In the first step, we formulate and solve a much smaller aggregated SDP which can be solved quickly. In the second step, we disaggregate the solution of the first stage. Finally, we describe necessary side constraints to the LPP that are implied by the fueling and servicing constraints. This paper makes the following major research contributions: We develop a modeling framework and a multi-stage solution approach for the LRP. We formulate the LRP as an integer-programming string decomposition problem (SDP) on a suitably defined space-time network. We also establish that this problem is NP-Complete. We develop efficient dynamic programming algorithms to enumerate strings, which are the decision variables in the SDP. We develop an aggregation-disaggregation based algorithm to solve the SDP to near optimality within a few minutes of computational time in cases in which there are several million decision variables. We present extensive computational results to validate the performance of our approach. We also present case studies of our algorithms on real data provided by a Class I US railroad. We believe that this research will help railroads manage their locomotive resources more efficiently. 2. NOTATION AND TERMINOLOGY Train Schedule: The train schedule (or train network) contains the set of trains that operate in a week. Each train has the following attributes: train ID, departure station, departure time of the week, arrival station, arrival time of the week, and duration. When carrying out locomotive planning, railroads typically 4

6 consider the part of their train schedule that is periodic. We assume that the train schedule repeats periodically on a weekly basis. Henceforth, we refer to trains in the weekly train schedule as weekly trains. Each weekly train is identified by the unique combination of its train ID and day of operation. For example, Train ID TR01, which operates on Monday, Tuesday, and Thursday, corresponds to three weekly trains, TR01-Monday, TR01-Tuesday, and TR01-Thursday. TR01 may also be referred to as a daily train. Locomotive Schedule: The locomotive schedule specifies the assignment of locomotive types to all trains in the week such that all operational constraints, other than the fueling and servicing requirements, are satisfied. These constraints include pulling effort and horsepower constraints for each train, flow balance for each locomotive type, fleet-size constraints, flow upper and lower bounds on each train, and weekly repeatability of locomotive assignments. Decomposed Locomotive Schedule: The locomotive schedule can be decomposed with respect to the different locomotive types in the fleet. The decomposed locomotive schedule that corresponds to a particular locomotive type only considers the trains that carry that locomotive type and also only considers assignments of that particular locomotive type. For example, suppose we consider a schedule with three trains: TR01 with a locomotive assignment of one unit of type A and one unit of type B, TR02 with a locomotive assignment of two units of type A, and TR03 with a locomotive assignment of two units of type B. Then, the decomposed locomotive schedule corresponding to locomotive type A will contain TR01 with an assignment of one unit and TR02 with an assignment of two units; and the decomposed locomotive schedule corresponding to locomotive type B will contain TR01 with an assignment of one unit and TR03 with an assignment of two units. Decomposed Train Schedule: The set of trains in a decomposed locomotive schedule of a particular locomotive type constitutes the decomposed train schedule of that locomotive type. Fueling Station: A fueling station is a station where locomotives can get fueled. Each fueling station has an associated fueling time and fueling cost per gallon of fuel. Servicing Station: A servicing station is a station where locomotives can get serviced. All servicing stations are also fueling stations. Each servicing station has a specific servicing time and servicing cost. Train Connection: This refers to the transfer of locomotives from an inbound train at a particular station to an outbound train at the same station. Minimum Connection Time: This refers to the minimum time required for a locomotive to connect between two trains (it varies from station to station, and includes the fueling and servicing times wherever applicable). String: A string is a connected sequence of trains ; the destination of train is the same as origin of train. Fuel String: A fuel string is a connected sequence of trains such that a locomotive unit traveling on this sequence can be fueled feasibly. Service String: A service string is a connected sequence of trains such that a locomotive traveling on this sequence can be fueled and serviced feasibly. 5

7 3. OVERVIEW OF OUR APPROACH In this section, we present our approach to solve the fueling and servicing-friendly locomotive routing problem in Figure 1. The flowchart presents the various steps in our approach and how these steps relate to each other. In subsequent sections, we elaborate on finer details. Step 1 involves solving the LPP, and Steps 2-4 constitute solving the LRP. Start 1. Solve the Locomotive Planning Problem (LPP) to obtain the locomotive schedule. 2. Enumerate the set of fuel and service strings on the network using the enumeration methods in Section Formulate the String Decomposition Problem (SDP) described in Section 5 and solve it using the aggregationdisaggregation algorithm in Section 6. LRP 4. Decompose the solution of the SDP into fueling and servicing friendly cyclic locomotive routes using a polynomial-time cycle decomposition algorithm (as in Ahuja et al. [1993]) Stop Figure 1. Flowchart of the fuel and service routing algorithm. As stated earlier, the locomotive schedule obtained from the LPP is one of the inputs that go into the LRP. We solve the LPP using the algorithm of Vaidyanathan et al. [2007], which in turn was based on the algorithm of Ahuja et al. [2005]. We then fix the assignment of locomotive types to trains. After the fixing of the assignment of locomotive types to trains, the LRP decomposes into independent problems, one for each locomotive type. Accordingly, in our description of the LRP in Sections 4-7, we consider problems that have only one locomotive type. 6

8 4. FUEL AND SERVICE STRING ENUMERATION ALGORITHMS The objective of the LRP is to route locomotive units in cycles in such a way that each unit has sufficient fueling and servicing opportunities. Consider a unit that travels on one such cycle. This locomotive will visit several stations, some which are servicing stations, some which are fueling stations, and some which are neither. Suppose this cycle is a fueling and servicing friendly cycle. Then, by definition this would imply that the sequence of trains that the locomotive takes between fueling stops is a fuel string and the sequence of trains that the locomotive takes between servicing stops is a service string. This observation is the basis of our approach to solving the LRP. Our approach involves enumerating strings and then decomposing the locomotive schedule into flows on strings. In this section, we develop algorithms to enumerate strings efficiently. In our algorithms for strings enumeration, we do not consider the compatibility of train arrival and departure times when locomotives transfer from one train to the next. Our simplification does not lead to infeasibilities since the train schedule is cyclic. For the same reason it is possible that a train can repeat in a string. But our simplification can result in strings in which there is excessive locomotive idling or waiting time at a station. We handle this by considering the ownership cost of locomotives while solving the string decomposition problem (SDP). The objective function of the SDP ensures that large locomotive waiting will be incurred only when it is profitable. We next define fuel strings and subsequently describe methods to enumerate them. Fuel String A fuel string is a sequence of trains It is connected; i.e., arrival station of = departure station of. that satisfies the following properties: The departure station of and the arrival station of are fueling stations. The length of the string is less than F miles. The string is minimal; i.e., the string does not pass through an intermediate fueling station. No train repeats in the string. These strings are enumerated on a train schedule that is cyclic or repeats each week. Potentially, the same train could appear in a string more than once but we explicitly prevent this from happening. Valid Fuel Sequence and Algorithmic Logic We define a valid fuel sequence as a sequence of trains that satisfies all the properties of a fuel string except that it does not terminate at a fueling station. Thus, a valid fuel sequence can be obtained from any fuel string by deleting the last train(s) from it. Conversely, any fuel string can be represented as a valid fuel sequence plus one last train that terminates at a fueling station. Our dynamic programming algorithm uses these properties to enumerate fuel strings. In the fuel string enumeration algorithm, let P denote the set of fuel strings, V k denote the set of valid fuel sequences containing k trains, Trains denote the set of weekly trains, and length(l) denote the number of miles train l travels. We let FS denote the set of fueling stations, and F the fueling distance threshold. Also, {v+l} represents the concatenation of valid sequence v with train l to create a longer valid sequence. 7

9 algorithm fuel string enumeration; begin ; for each such that origin(l) FS and destination(l) FS, do for each such that origin(l) FS and destination(l) FS, do for k = 2 to Trains do ; for each valid sequence and for each train l such that origin(l) = destination(v) do begin if and if and if length(v) + length(l) F, then else if and if and if length(v) + length(l) < F then end if end end then stop; The number of valid sequences and fuel strings is finite. Hence, FSE terminates in a finite number of steps. We now define service strings and extend the dynamic programming approach to enumerate service strings. Service String Enumeration We define a service string in a similar spirit to fuel strings. Service strings are connected sequences of trains that start and terminate at servicing stations (and do not pass through any other intermediate service station), have a length less than S miles, and cannot contain any train more than once. In addition, every service string also needs to be fueling feasible. Note that since all service stations in the railroad network support fueling, it follows that for the last condition to be satisfied, every service string has to be constructed from one or more connected fuel strings. We define a valid service sequence as a sequence of trains that satisfies all properties of a service string except that it does not terminate at a service station. Therefore, any service string can be represented as a valid service sequence plus one fuel string that terminates at a servicing station. Our dynamic programming algorithm uses this property to enumerate service strings. The algorithm starts with a seed set of trivial valid sequences (fuel strings which originate at servicing stations and do not terminate at servicing stations) and iteratively builds longer sequences from this set. The service string enumeration (SSE) algorithm is similar to the FSE algorithm with the following difference. In FSE, we construct fuel strings using trains as building blocks whereas in the SSE, we construct service strings using the previously enumerated fuel strings as building blocks. In our algorithms for the enumeration of strings, we do not directly consider the connection times of locomotives when they transfer from one train to another. Our simplification does not lead to infeasibilities since the train schedule is cyclic. For the same reason it is possible that a train can repeat in a string. But our simplification can result in schedules in which there is excess locomotive waiting at a train station. We address this by considering the ownership cost of locomotives while solving the string decomposition problem (SDP). Our objective function ensures that large locomotive waiting will be incurred only when it is profitable. 8

10 5. STRING DECOMPOSITION PROBLEM (SDP) In the previous section, we described methods to enumerate service strings which are the decision variables in the SDP. The objective of the SDP is to determine the minimum cost decomposition of a locomotive schedule into flows on service strings. Due to the manner in which service strings are constructed, it follows that a locomotive schedule, when decomposed into flows on service strings, will give fueling and servicing compliant routing of locomotive units. We formulate the SDP as an integerprogramming problem on a suitably defined space-time network. This formulation is analogous to a set partitioning problem with side network flow-balance constraints. We first describe the construction of the space-time network and then the integer programming formulation. We also show that the SDP is NP- Complete using a polynomial-time reduction from the 3-partition problem. Space-Time Network We denote the space-time network by G=(N, A) where N is the set of nodes and A is the set of arcs. For each train arrival at a service station, we create a train-arrival node at that station, and for each train departure from a service station, we create a train-departure node at that station. Once a locomotive arrives at a service station, it needs a minimum connection time before being ready for assignment on the next train. We call the time at which the locomotive is ready for assignment the ready time. For each train-arrival node we assign a time attribute equal to the ready time, and for each train-departure node, we assign a time attribute equal to the departure time of the train. We now describe the construction of arcs on the network. Let S be the set of service strings enumerated using the methods described in the previous section. Let first(s) denote the first train in string s and last(s) denote the last train in string. The space-time network contains a train-departure node that corresponds to first(s) and a train-arrival node that corresponds to last(s). For each string s, we construct an arc between its corresponding nodes and. We denote this subset of arcs as and refer to them as string arcs. We also construct train connection arcs ( ) between all combinations of train arrival and departure nodes at each station to model the various possibilities of inbound locomotives being assigned to outbound trains. The following important property directly follows from the construction of the network. Property 1: A locomotive that travels on a cycle in the network given above can be fueled and serviced feasibly. In Figure 2, we illustrate a part of the space-time network at a particular service station. This station has two incoming trains (two train-arrival nodes), two outgoing trains (two train-departure nodes), four incoming strings, seven outgoing strings, and four train connections. Note that the overall space-time network contains one such component at each service station, and strings link these components to each other. 9

11 Train arrival node Train departure node Figure 2. A part of the space-time network at a particular service station. String Connection arcs Integer Programming Formulation We formulate the SDP as an integer-programming problem on the space-time network. Our objective is to partition the locomotive assignment on each train (locomotive schedule) into flows on the service strings that pass through it, while ensuring locomotive flow balance is conserved at each service station. We use the following notation in the formulation. Trains: Set of weekly trains; indexed by l. if train l is a part of string, 0 otherwise. : Number of locomotives assigned on train l in the locomotive schedule. O: Set of arcs that cross the count-time. The count-time is a reference time at which we count the number of locomotives used (without loss of generality, we set it to Sunday midnight). : Number of times string arc crosses the count-time. : Cost of a locomotive unit assigned on string arc. G: Ownership cost of a locomotive unit. The decision variables are: : Denotes the flow on arc (i, j). If (i, j) is a string arc, we alternatively write the flow on the arc as. 10

12 The integer program is the following: Min (1) (2) (3) (4) Constraint (2) is a set partitioning constraint that ensures that the locomotive assignment on each train is distributed completely on the service strings that pass through it, and Constraint (3) is the flow balance constraint at each node. We assume that the set of strings that can service a particular train are unrelated. A practical concern is that when a number of locomotives are assigned on a train, then uncoupling a locomotive in the center is more expensive and takes more effort than uncoupling an outer locomotive (this is referred to as consist busting); the formulation does not address these costs. In a large sense, we avoid addressing these costs in the LRP model, because they are addressed via the input to the LRP model. In our research on the LPP reported in Vaidyanathan et al. [2007], our primary objective was to minimize consist-busting. There, we showed that by routing intelligently created groups of locomotives (or consists) together instead of individual locomotives, we can obtain a locomotive schedule with highly reduced consist busting. In such a consist-based locomotive schedule, most trains are assigned a single consist while others have two consists. No single consist is ever busted. Even though we describe our locomotive routing algorithms using locomotive types as the commodities, we can (and do) run our algorithms on a consist-based locomotive schedule where consist-types are the commodities. In particular, we create a consist-based locomotive plan in Step 1 of Figure 1, and run our locomotive routing algorithms on this consist-based plan. Since the LPP assigns one consist to most trains in the locomotive schedule, it follows that most trains in the solution of the LRP will be serviced by only one string. We now describe the objective function. The first term of the objective function,, represents the cost of fueling and servicing for the locomotives traveling on strings. Railroads operate in such a way that whenever a locomotive fuels, its tank is topped off. Based on this fact and the fact that average fuel burn rate of each locomotive type is known, the cost of each service string can be computed considering the cost of servicing and fueling at the final station in the string and the costs of fueling at the other fueling stations encountered en-route. The second part of the objective function,, minimizes the total ownership cost of locomotives by accounting for the ownership costs of locomotives traveling on overnight arcs. The optimal solution to the SDP is a circulation. Any circulation can be decomposed into the flow around cycles (see for example, Ahuja et al [1993]). Also, from Property 1, it follows that each of these cycles will be fueling and servicing friendly cycles and hence constitute a solution to the LRP. Theorem 2: The string decomposition problem (SDP) is NP-complete. 11

13 Proof: To show that the SDP is NP-Complete, we carry out a polynomial-time transformation from a variant of 3-partition, which is known to be NP-Hard (see, for example, Garey and Johnson [1979]). Input: Three sets A, B, C of n integers each, where A= {a 1,, a n }, B = {b 1,, b n }, and C = {c 1,, c n }, and there is an integer d. Question: Are there n subsets S 1,, S n such that S j A = S j B = S j C = 1, and such that the sum of the values in each subset is d? We reduce the 3-partition problem to a special case of the SDP as follows. Suppose that there are three fueling stations, labeled 1, 2, and 3. In addition, station 1 is the only service station. There are n trains from station 1 to station 2, where the jth train travels a j miles. There are n trains from station 2 to station 3, where the jth train travels b j miles. There are n trains from station 3 to station 1, where the jth train travels c j miles. The maximum number of miles between servicing is d. Then the feasible strings will consist of triples of trains whose total distance traveled is at most d. Moreover, there will be a feasible solution to the SDP if and only if there is a feasible solution to the 3-partition problem. In the next section, we address the computational complexities involved in solving the SDP and also describe algorithmic approaches to solve this problem in an efficient manner. 6. A TRACTABLE SOLUTION APPROACH: AGGREGATION AND DISAGGREGATION A typical weekly train schedule has around 3,000 trains, and the railroad network has around 100 stations, out of which roughly 50% support fueling and 30% support servicing. For a problem of this size, the number of service strings runs into several millions. We did not find a direct integer programming approach for the SDP to be viable. So, we adopted a heuristic approach based on aggregation and disaggregation. In the first stage, we construct a smaller aggregated problem that can be solved quickly. In the second stage, we disaggregate the solution, and create a solution for the SDP. Aggregated Model The aggregated problem is an approximation of the original problem. There are two major considerations in defining the aggregated problem: (1) which entities in the original problem to aggregate; and (2) how to ensure that the aggregated problem is a good approximation of the original problem. We divide our discussion into two parts. First, we focus on relationship between the feasibility of the aggregated problem and the original problem and, in the process, address the first question. Next, we focus on the goodness of the aggregated model, and address the second question. Consider the weekly train schedule. We consider a set of weekly trains to be day-equivalent if they start at the same station at the same time of day, and end at the same station, and if their durations are the same. The only difference is that they may operate on different days of the week. Our aggregated problem ignores the days of the week. All day-equivalent trains are aggregated together to create a set of aggregated trains. The total flow on each aggregated train represents the total flow on all weekly trains corresponding to it. The locomotive schedule obtained after aggregation is called the aggregated locomotive schedule, and the set of trains in this schedule constitute the aggregated train schedule. We now illustrate aggregation through an example. Suppose daily train TR01 has a weekly frequency of three and operates on Monday, Tuesday, and Thursday (TR01-Monday, TR01-Tuesday, and TR01-Thursday), and suppose each of these day-equivalent weekly trains carries a flow of one locomotive of type A and one of type B. Then in the aggregated locomotive schedule, aggregated train TR01 will be assigned a flow of three units of type A and three units of type B. 12

14 Similar to the enumeration of strings from weekly trains, we can also enumerate strings using the aggregated trains; we call such strings aggregated strings. We can also analogously formulate an aggregated string decomposition model to decompose the aggregated locomotive schedule into flows on aggregated strings (in a similar manner to the SDP). We next summarize the steps to formulate the aggregated string decomposition model: Enumerate the set of aggregated service strings using the aggregated train schedule as input and the SSE algorithm described in Section 4. Construct a space-time network as described in Section 5 using the aggregated strings (instead of strings) and the aggregated train schedule (instead of the train schedule). Formulate the aggregated SDP as described in Section 5 using the aggregated locomotive schedule (instead of the locomotive schedule) and the aggregated strings (instead of strings). The aggregated model is identical in structure to the original model, but is far smaller. The number of feasible strings decreases by several orders of magnitude. To see why, consider an aggregated string made up of aggregated trains A, B, and C. Let each of these trains have a frequency of four. Then, there are 4 x 4 x 4 = 64 different strings possible in the original network using the weekly trains corresponding to A, B, and C (refer to Figure 3). However, the aggregated formulation considers only one aggregate string instead of the 64 strings. Hence, the flow on one aggregated string, in this case, represents the cumulative flow on 64 strings. Using this method of variable aggregation, we are able to reduce the number of variables to several thousand. In addition, there is approximately an 80% reduction in the number of constraints. A-1 B-1 C-1 A A-2 B-2 C-2 B A-3 B-3 C-3 C A-4 B-4 C-4 Figure 3. Illustration of disaggregated strings and corresponding aggregated string. (Note For the sake of clarity, we show only show selected connection arcs) We now state an important theorem related to the aggregated problem. Theorem 3: There exists a feasible solution to the string decomposition problem if and only if there exists a feasible solution to the aggregated string decomposition problem. 13

15 Proof: The only if part is obvious. Any solution to the string decomposition problem induces a solution to the aggregate problem. Now consider a feasible solution F to aggregated string decomposition. We can obtain a feasible solution to string decomposition by distributing the flow on each aggregated string in F on the strings corresponding to it in the original network in such a way that the flow on all weekly trains is partitioned. Since we merely redistribute the flows on the aggregated strings, the total flow entering a station and the total flow leaving a station in both the aggregated solution and the new solution will be the same. Hence, flow balance at each station is also satisfied and the result follows. While the aggregated problem is equivalent to the original problem in terms of feasibility, it does not capture the costs precisely. In particular, the aggregated problem could generate bad solutions in terms of locomotive usage. For example, consider a weekly train A that arrives at a station on Monday at 10:00 AM and another weekly train B that departs from the same station at 11:00 AM on Sunday. The optimal solution of the SDP is not likely to route the same locomotive unit on these two weekly trains because the idling time of that locomotive would be extremely high (six days and one hour). On the other hand, in the aggregated problem, since we do not consider the arrival and departure days of trains (we only consider the arrival and departure times of the day), the connection time between the corresponding aggregated trains will be just one hour and it is likely to be used in the solution. Hence, we find that the aggregated problem, in such cases, may not serve as a good approximation of the original problem In order to improve the aggregated model, we use the estimated connection time for each train connection on the aggregated network. The estimated connection time between daily trains A and B represents the probable connection time if a locomotive connects between a weekly train corresponding to aggregated train A and a weekly train corresponding to aggregated train B (we cannot compute this value exactly unless both A and B have a frequency of one). We represent the estimated connection time of a train connection j by estimated duration of an aggregated string ( and the estimated connection times (. Each string is made up of possibly several train connections. We compute the ) by adding the exact durations of the trains belonging to it ) for the connections that belong to it. We next describe how to use these estimated durations in the objective function of the aggregated model. Consider the objective function of the SDP. The first term,, represents the cost of fueling and servicing for the locomotive traveling on string s. The computation of is a function of the stations encountered en-route the string, the cost of fueling or servicing at these stations, and the length of trains that belong to the string; this logic is hence directly extendible to aggregated strings. The second part of the objective function,, minimizes the total ownership cost of locomotives by counting the number of locomotives traveling on overnight arcs. In the aggregated problem, it is not possible to determine the set of overnight arcs or the number of times an aggregated string crosses the count-time ( ). This is because the arrival and departure days of trains are abstracted in the aggregated problem. In order to counter this problem, we re-write the objective function of the SDP in a different though equivalent form. Instead of minimizing the ownership cost of locomotives on overnight arcs, we minimize the total cost of locomotive-minutes used on all arcs. Let represent the exact duration of a string arc, the exact duration of a connection arc, and G the ownership cost of a locomotive per unit time. The original objective function can be equivalently written as: 14

16 Min (5) This form of the objective function is easily extendible to the aggregated problem by using the estimated durations ( ) in place of the exact durations ( ). Our studies show that using the modified objective function in the aggregated model makes it a much better approximation of the original problem, and produces solution that can be disaggregated to obtain near optimal solutions to the SDP. We now focus on the disaggregation stage. Disaggregation Model The proof of Theorem 3 describes a straightforward method to obtain a feasible string decomposition starting with a solution to the aggregated problem; however, this method typically allocates too many locomotives. The objective of the disaggregation model is to disaggregate while simultaneously minimizing the number of locomotives used (We do not consider the fueling and servicing costs in this stage since these costs remain the same). The disaggregation problem, similar to the aggregated problem, can be solved for each locomotive type independently. The inputs to the disaggregation problem are as follows: Locomotive schedule: This gives the assignment of locomotive types to weekly trains. Solution of the aggregated model: This gives the aggregated strings and their locomotive assignments. The disaggregation model redistributes flow on each aggregated string on the strings corresponding to it in the original network while ensuring that the assignment on each weekly train is covered and the total number of locomotives used is minimized. We formulate the problem as an integral multi-commodity flow problem on a suitably defined network. We consider one commodity for each string with positive flow in the solution of the aggregated problem (however, the disaggregation problem is still solved as an independent problem for each locomotive type). We denote the network as G=(N, A) where N is the set of nodes and A is the set of arcs in the network. We create a train-arrival node corresponding to each train arrival and a train-departure node corresponding to each train departure. We also construct one supply node and one demand node corresponding to each aggregated string with positive flow ( ) and define a commodity corresponding to this string. We set the supply of each commodity at its supply node to (and the supply of all other commodities to zero). Similarly, we set the demand of each commodity at its demand node to (and the demand of all other commodities to zero). We now describe the construction of arcs. For each weekly train, we construct an arc connecting its train-departure node and train-arrival node; we refer to the set of weekly train arcs as Trains. We also construct connection arcs (CoArcs) between train-arrival nodes and train-departure nodes at each station. Let first(s) be the set of weekly trains corresponding to the first aggregated train in aggregated string s, last(s) be the set of weekly trains corresponding to the last aggregated train in aggregated string s, and trains(s) be the set of all weekly trains corresponding to the aggregated trains in s. For each aggregated string s with positive flow ( ), we connect its supply node to the departure nodes of all the trains in first(s), and we connect the arrival nodes of all trains in last(s) to its demand node. The disaggregation 15

17 model can be formulated as a multi-commodity flow problem (MCFP) on the network constructed above. We now introduce the notation. K: Set of commodities indexed by k. We define one commodity for each aggregated string s with positive flow. k(s): The commodity corresponding to aggregated string s. s(k): The aggregated string corresponding to commodity k. : Total locomotive assignment on weekly train in the locomotive schedule. : Supply/demand vector of commodity. : Upper bound on the flow of commodity on arc. : Duration of arc. : Arc adjacency matrix of G=(N,A). The decision variables are: : Flow of commodity on arc. The formulation is: Min (6) (7) (8) (9) The flow balance constraints (Constraints 8) and also setting flow upper bounds for each commodity on train arcs as described above ensures that the flow on each aggregated string is redistributed completely on the strings corresponding to it in the original problem. Also, Constraint (7) ensures that the total flow on each weekly train is partitioned among the service strings that pass through it. Hence, MCFP is a valid formulation for the disaggregation problem. The objective function minimizes the total number of locomotive minutes used. Note that Constraints (7) are the bundling constraints, which link the commodities together and complicate the model. If these constraints were relaxed, then the problem would reduce to K independent minimum cost flow problems. Based on this, we adopt a sequential commodity-bycommodity approach to obtain a feasible solution to the disaggregation problem. We first solve the problem for commodities which correspond to longer strings before those corresponding to shorter strings. The reason we do this is that longer aggregated strings tend to have a greater impact on the cost, and we want to optimize them first. Let k(s) represent the commodity corresponding to aggregated string s. For each aggregated string s, we consider the sub-graph, which contains only 16