Scheduling approach for onsite jobs of service providers
 145 Downloads
Abstract
Nowadays the successful operation of a company is unimaginable without fast and reliable communication. As a result, socalled Communication Service Providers play an important role in today’s business life. Their orders have to be carried out promptly and dependably, let them be requests for new installations, modifications, or maintenance tasks. These orders have to be performed at different locations and they often have deadlines or strict starting times. Violating such a timing requirement usually implies penalties. In this paper, scheduling problems arising at a Hungarian service provider are examined. At this company, orders are decomposed into smaller tasks, which can be performed by specially trained personnel. Transportation of these specialists contributes a lot to the costs and to the complexity of their scheduling, as well. The goal is to minimize the overall cost of satisfying all orders within the given time horizon with the available assets of the company. The proposed approach relies on the Sgraph framework, which has been applied to various production scheduling problems in the literature. In addition to an unambiguous and sound Sgraph model of the examined problem, slight modifications of the scheduling algorithms for cost minimization, and new bounding methods have been developed. Several of such bounds have been provided and tested for performance and scalability over a large number of generated examples. The sensitivity of the approach for certain problem features has also been examined.
Keywords
Sgraph Scheduling Time constrained jobs Service provider1 Introduction
Scheduling problems appear almost everywhere from the management of public transportation through CPU time allocation to the chemical production industry. Although these problems share the basic goals of scheduling, i.e. assigning resources and time intervals to tasks, their characteristics have significant differences, and as a result, the applied approaches are very diverse. The specific case of the operation of Communication Service Provider teams has not yet been investigated directly in the literature, however, the problem shows strong similarities with production scheduling and vehicle routing problems (VRP). In the examined problem, specialists of a company are organized into small teams with a car and have to carry out jobs at various locations. The orders may have various timing constraints, such as a deadline or an earliest starting time. Each order consists of several nonpreemptive tasks that have arbitrary dependencies between them and may require the expertise of different teams. The general goal is to minimize the overall cost of a workshift which entails transportation costs, liquidated damages, and operation costs.
It can be said that the examined problem is an integration of batch process scheduling and VRP as both problem classes are special cases of it: If all the orders arose at the same location, the problem would be equivalent to a general batch process scheduling problem. On the other hand, in the special case of singlestage orders, the problem would be a VRP with maximum traveling distance, service time (Juan et al. 2009) and time window constraints. There is a number of published approaches for both batch process scheduling (Hegyháti and Friedler 2010) and VRP (Braekers et al. 2016), that could serve as a basis for solving the problem under investigation. In this paper, the scheduling of Communication Service Provider teams is considered as a generalization of the batch process scheduling problem and addressed with an extended approach from that field.
The VRP formulation, as a generalization of the Traveling Salesman Problem, was introduced by Dantzig and Ramser (1959). The original VRP aim is to generate routes for identical vehicles to fulfill the demands of a set of customers. Each customer must be visited exactly once by one vehicle and each vehicle starts from the depot and arrives back at the depot. From the point of view of the paper, the most important variant of the VRP is the VRP with Time Windows (VRPTW) (Bräysy and Gendreau 2005a, b; Gendreau and Tarantilis 2010), where each customer must be visited in a defined time interval. Because of the NP hard nature of the VRP, most of the stateoftheart methods use heuristics (Reil et al. 2018) or metaheuristics (Harzi and Krichen 2017).
Batch process scheduling gained the interest of both chemical engineers and optimization experts in the 90s and since then the presented approaches have been developed by those groups (Méndez et al. 2006). In its simplest form, the goal in a batch process scheduling problem is to find the best assignment of units to nonpreemptive tasks satisfying dependencies and storage related constraints while minimizing the total production time, i.e., makespan. The effort of researchers in the last few decades had two main directions: developing more and more efficient algorithms for the problem classes already tackled, and to address more and more general, integrated problems. Most of the related papers formulate the problem as a Mixed Integer Linear Programming (MILP) model and apply a general purpose MILP solver such as CPLEX, Gurobi or COINOR to solve them. Although these models are rather flexible to extensions and many of them have low CPU needs, the modeling techniques used to improve solution performance have some flaws. Some of the developed approaches may lead to suboptimal solutions as reported by Shaik and Floudas (2009), or even to schedules containing infeasible crosstransfers as shown by FerrerNadal et al. (2008) and Hegyháti et al. (2009). Another wellresearched technique is the application of directed graph based models and specialized BranchandBound (B&B) algorithms. The Sgraph (Sanmartí et al. 2002) relies on such tools and has been developed with acceleration techniques and generalizations for the last 3 decades. Alternative graphs (D’Ariano et al. 2007) apply a similar mathematical model and branching strategy. The third notable direction in batch process scheduling is based on the state space enumeration of the production facility by either Linear Priced Timed Automata (Schoppmeyer et al. 2012) or Timed Place Petri Nets (Ghaeli et al. 2005).
There are numerous papers in literature focusing on solving transportation problems with various techniques, such as stochastic programming (Larsen et al. 2014), constraint programming (Masoud et al. 2011) or alternative graph representation (Samà et al. 2017). Stochastic programming approaches are used in cases where the precise values of some parameters are not known in advance because of the uncertainty of the traffic (Larsen et al. 2014), or robust solutions are needed for production scheduling problems (Urgo and Váncza 2018). In VRPs, changeover times are usually sequencedependent, which is also frequent in production scheduling. For example, Guinet (1993) proposes a heuristic extension of the Hungarian method to solve a VRP problem, and Ruiz and AndrésRomano (2011) shows a MIP model with dispatching heuristics.
In this paper, an extension and application of the Sgraph framework is presented to solve the scheduling of Communication Service Provider teams, motivated by an ongoing R&D project with a Hungarian service provider. The framework was originally developed to solve makespan minimization problems for batch processes (Sanmartí et al. 2002). Later it was successfully applied to solve largescale industrial problems, as well (Adonyi et al. 2008). Transportation, which is a key element of the investigated problem, has been tackled with the Sgraph framework to solve train scheduling problems (Adonyi et al. 2010), and the scheduling of transporter robots in Automated Wetetch Stations (Hegyháti et al. 2014). Many of the later developments and extensions of the framework provide the basis for the approach applied in this paper. A very important aspect of batch scheduling problems is the storage policy of the process. The Sgraph extensions developed to tackle the socalled Zero Wait (ZW) and Limited Wait (LW) storage policies (Hegyháti et al. 2011) will be crucial in modeling the strict timing constraints of the orders of the service provider.
The proposed approach entails a slight modification of formerly published Sgraph algorithms, a sound Sgraph representation of service provider scheduling problems and several newly developed bounding procedures. The innovative aspect of these developments is to provide an integrated method to tackle both transportation and local scheduling aspects with time windows and complex cost evaluations. The proposed approach can help the planning department of the mentioned company or other companies in the same business to systematically minimize costs, which often inherently maximizes client satisfaction as delay costs can be dominant in the objective.
In Sect. 2, the exact definition of the problem is given, then Sect. 3 provides a brief introduction to the Sgraph framework which is needed as the basis of the proposed approach detailed in Sect. 4. The method was tested on randomgenerated instances, the results are given in Sect. 5. Sections 6 and 7 present the potentials of the proposed approach beyond the presented problem class and summarize the results, respectively. To facilitate readability and the replication of the results, a nomenclature (Appendix 1), a formal summary of the proposed model (Appendix 2) and a pseudocode for the approach (Appendix 3) is provided in the Appendix.
2 Problem definition
The orders of a service provider company are not arbitrary in structure but follow some predefined templates. The set of orders and templates are denoted by \(\mathcal{O}\) and \(\mathcal{T}\), respectively. For each order \(O \in \mathcal{O}\), \(T_O \in \mathcal{T}\) denotes the template for that order. Each template \(T\in \mathcal{T}\) entails a set of uninterruptible tasks, \(\mathcal{I}_T\), and the mandatory dependencies between them: \(D_T\subset \mathcal{I}_T \times \mathcal{I}_T\). If \((I,I')\in D_T\), task \(I'\) can only start to be performed after task I has already been completed.
The orders have to be carried out at various locations. The set of possible locations is denoted by \(\mathcal{L}\), and it always contains the depot, \(L^D\), where cars and specialists reside between shifts. All tasks of an order \(O\in \mathcal{O}\) have to be performed at the same location which is denoted by \(L_O\), where \(L_O\in \mathcal{L}\).
At the current stage of our research it is assumed that specialists have already been assigned to cars. Thus, instead of listing competencies and providing the relations between tasks to competencies, competencies to specialists, and specialists to cars, problem description can be simplified by defining the cars that have a suitable specialist assigned for a given task. Let \(\mathcal{C}\) denote the set of these cars, and \(\mathcal{C}_I\subseteq \mathcal{C}\) denote the cars that have suitable personnel to carry out task I.
As usual, timing constraints provide the core of the problem. None of the cars can start a journey before the start of the shift, denoted by \(t^{shiftstart}\), and similarly, all of the cars must arrive back at the depot (\(L^D\)) by the end of the shift, \(t^{shiftend}\). These constraints are strict, i.e., they cannot be violated in any circumstances.
The time needed for a car to travel from one location to another is given as an input parameter, denoted by \(t^{travel}(L_1,L_2) \; \forall L_1, L_2\in \mathcal{L}\). Note that \(t^{travel}(L_1,L_2)\) may differ from \(t^{travel}(L_2,L_1)\), however, \(t^{travel}(L,L)=0\) for all \(L\in \mathcal{L}\). Besides transportation, other important time consuming activities are the tasks themselves. \(t^{perform}(I)\) denotes the time needed to perform a task that is not dependent on the specialist, thus it does not depend on the car, either.
 ’time window’

Means that the order has to be performed within a time interval. The order cannot start earlier as defined but the finish time can be violated.
 ’deadline’

Means that the order has to be finished before a given time point. This constraint can be violated.
 ’exact start’

Means that the order has to be started at a given time point. This constraint can be violated and a 15min delay is allowed without penalty.

Each order \(O\in \mathcal{O}\) has a \(t^{startafter}(O)\) parameter, which denotes the earliest time when the execution of the first task of the order can be started. This constraint is strict, i.e., it must not be violated by the schedule. If no other value is provided for O, \(t^{shiftstart}\) or 0 can serve as a default.

Each order \(O\in \mathcal{O}\) has a deadline, \(t^{deadline}(O)\), by which all of the tasks of O must be finished. This constraint is soft, i.e., it can be violated, however, tardiness is punished by penalties. If no other value is provided, \(t^{shiftend}\) serves as a default.

There is a subset of orders \(\mathcal{O}^{scheduled}\subseteq \mathcal{O}\), where for each \(O\in \mathcal{O}^{scheduled}\), if the first task starts more than 15 min later than \(t^{startafter}(O)\), penalties must be paid similarly to violating deadlines.
Next to timing, several constraints must be met for operating the cars, as well. A car \(C\in \mathcal{C}\) may not travel a larger distance than its limit denoted by \(d^{max}(C)\). Distance between two locations are given by the \(d^{travel}(L_1,L_2)\) parameter. It is also assumed that the specialists assigned to the same car must stay together, i.e., part of the crew cannot leave for another location and leave a member performing a task behind. Moreover, specialists in the same car cannot perform separate tasks in parallel at the same location.

If a car is used for at least one task during the shift, a fix cost of \(c^{fix}(C)\) must be paid.

For each car, transportation cost must be paid, which is proportional to the distance traveled by that car. The coefficient is denoted by \(c^{travel}(C)\).

Performing task I costs \(c^{perform}(I)\). Note that this cost does not depend on the assigned car, thus, it is just a constant term, not influenced by the scheduling decisions made.

If a deadline or the 15min starting window of a scheduled order is missed, a penalty is paid, which is proportional by the tardiness. The coefficient depends on the order and it is denoted by \(c^{penalty}(O)\).
3 Sgraph framework
The Sgraph framework has been developed by Sanmartí et al. (2002) for production scheduling. The framework has two pillars: the directed graphbased mathematical model and the algorithms that operate on that model. In Sgraphs nodes denote tasks and products and each arc defines a timing constraint between the connected nodes. There are two types of arcs in an Sgraph: recipearcs, which express production related constraints given in the input and schedulearcs, which express the sequencing decisions made by the optimization algorithms. Based on the arcs present in them, two types of Sgraphs have special significance in the solution process: the recipe and the schedulegraph.
A recipegraph belongs to the recipe, which entails the network of tasks to be performed. Figure 1 represents the production sequence of three products where each production consists of three consecutive steps. Nodes p1, p2, and p3 denote the products (productnodes) and nodes t1–t9 denote the tasks (tasknodes). The arcs between the tasknodes represent the production order and the arcs from tasknodes to productnodes denote the completion of the corresponding products. Each arc is a recipearc and denotes a timing constraint between the starting times of the two connected tasks or between the starting time of the task and the completion time of the corresponding product. The weight of these arcs is the processing time of the tasks from which they start.

The sets of units/resources have been replaced by the unit/resource chosen by the algorithm to perform that task.

Some additional arcs expressing the activity order of resources are inserted into the graph.
All these additional arcs are schedulearcs and the way they are inserted into the graph depends on the availability of storage for intermediate materials in the plant.
If there are no storage units available, the arcs must start from the consecutive nodes of the source node in the recipe, shown as Case (a) in Fig. 2. In this case, the weight of each arc is 0. As an example, the same sequencing of e1 is expressed by the 0 weighted schedulearc between tasks t2 and t7 because e1 performs task t1 first then it loads its material into e3 and starts to work on task t7.
However, if there is sufficient storage available, the schedulearc is inserted between the two tasks that have been assigned to the same unit and the weight of the arc is the processing time, as shown as Case (b) in Fig. 2. For example, resource e1 performs task t1 first then it starts to work on task t7, thus a 2 weighted arc is inserted between task t1 and task t7.
As presented so far, the weight of the arcs in the Sgraph framework were scalar numbers which express a lower bound on the timing of the connected nodes. Many industrial applications, however, require timing constraints that are of the ’less or equal’ type. Most commonly, unstable intermediate materials can have a limit on their storage time. To address these types of restrictions, the Sgraph model has been extended with interval weighted recipearcs (Hegyháti et al. 2011). In this extended Sgraph model, if an arc has the weight of \((t^l,t^u)\), then the difference between the timing of the connected nodes should be at least \(t^l\) and at most \(t^u\). These type of arcs can be addressed by the Sgraph algorithms in different ways, among which the most efficient is a combinatorial technique (Hegyháti 2015).
Intervalweighted arcs in the Sgraph framework are called LWarcs to refer to the Limited Wait storage policy of the intermediate materials where they are most often applied. If the lower and upper bound of an arc are of the same value, i.e., the weight of the arc is in the form of (t, t), the arc is often called a ZWarc, again, referring to the ZeroWait storage policy. ZWarcs express a fixed timing difference between the connected nodes, which can often be used in various situations. In this work all LWarcs are ZWarcs. Last but not least, \((t,\infty )\) weighted arcs represent the original lower bound type of arcs of the Sgraph framework and thus they are often called UWarcs (Unlimited Wait arcs).
A very common problem parameter for batch process scheduling is the socalled changeover time, which is the time needed for a unit to change from one task to another. Usually this time is needed to perform some kind of operation on the unit to make it ready for the upcoming task, e.g., cleaning, changing settings. In the literature, changeover times can have different forms. In some cases, the time is unit specific, i.e., the changeover time depends on the assigned units as well, not only the tasks. Changeover time is called sequence dependent if it depends on the order of the two tasks as well.
For later sections, a brief introduction to the formal definitions of the Sgraph is needed. A recipegraph is denoted by \(G(N,A_1,\emptyset )\) where N is the set of nodes and \(A_1\) is the set of recipearcs. N is partitioned into two distinct subsets, \(N^T\) referring to tasknodes, which need to be scheduled, and productnodes, \(N^P\), which do not require any resource assignment. A schedulegraph of recipegraph \(G(N,A_1,\emptyset )\) is denoted by \(G(N,A_1,A_2)\) where \(A_2\) is the set of schedulearcs. Both arc sets contain quadruplets in the form of \((n_1,n_2,t^l,t^u)\), where \(n_1,n_2 \in N\) and \(t^l,t^u \in [0, \infty [\). R denotes the set of resources and \(N_r\) (\(\subseteq N\)) denotes the nodes, which can be performed by resource r (\(\in R\)). Through the solution process set \(N^U\) (\(\subseteq N^T\)) denotes the set of unscheduled tasknodes and M (\(\subseteq N^T\times R\)) denotes the set of assignments made in the form of (n, r) pairs, where \(n\in N_r \setminus N^U\). Obviously, if \((n,r)\in M\), there exists no \(r'\ne r\) such that \((n,r')\in M\) too, and \(\{n \mid \exists r\in R, (n,r)\in M\}=N^T\setminus N^U\), i.e., M can be considered as a function.
The input of the Sgraph optimization algorithm applies a BranchandBound based search to find the optimal schedulegraph to the given scheduling problem. The specific version of the optimization algorithm applied in this paper is given formally in Appendix 3.
4 Modeling the problem with Sgraph
The proposed approach relies on an extension of the Sgraph framework to address all parameters of the problem at hand without the need to make any further assumptions atop those stated in Sect. 2. The core of the extension is a model transformation, i.e., providing a mapping between the input data and the Sgraph model described in Sects. 2 and 3, respectively. This mapping is described in detail in Sect. 4.1 and summarized formally in Appendix 2. To address the costbased objective and the travel distance limits, new bounding and feasibility functions had to be defined, which are described in Sects. 4.2 and 4.3. To solve the problem, there is no need to modify the standard Sgraph algorithm for UISLW storage policy with changeover times. However, for easy understanding, the pseudo code for this algorithm is included in Appendix 3, as this specific version in its entirety has not been presented in the literature before.
4.1 Model transformation
The problem at hand is modeled as a precedential batch scheduling problem. Throughout the whole problem UIS storage policy is considered as the order locations can be left without any specialists. To model the various timing constraints of the problem, UISLWarcs are needed. However, the terms ZWarc and UWarc are used when referring to (t, t) or \((t,\infty )\) weighted UISLWarcs.
4.1.1 Orders
4.1.2 Travel times
4.1.3 Depot
To ensure that \(L_C\) is the first task assigned to C and \(U_C\) is the last one, some additional changes are needed. This rule could easily be enforced by slightly changing the core Sgraph algorithms to adhere to it. However, that is not necessary as this constraint can be expressed by some additional recipearcs, as well.
4.2 Bounding function
The general B&B algorithms of the Sgraph framework were originally developed for makespan minimization. However, for any other objective, if a proper bounding function is provided, the scheduling algorithms will provide an optimal solution.

Processing costs of tasks

Fix costs for cars if they are used

Travel costs of cars

Penalties for lateness for scheduled orders

Penalties for deadline violations
In Sect. 4.2.1, a basic lower bound function is presented which incorporates the costs associated with the decisions already made in a partial schedule. This simple bound can be tightened if a lower bound is given for the costs corresponding to decisions that are not yet made. Section 4.2.2 provides several examples for such procedures. In Sect. 4.2.3 the different options for the bounding function are summarized.
4.2.1 Basic bounding function
The basic bounding procedure summarizes all costs based on decisions already made in previous branching steps. The function starts with initializing the bound variable to zero. Each following block increases its value by the lower bound of a costcomponent so that it will contain the lower bound on the overall cost in the end.
First, the sum of the costs of processing the tasks is added, which will be constant for all schedules. This value does not depend on any decision because all orders have to be performed.
Then the fix costs of those cars are added that already have at least one task assigned to them. These cars will be used in each solution reachable from the current subproblem so their fix costs will increase the total cost.
A lower bound for the travel costs of cars can be easily established by summing the costs for travels that have already been assigned to a car.
The longest path from \(Z\) provides a lower bound on the starting time of each node. Thus, a lower bound on the penalties for starting orders too late can be given by summing the costs caused by the lateness that the partial schedule already ensures.
Similarly, a lower bound on the lateness for deadlines of the orders can be established and used to further increase the bound with the corresponding costs.
After these steps, the returned bound variable contains the sum of the lower bounds for all of the costcomponents, thus, a lower bound on the total cost itself.
4.2.2 Tightening the bound
The bound described in Sect. 4.2.1 only considers direct implications of decisions that have already been made in the partial schedule. This bound can be further tightened by including some additional costs that arise from decisions not yet made, but are certain to be included later in the B&B tree.
Each of the following procedures provide a lower bound on such costs and can be called to further increase the value of the bound variable from Sect. 4.2.1.
Fix costs of cars One way to achieve a tighter bound is to include the fix costs of cars that have not yet been assigned to any task but their usage is inevitable. This is the case, for example, if there is at least one unscheduled task that can only be performed by a single, yet unused car.
Cost of remaining trips The bound can be further tightened by computing a lower bound for the cost of the remaining trips that the cars have to make. Two such different lower bounds are given here.
The first method relies on the minimal costs of entering and leaving a location. These values (\(c^{enter}(l)\), \(c^{leave}(l)\)) calculated at the start of the solution will remain constant:
For every location with unscheduled tasks, the cost of leaving this location can be added. If a car has a task with this location assigned to it most recently, it may be able to perform the remaining tasks there. Otherwise, a car will have to travel there so the cost of entering can be added. The sums of entering and leaving costs are kept separately, as every trip both leaves a location and enters another. Only one of the sums can be included in the bound, preferably the higher.
\(M^L \subseteq M\) is the set of assignments that were last assigned to the cars. It contains up to one taskresource pair for each car.
We can also add the costs of returning to the depot or leaving the last location for each car. Note, that triangle inequality is assumed to hold for \(d^{travel}\).
The second method considers the remaining trips for each car in more detail. The locations that the car must visit are determined by the tasks that can only be performed by the car in question. The lowest possible cost of visiting these locations is the solution of a traveling salesman problem. However, solving an NPhard problem at each bounding step would be inefficient. The minimum spanning tree of the locationdistance graph gives a computationally easy lower bound on the future trips. If distances are asymmetric, the smaller distance can be used for each location pair. Finally, for the locations whose every task can be performed by multiple cars (\(\mathcal{L}^x\)), the first method can be used to get a lower bound for further costs.
4.2.3 Variants for the bounding function

BasicBound is either used or not

AdditionalFixCost is either used or not

For future travel costs, either AdditionalVisitCosts or CarBasedCosts is used, or neither of them.
Bound0 The simplest option is to use only the BasicBound function. This is the fastest approach but it also provides the poorest bound. This option is mostly used as a baseline reference.
Bound1 Another option is to use the sum of the return values of BasicBound, AdditionalFixCosts and AdditionalVisitCosts. This option requires slightly more computation but provides a tighter bound.
Bound2 The third option is to use the sum of the return values of BasicBound, AdditionalFixCosts and CarBasedCosts. The last procedure requires to solve a minimal spanning tree problem, thus it is expected to be the slowest, but it can also provide even tighter bounds.
4.3 Feasibility function
The B&B algorithms of the Sgraph framework perform a feasibility check at each partial schedule. The basic feasibility function of the framework searches for a directed cycle within the graph, which indicates infeasible schedules.
This function is adequate for most of the problems solved by the Sgraph framework so far. However, for the problem at hand, there is a limit on the maximal distance a car can travel a day, \(d^{max}(C)\).
The distance that a car must cover in the current partial problem can be calculated very similarly to its corresponding cost contribution and if it exceeds the given limit for any car, the function must return false:
This feasibility function considers only the trips already assigned to a car. The second bound tightening method calculates a lower bound on the future trips of each car. It is also used to detect a future infeasibility when the lower bound exceeds \(d^{max}(r)\).
4.4 Branching strategies
Two main Sgraph branching strategies have been published to make the assignment and sequencing decisions expressed by schedulearcs. The original algorithm (Sanmartí et al. 2002) selects an equipment unit in each branching step, and different tasks are added to the end of its production sequence in each children node. More recently, a different algorithm has been proposed (Adonyi et al. 2007), where an unassigned, unscheduled task is selected, and in each child node, the task is added to a different position in the production sequence of any suitable units. To highlight this difference in the branching step, the two algorithms had been labeled as equipmentbased and taskbased, respectively. Both branching procedures can have many variants based on the selection method of the pivoting unit or task and the order in which the children are generated.

Unless there is a very defining bottleneck, it outperforms the taskbased strategy in most of the general cases (Adonyi 2008).

More acceleration techniques have been published to further enhance its performance (Holczinger et al. 2002; Adonyi et al. 2008).

Some components of the bounding functions detailed in Sect. 4.2 rely on this strategy.
For the computational tests, unit selection was based on alphabetical order and the B&B tree was explored in a depthfirst fashion.
5 Computational tests
The performance of the proposed approach was tested on several problem instances. The example in Sect. 5.1 illustrates the solution process of a problem, showing the input parameters, the resulting recipegraph and the schedule of the obtained optimal solution. Then Sect. 5.2 presents more results for problem instances that were randomgenerated with different parameter settings.
The tests were run on an Intel Core i5660 3.33 GHz CPU with 4 GB RAM with 3600 s time limit.
5.1 Illustrative example
The example presented below shows how a problem can be represented by an Sgraph. It contains orders with all types of time constraints.
Distance of locations in du
Depot  l1  l2  l3  

Depot  0.0  0.5  1.0  0.5 
l1  0.5  0.0  0.5  1.0 
l2  1.0  0.5  0.0  0.5 
l3  0.5  1.0  0.5  0.0 
Data of cars
Car  \(d^{max}\) [du]  \(c^{travel}\) [cu/du]  \(c^{fix}\) [cu] 

c1  10  150  100 
c2  15  120  120 
Process templates
Template  Task  Time [h]  Cost [cu]  Next tasks  Suitable cars 

t1  i1  0.25  3000  –  c1 
t2  i2  0.35  5000  i3  c1 
i3  0.5  10,000  –  c1  
t3  i4  0.25  1000  i5, i6  c1, c2 
i5  0.5  2000  i7  c1, c2  
i6  0.5  3000  i7  c1, c2  
i7  0.5  4000  –  c2 
Data of orders
Order O  \(L_O\)  \(T_O\)  Constraint  Delay cost [cu/h] 

o1  l1  t1  10:00–12:00  0 
o2  l2  t2  Till 14:00  1 
o3  l2  t2  –  0 
o4  l2  t2  At 14:00  100 
o5  l3  t3  9:00–15:00  100 
o6  l3  t3  Till 15:00  200 
In the example, the working hours start at 8:00 and finish at 16:00, i.e., there are 8 h to perform all orders.
The example was solved with the different bounding methods defined in Sect. 4.2.3. The solution times using Bound0, Bound1 and Bound2 are 181.52 s, 1.10 s and 0.02 s, respectively.
5.2 Parameter analysis
Parameters for problem generation
Parameter  An  Bm  Cwxy  Dz 

params.taskNumber \(\equiv N^T\)  n  15  15  15 
params.orderNumber \(\equiv \mathcal{T}=\mathcal{O}=\mathcal{L}\)  5  m  5  5 
params.carNumber \(\equiv \mathcal{C}\)  2  2  2  z 
params.ordersWithTimeWindow  3  3  w  3 
params.windowBuffer  1.4  1.4  0.5  1.4 
params.ordersWithExactStart \(\equiv \mathcal{O}^{scheduled}\)  3  3  x  3 
params.orderDeadlineMin  10  10  40–30y  40 
10 instances were generated for each parameter setting. In the charts they are sorted by the solution time of the slowest method for more clarity. Because of the high variance among solution times, the values are displayed with a logarithmic scale.
As in most scheduling problems, the number of tasks to be scheduled, is a good measure of the problem size and it relates to the difficulty of solving a problem. Hence, the first set of test instances are scaled on the task number.
In A12, 12 tasks are in each instance. As Fig. 12 shows, this size can be solved in less than 100 s even without using more sophisticated bounding methods. With 14 tasks solution time increased, and in one case the basic method needed 1878 s for finding the optimal solution (Fig. 13). The instances of A16 are complex enough that even Bound1 hit the 1h time limit for 1 instance (Fig. 14). The solution times well illustrate the performance improvements of tightening the bound. Even Bound1 is significantly faster than the basic method. The more complex Bound2 performs even better on most instances suggesting that the benefits of a tighter bound justify the usage of a more computationalheavy subroutine.
In this scheduling problem the tasks are grouped into orders and the timing constraints and location are given for orders. The datasets Bm were used to examine how the number of orders contribute to the complexity. Figure 15 shows the solution times for 3, 5, 7, and 9 orders. The average solution times are the highest for B7. Solution times show a tendency to increase as order number increases, especially for Bound1 method (shown in blue) but with 15 tasks, most orders in B9 are singlestage, which can simplify some scheduling decisions.
The hypothesis behind datasets Cwxy was that the types of timing constraints contribute more to the complexity rather than the number of orders. As they were introduced in Sect. 2, there are 3 types of constraints: time window, exact start and deadline. Parameters w and x represent the number of orders with time window and exact start constraints. y is a binary parameter, denoting whether the orders have deadlines or not. In previous tests, their values were 3–3–1 to get orders with mixed constraints.
The datasets of Cwxy were used to examine solution performance with only 1 type of order constraints. Instead of solution times, which showed a similar difference between the bounding methods as the previous tests, Fig. 16 shows how many instances were solved to optimality under the time limit.
It can be seen that the exact start constraints had the highest contribution to complexity. Note that these constraints do not fix the starting times of orders, they can be started later but with penalty. As the proposed method performed worse on these test cases than others, it poses a future research objective to improve the approach for problems with exact start constraints. For example, a heuristic search could provide good approximate solutions to prune the search tree.
Based on the input parameter analysis, Bound2 has the best performance on most problems. Also, the exact start constraint causes the most difficulties for the approach, therefore, future research is needed to improve performance on this particular type of timing constraint.
6 Comments
The proposed approach was specifically developed for the problem class given in Sect. 2, however, requests for solving the instances of a more general problem class can be expected in the future. Thus, in this section, some perspectives are given on what can be included in the proposed model with no difficulties, which requires major modifications, and how these may influence the efficiency of the approach.
Car specific shifts The specialists, and thus the cars may work in different work shifts. This can easily be addressed by having a direct ZWarc between \(Z\) and the \(L_C\) nodes. If there is no general earliest starting time for the orders themselves, the \(S\) node is removed and direct arcs can be inserted from \(Z\) to the starting nodes of the jobs. Some additional attention is needed to prevent the algorithm from not scheduling the \(L_C\) nodes as first in the sequence of the car, however, after these minor tweaks, the approach can address car specific shifts without any computational disadvantage.
Car specific travel times/distances The cars in the problem may not be uniform, some can travel faster, some must avoid certain roads for various limitations, etc. Modeling such circumstances does not require any further extensions, as the Sgraph framework is already equipped with unitspecific changeover times. Just like in the previous case, this generalization only needs additional input data and has negligible effect on the CPU requirements of the approach.
Strict deadlines At the moment, the only strict deadline for a job is the end of a shift. However, a separate deadline could similarly be added to the graph without any changes in the algorithm.
Parallel tasks at the same location The proposed approach cannot address situations when a job has tasks that could be performed in parallel by distinct subsets of the same team. Since parallel execution of tasks by the same resource is prohibited in the very core of the Sgraph framework, addressing this feature would require a more complex extension of the framework.
7 Summary
In this paper a scheduling problem has been presented where mobile groups of workers have to perform orders in different locations. The orders have various time constraints, some of which can be violated and thus incurring penalties. The Sgraph framework has been extended to handle the special aspects of the problem by introducing a sound construction rule for the Sgraph model and problem classspecific bounding functions. The applicability of the approach was illustrated in detail, and additional tests have been carried out on a large number of randomgenerated examples to examine solution performance of variants of the proposed algorithm on problems with different characteristics.
In the future, the approach can be extended to handle cases where there are not enough resources to perform all orders. Performance can be improved on problems with exact start constraints. The representation and the corresponding algorithm can be modified to take into account multiple days or shifts, i.e., with modifications it can also define the daily work assignments. Other potential extension is to use flexible groups, i.e., the group of workers can be modified before the working hours, therefore, the available cars for tasks can be changed.
The motivating problem of the research, which was solved by the proposed method, came from a service provider company. However, the attributes of the problem, for example the sequencedependent changeover times or the time window constraints also exist in other scheduling problems. With some minor modifications of the method a large class of scheduling problems could be solved, which is a future aim of this research.
Footnotes
 1.
Note that instead of using the set \(\mathcal{I}^{first}_T\), these arcs could be freely inserted to all of the task nodes of an order. The additional arcs would be redundant, and wouldn’t express additional constraints, nor would they improve bounds or have any other effect on the behavior of the approach.
 2.
du, tu, cu refer to distance unit, time unit, and cost unit, respectively.
Notes
Acknowledgements
Open access funding provided by University of Pannonia (PE). We acknowledge the financial support of Széchenyi 2020 under the EFOP3.6.116201600015.
References
 Adonyi R (2008) Batch process scheduling with the extensions of the Sgraph framework. Ph.D. Thesis, University of PannoniaGoogle Scholar
 Adonyi R, Holczinger T, Majozi T, Friedler F (2007) Novel branching procedure for Sgraphs based scheduling of batch processes. In: Proceedings of 19th Polish conference of chemical and process engineering, p 9Google Scholar
 Adonyi R, Biros G, Holczinger T, Friedler F (2008) Effective scheduling of a largescale paint production system. J Clean Prod 16(2):225–232CrossRefGoogle Scholar
 Adonyi R, Heckl I, Szalamin A, Olti F (2010) Routing of railway systems with the Sgraph framework for effective scheduling. Chem Eng Trans 21:913–918Google Scholar
 Braekers K, Ramaekers K, Nieuwenhuyse IV (2016) The vehicle routing problem: State of the art classification and review. Comput Ind Eng 99:300–313CrossRefGoogle Scholar
 Bräysy O, Gendreau M (2005a) Vehicle routing problem with time windows, part I: route construction and local search algorithms. Transp Sci 39(1):104–118CrossRefGoogle Scholar
 Bräysy O, Gendreau M (2005b) Vehicle routing problem with time windows, part II: metaheuristics. Transp Sci 39(1):119–139CrossRefGoogle Scholar
 Dantzig GB, Ramser JH (1959) The truck dispatching problem. Manag Sci 6(1):80–91MathSciNetCrossRefzbMATHGoogle Scholar
 D’Ariano A, Pacciarelli D, Pranzo M (2007) A branch and bound algorithm for scheduling trains in a railway network. Eur J Oper Res 183(2):643–657CrossRefzbMATHGoogle Scholar
 FerrerNadal S, CapónGarcía E, Méndez CA, Puigjaner L (2008) Material transfer operations in batch scheduling. A critical modeling issue. Ind Eng Chem Res 47:7721–7732CrossRefGoogle Scholar
 Gendreau M, Tarantilis CD (2010) Solving largescale vehicle routing problems with time windows: the stateoftheart. Cirrelt, MontrealGoogle Scholar
 Ghaeli M, Bahri PA, Lee P, Gu T (2005) Petrinet based formulation and algorithm for shortterm scheduling of batch plants. Comput Chem Eng 29(2):249–259CrossRefGoogle Scholar
 Guinet A (1993) Scheduling sequencedependent jobs on identical parallel machines to minimize completion time criteria. Int J Prod Res 31(7):1579–1594CrossRefGoogle Scholar
 Harzi M, Krichen S (2017) Variable neighborhood descent for solving the vehicle routing problem with time windows. Electronic notes in discrete mathematics. In: 4th international conference on variable neighborhood search, vol. 58, pp. 175–182Google Scholar
 Hegyháti M (2015) Batch process scheduling: extensions of the Sgraph framework. Ph.D. Thesis, University of PannoniaGoogle Scholar
 Hegyháti M, Friedler F (2010) Overview of industrial batch process scheduling. Chem Eng Trans 21:895–900Google Scholar
 Hegyháti M, Majozi T, Holczinger T, Friedler F (2009) Practical infeasibility of crosstransfer in batch plants with complex recipes: Sgraph vs MILP methods. Chem Eng Sci 64(3):605–610CrossRefGoogle Scholar
 Hegyháti M, Holczinger T, Szoldatics AA, Friedler F (2011) Combinatorial approach to address batch scheduling problems with limited storage time. Chem Eng Trans 25:495–500Google Scholar
 Hegyháti M, Ösz O, Kovács B, Friedler F (2014) Scheduling of automated wetetch stations. Chem Eng Trans 39:433–438Google Scholar
 Holczinger T, Romero J, Puigjaner L, Friedler F (2002) Scheduling of multipurpose batch processes with multiple batches of the products. Hung J Ind Chem 30:263–270Google Scholar
 Juan AA, Adelantado F, Grasman SE, Faulin J, MontoyaTorres JR (2009) Solving the capacitated vehicle routing problem with maximum traveling distance and service time requirements: an approach based on Monte Carlo simulation. In: Winter simulation conference, WSC ’09, pp 2467–2475Google Scholar
 Larsen R, Pranzo M, D’Ariano A, Corman F, Pacciarelli D (2014) Susceptibility of optimal train schedules to stochastic disturbances of process times. Flex Serv Manuf J 26(4):466–489CrossRefGoogle Scholar
 Masoud M, Kozan E, Kent G (2011) A jobshop scheduling approach for optimising sugarcane rail operations. Flex Serv Manuf J 23(2):181–206CrossRefzbMATHGoogle Scholar
 Méndez CA, Cerdá J, Grossmann IE, Harjunkoski I, Fahl M (2006) Stateoftheart review of optimization methods for shortterm scheduling of batch processes. Comput Chem Eng 30(6–7):913–946CrossRefGoogle Scholar
 Reil S, Bortfeldt A, Mönch L (2018) Heuristics for vehicle routing problems with backhauls, time windows, and 3d loading constraints. Eur J Oper Res 266(3):877–894MathSciNetCrossRefzbMATHGoogle Scholar
 Ruiz R, AndrésRomano C (2011) Scheduling unrelated parallel machines with resourceassignable sequencedependent setup times. Int J Adv Manuf Technol 57(5):777–794CrossRefGoogle Scholar
 Samà M, D’Ariano A, D’Ariano P, Pacciarelli D (2017) Scheduling models for optimal aircraft traffic control at busy airports: tardiness, priorities, equity and violations considerations. Omega 67:81–98CrossRefGoogle Scholar
 Sanmartí E, Puigjaner L, Holczinger T, Friedler F (2002) Combinatorial framework for effective scheduling of multipurpose batch plants. AIChE J 48(11):2557–2570CrossRefGoogle Scholar
 Schoppmeyer C, Subbiah S, Engell S (2012) Modeling and solving batch scheduling problems with various storage policies and operational policies using timed automata. In: Karimi IA, Srinivasan R (eds) 11th international symposium on process systems engineering, vol 31, Elsevier, pp 635–639Google Scholar
 Shaik MA, Floudas CA (2009) Novel unified modeling approach for shortterm scheduling. Ind Eng Chem Res 48(6):2947–2964CrossRefGoogle Scholar
 Urgo M, Váncza J (2018) A branchandbound approach for the single machine maximum lateness stochastic scheduling problem to minimize the valueatrisk. Flex Serv Manuf J. https://doi.org/10.1007/s106960189316z Google Scholar
Copyright information
Open AccessThis article is distributed under the terms of the Creative Commons Attribution 4.0 International License (http://creativecommons.org/licenses/by/4.0/), which permits unrestricted use, distribution, and reproduction in any medium, provided you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons license, and indicate if changes were made.