Abstract
This work aims to present a methodology to support a company in the automotive business on scheduling the jobs on its final processes. These processes are: (i) checking the final product and (ii) loading the dispatch trucks. These activities are usually found in the outbound area of any manufacturing company. The problem faced is defined as the flow shop problem with precedence constraints, release dates, and delivery times. The major objective is to minimize the latest date a client receives its products. We present a time-indexed integer mathematical model to compute feasible solutions for the presented problem. Moreover, we take advantage of the Lagrangean Relaxation procedure to compute valid lower and upper bounds. The experiments were held based on the company’s premises. As a conclusion, the results showed that the methodology proposed was able to compute feasible solutions for all the instances tested. Also, the Lagrangean Relaxation approach was able to calculate better bounds in a shorter computational time than the Mathematical problem for the more complicated instances.
1. Introduction
Many companies sort their processes in a sequential way. The sequential standard follows quite well the concept that each process has its suppliers and clients, which may be represented by the previous and the successor processes, respectively.
The problem defined above may be viewed as a flow shop one [1]. In the flow shop approach, each process may be viewed as a single or a set of machines. Each machine is responsible for executing a specific task. Moreover, all the jobs must follow the same order of machines. So, after a job completes a task in a machine, it must join the queue at the next machine. Furthermore, the tasks must be executed under some constraints such as release dates or resources availability. In this work, we approach a real-world problem that may be equivalent to a flow shop problem with precedence constraints, release dates, and delivery times. The company evaluated in this work, focuses its activities on the car-assembling business. We concerned with a part of the company’s processes to carry out the work. To be precise, we focus on the three final processes of the company’s production flow, which are the checking, loading, and dispatching. In addition, we work under a set of premises. As a result, we state the studied problem as the flow shop problem with precedence constraints, release dates, and delivery times with the objective function of minimizing the makespan. That problem is defined as a strongly NP-hard problem [2]. The problem is depicted in Figure 1 and described as follows.
The observed company acts in the automotive business, and it is able to produce up to 2.000 products each day. We highlight that the products are not all the same, because there may exist differences between them. So, after the manufacturing phases, each product is assigned to a cluster. A cluster is represented by the letters A, B, and C in Figure 1. One cluster is set based on the similarities of the products. Also, each cluster must pass a quality control process to avoid sending poor-quality products to the final clients. The control consists of evaluating each product individually. As a result, the operator receives a list of clusters needed to be checked. Then, each cluster is schedule and checked one by one. It is noteworthy to state that the time spent at each cluster may vary according to the type of the products that compound the cluster, and the failures that may be found, as well. Usually, the cluster is compounded by a set of products that do not significantly differ from themselves.
In contrast, some products do differ from themselves, and that is the reason that justifies the clustering procedure. So, the company does not mix different products in the same cluster.
Afterward the checking phase, an established cluster is fragmented. In other words, the products that compound that cluster, are placed in a waiting zone and assorted according to its destinations. Usually, clients receive products that belong to a variety of clusters. So, after a truck’s load has already been completely placed in the waiting area, the dispatching truck is authorized to get inside the marquee. Therefore, a truck is not allowed to get inside before all its cargo have already been placed in the waiting zone. So, we can assume that each outgoing truck has a precedent-jobs list. Then, after the truck arrival, the operators start to load the truck and conclude their task after an amount of time, which may vary according to the truck type, the cargo and the paperwork required. In this work, we assume that there is one team in charge of loading the trucks. As a result, we can not assume that more than one truck is loading at the same time.
Finally, the last process is the Dispatching one. Here the truck departs from the company towards the client’s location. We highlight that we did not consider evaluating which route the truck driver should do, but the average duration to reach the clients’ locations instead.
So, we considered modeling the checking and the loading process as machines. So, the checking process is defined as the Machine 1 () and the loading process as the Machine 2 (). Moreover, we state the main objective is to minimize the maximum date when a client receives its products. As a result, we decided to model this problem as a two-machine flow shop scheduling problem. Therefore, we define this problem as the two-machine flow shop scheduling problem with precedence constraints, release dates and delivery times.
Also, we modeled it through a time-indexed formulation which is based on the discretization of the time horizon. This kind of formulation is known to provide tighter linear relaxation bounds. However, the model presents a high number of variables.
In this work, we face two primary objectives. The first is to present a suitable model to cope with the flow shop problem with precedence constraints, release dates and delivery times. The second goal is to solve the proposed model problem through an appropriated decomposition method. Here, we propose an integer linear programming model on time-indexed variables and a Lagrangean Relaxation (LR) approach to obtain both upper and lower bounds. The sub-gradient method was chosen to carry out the convergence of the LR. See [3].
The paper is organized as follows. The mathematical model section presents the integer linear programming model. The Lagrangean Relaxation section describes the decomposition approach. The Computational Results section reports experiments results. Finally, the Conclusions section concludes the paper.
2. The Mathematical Model
The two-machine flow shop scheduling problem with precedence constraints, release dates and delivery times is set as (). In other words, we aim to solve a scheduling problem, whose target is to minimize the date when the last product will be delivered to the client. Moreover, we deal with a set of constraints related to the company’s machines. These constraints state that the machines are not allowed to work with more than one job at the same time. Also, all those jobs must be executed only once. Besides that, there is a precedence list in order to enable a job to be processed in machine 2. We present the mathematical model of this formulation next.
The notation was set based on [1]. The term F2 means that there are two machines in sequence. The terms () mean that there are three classes of constraints applied, which are: the precedence, the release dates and the delivery times ones, respectively. Finally, the term refers to the objective function of minimizing the latest date a client receives its products. Moreover, the () can be described as follows. Consider a set of jobs to be processed on the first machine , which correspond to the clusters to be processed at the first machine. Likewise, consider a set of jobs to be processed on the second machine , which correspond to outgoing trucks to be loaded at the loading process. The processing time of a job j at a machine is denoted by , which corresponds to the time for processing a cluster at the . The precedence constraints applied imply that to each job (truck) is associated a nonempty set such that j can only be processed in M2 after all clusters belonging to have been processed in . Furthermore, we consider the delivery time for each job . It corresponds to the time required to deliver the job to its final client. The delivery time data refers to the time spent on the road. As a reference, the reader may consider that the delivery time is related to the time spent from Spain to another European country and those in North Africa.
So, the problem consists of finding a sequence of clusters in to be processed in and a sequence of the jobs in to be processed in to minimize the maximum date when a client receives its job. In other words, we aim to minimize , which is equivalent to the latest time that one client receives its products.
To this aim, we propose a time-indexed model, which is based on a time-discretization of the planning horizon into a set of periods. Time-indexed formulations have been shown in the literature to be likely to provide better LP-relaxation bounds than other formulations for scheduling problems, see [4–6]. Continuing, we define two binary variables: (resp. ) assumes value 1 if a job (resp. ) starts its processing in (resp. ) in period , and 0 otherwise. Also, the integer variable , which is the maximum time when the last client receives its products. The integer linear programming (ILP) formulation proposed for that version of the () is presented as follows:
The objective function (1) minimizes the time of reception of the last job, which is equivalent to the biggest value possible of () . Constraints (2) (resp. (3)) state that each job (resp. ) has to be started exactly once at (resp. ). In other words, one job must not be processed more than once by either the machines. The precedence constraints (4) ensure that a job cannot be processed at M2 before all jobs in have been completed at M1. Further explanation could be found in Figure 2. Constraints (5) (resp. (6)) state that machine (resp. ) can handle at most one job at any time period. Consequently, the and are not able to process more than one job at the same time. The value is established by the constraints (7). As a result, the period a final product the client is bigger or equal to the sum of its processing time in , the delivery time () from the manufacturer up to the client, and the period when it has been started to be processed in . Lastly, constraints (8)–(10) define the domain of the variables.
3. The Lagrangean Relaxation
The approach proposed to obtain lower and upper bounds for the () is based on applying a Lagrangean Relaxation (LR) procedure to the previous ILP model. The precedence constraints (4) that couple the scheduling on machines and are relaxed in the LR approach. Figure 2 illustrates a scheduling which is not feasible to constraints (4). In this example, job 1 () processed by begins its processing at , so, , and job 2 () processed by begins its processing at , so, . Considering as the predecessors of job 1 () processed by , it can only start its processing at . However, in this example, begins its processing at , , and not at as expected, violating the precedence constraints.
Let , , , be the Lagrangean multipliers associated with constraints (4). The La- grangean multipliers are equivalent to the dual variables associated with each relaxed constraint placed in the objective function, see [3]. If a job is scheduled in before one of its predecessor has been completed, the objective function will be penalised in the Lagrangean subproblem as follows:
s.t. (2), (3), (5)–(10).We use the subgradient algorithm to solve the Lagrangean dual . The resulting model allows us to decompose the Lagrangean subproblem into one smaller subproblem in .
First, the subproblem is the total weighted completion time scheduling problem on one machine. The completion of a job is weighted by the sum of penalties applied on all jobs to be scheduled on which have among their predecessors. Setting , subproblem is written as follows:
s.t. (2), (5), and (7). Subproblem can be solved by the weighted shortest processing time first rule, in which jobs are sorted in decreasing order of . The proof is stated in [1]. So, we can infer an UB based on the jobs sequenced on the . It will allow us to calculate the release dates of the jobs on the . We will discuss the UB next.
In order to obtain a valid UB, let , , , be an optimal solution of subproblem for a given value of the Lagrangean multipliers. On the one hand, a schedule on such that the starting time of each job satisfies is feasible and provides an upper bound for the () problem. On the other hand, the total weighted completion time scheduling problem on one machine with release dates is NP-Hard [7]. Thus, we propose a Lagrangean heuristic that consists of solving, for a given value of the Lagrangean multipliers, subproblem in , and then applying the approximation algorithm proposed by Philipps et al. [8] to the resulting problem with release dates in .
In the first step, the algorithm allows preemption to get an optimal schedule with the remaining weighted shortest processing time first rule. In the second step, jobs are nonpreemptively scheduled in the same order of their completion times. The algorithm produces, in time, a nonpreemptive schedule increasing the total weighted completion time by at most a factor of 2 to a preemptive schedule.
Then, to complement the subgradient algorithm, we need to calculate a valid Lower Bound (LB) value. To do so, we aim to obtain the biggest possible LB value at each iteration of the subgradient algorithm. In this problem, a LB value may correspond to a relaxation of one of the constraints. In this sense, the constraints selected to be relaxed were the (6) ones. These constraints regard to the availability of the . In other words, it means that two or more jobs cannot be processed at the same time by the . Afterward, we need to compute a valid value of the . The can be evaluated as the biggest term of . It is computed following a rule we introduce next.
In order to calculate the date a client will receive its products, we need first to assign a minimum release date value for each job , which is defined as . Then, we add to that value the respective processing time in the (). Next, we sum the delivery time required to deliver the products into the client’s location (). Afterward, we sort the computed values in decreasing order. As a result, we assign the biggest value found, to the variable. Therefore, the reader may notice that it is equivalent to the relaxation of the constraints (6). In this sense, the value computed is a valid LB. The Figures 3 and 4 depict examples of valid UB and LB solutions, respectively.
Therefore, we did not use the complete formulation of the subproblem (equation (11)) to execute the LR. We did not take into account the whole objective function of the Lagrangean dual to obtain the bounds. Instead, we considered the sequence calculated on M1. We took advantage of the LR and the subgradient method structures to obtain valid UB values, as explained before. Moreover, the LB values were computed following a greedy rule based on the three components: (i) the minimum release date regarding each job , (ii) the processing time in the M2, and (iii) the delivery time. Afterward, both UB and LB values were introduced to the subgradient algorithm to pursue its convergence. In this sense, we may refer to our approach as an adaptation of the LR method. The Figure 5 illustrates the conditions to the method that achieves the optimality.
(a)
(b)
As a result, the Langrangean Relaxation achieves an optimal solution whenever the computed UB and the LB values are the same. Consequently, it requires that both bounds converge to an equal value to obtain the optimal solution.
4. Computational Results
We report computational results on random instances, which are described as follows. The instances are divided into two groups: (i) short processing time jobs, and (ii) long processing time jobs. In the first (resp. second) group processing times are drawn from the uniform distribution between 1 and 10 (resp. 10 and 100). The number n of jobs in is set to 5, 10, 20, 40, and 60, and the number of jobs in is set to 0.6n, 0.8n, n, 1.2n, and 1.4n.
The set of predecessors of a job is a random subset of with cardinality drawn from the uniform distribution between 1 and . In the Tables 1, 2, and 3, an instance is identified by , where np is the maximum number of predecessors a job in can have and is the group. Regarding the delivery times, the delivery time will be calculated in terms of the uniform distribution between 100 up to 1000 and from 1000 up to 5000 for elements of the group 1 and 2, respectively. The reader may interpret each slot of time as 10 minutes in the real world. Moreover, we believe this set of data represents quite well the processes studied and its variability, as well.
Table 1 summarizes the structure of the generated instances. The first column shows the group. The second and third columns show the possible values for the number of jobs in and , respectively. The fourth and the fifth columns show the uniform distribution intervals from which and the processing times are drawn, respectively. The sixth column refers to the time spent on the road to deliver the products to the final clients. The last column shows the identification, where one instance is generated for each value of in the second column.
The experiments were carried out on the Operational System CentOS 7.x x86_64 with 27 compute nodes, 720 cores and 7.4 TB of RAM as the maximum capacity. We highlight that we applied only one node to proceed with the calculations. As a result, we did not use any parallel approach. Moreover, the programming languages C and C++ were used with compiler GNU GCC, and CPLEX 12.6.8. was used to solve the ILP models.
We first report the results obtained when trying to solve the ILP model running CPLEX with a time limit of 7,200 seconds. Table 2 shows results for the instances which CPLEX obtained lower and upper bounds within the time limit. Moreover, we introduced the same metrics for the Lagrangean Relaxation applied for the same instances. The results from instance group 1 are presented from the first to the ninth columns and for instance group 2 from the tenth to the eighteenth columns. For each group, we present the instance identification, the final upper (UB) and lower (LB) bounds obtained within the time limit, the percentage gap, and the time in seconds. The linear relaxation bounds are presented in the subsequent tables, along with results for the LR, as well. The percentage gap is computed as . The dash symbol “-”in the tables means that a method did not finish within the time limit.
Regarding the results, the mathematical model is able to obtain the optimal solution for 16 instances of group 1 and only 9 instances for group 2. Furthermore, the CPLEX was not able to provide neither a feasible UB nor a LB for the most complicated instances of the Group 2. In contrast, the LR was able to compute valid bounds for all instances. Indeed, the LB values were verified to be the same as the optimal solutions in 21 opportunities. Moreover, the GAP values were smaller than 3% in 20 opportunities. To conclude, the maximum time spent by the LR to complete the method was 61 seconds and it was observed for the most complicated instance.
Moreover, we present two figures that illustrate the application of the subgradient algorithm when solving the Lagrangean Subproblem. The first figure represents a scenario that the optimal solution was achieved and the other figure represents a scenario that the convergence was not achieved, Figures 6 and 7, respectively.
Then, we report the results obtained with the linear relaxation of the ILP model. Also, we present the results based on the proposed LR. The time limit was set as 7,200 seconds for both experiments.
Table 3 shows the results for instance of the groups 1 and 2. Results obtained with Linear relaxation are shown from the second to the third columns and from the eighth to the nineth columns. Moreover, the LR results are shown from the fourth to the sixth columns and from tenth to the twelfth columns. The first column presents the instance, the second column the linear relaxation solution, and the third column presents the computational time in seconds. Then, we present the LR lower bound in the next column, followed by the variance between both lower bounds found, and finally the computational time in the LR in seconds. Afterward, the same structure repeats for instances of the Group 2. The dash symbol ‘-’ in the tables means that a method did not finish within the time limit.
For both groups of instances, the results show a common pattern. The LR provided either equal or better LB result than linear relaxation for all out of the 50 instances. Also, the CPLEX was not able to compute a valid LB for the most complicated set of instances. As a result, LR outperformed the linear relaxation for all out of 46 instances. Furthermore, the LR provided valid LB for the four most complicated instances. The linear relaxation was not able to compute valid LB for those instances within 7,200 seconds computing time.
As previously mentioned, instances of group 2 were generated with longer processing times than those of group 1, c.f., Table 1. As a result, those instances present a much larger time- horizon, increasing the number of variables drastically. This fact has a significant impact on the performance of the methods.
5. Conclusions
In this work, we considered a two-machine flow shop scheduling problem with precedence constraints, release dates and delivery time. Moreover, the problem’s objective is minimizing the time a client receives the last job. This problem is the usual case for many manufacturers’ production procedures, which must check each product as soon as it is done. By doing so, the company avoids sending poor-quality products to the final client.
We also propose an adaptation of the Lagrangean Relaxation (LR) approach, which presented the best overall results. On the one hand, the LR has obtained the optimal solution only in 3 cases out of 50. On the other hand, the LR outperformed the CPLEX for the most complicated instances. The LR was able to compute feasible solutions for all instances within 61 seconds of computing time. Even though the ILP provided the optimal solution for 26 instances, those optimal solutions were achieved only for the easier instances.
Therefore, the work presents an alternative way for companies that must schedule its activities in a flow shop fashion. Besides, the activities described in that work may be adapted for a range of others scenarios. As a result, the methodology presented is a contribution to the companies that must schedule their processes, in particular in the outbound area.
As future works, we consider developing a metaheuristic to provide better UB and LB in order to achieve better solutions for the large instances.
Data Availability
The instances data used to support the findings of this study are available from the corresponding author upon request.
Conflicts of Interest
The authors declare that they have no conflicts of interest.
Acknowledgments
This work has been partially supported by Doctorats Industrials, Agéncia de Gestió d’Ajuts Universitaria I de Recerca, Generalitat de Catalunya [2016 DI 022] (Marcelus Fabri), the Spanish Ministry of Economy and Competitiveness [TRA2013-48180-C3-2-P] (Helena Ramalhinho), and CAPES, CNPq, and FAPEMIG, Brazil (Martín Gómez Ravetti, Mauricio C. de Souza).