An algorithm for a no-wait flowshop scheduling problem for minimizing total tardiness with a constraint on total completion time

We consider a no-wait m-machine flowshop scheduling problem which is common in different manufacturing industries such as steel, pharmaceutical, and chemical. The objective is to minimize total tardiness since it minimizes penalty costs and loss of customer goodwill. We also consider the performance measure of total completion time which is significant in environments where reducing holding cost is important. We consider both performance measures with the objective of minimizing total tardiness subject to the constraint that total completion time is bounded. Given that the problem is NP-hard, we propose an algorithm. We conduct extensive computational experiments to compare the performance of the proposed algorithm with those of three well performing benchmark algorithms in the literature. Computational results indicate that the proposed algorithm reduces the error of the best existing benchmark algorithm by 88% under the same CPU times. The results are confirmed by extensive statistical analysis. Specifically, ANOVA analysis is conducted to justify the difference between the performances of the algorithms, and a test of hypothesis is performed to justify that the proposed algorithm is significantly better than the best existing benchmark algorithm with a significance level of 0.01.


Introduction
Jobs should be processed uninterruptedly on successive machines in a no-wait m-machine flowshop manufacturing setting. In other words, each job is processed successively from machine 1 to machine m. For example, steel, chemical, and plastic industries require no-wait in process. Hall and Sriskandarajah (1996) and Allahverdi (2016) summarize the research that has been conducted on flowshop scheduling with the no-wait constraint. Hall and Sriskandarajah (1996) reviewed more than 100 papers while Allahverdi (2016) surveyed about 300 papers. Petroleum refineries (Arabameri & Salmasi, 2013), bakery production (Hecker et al., 2014), and surgery scheduling (Wang et al., 2015) are some recent applications of the no-wait flowshop scheduling problem. The objective is minimizing total tardiness (TT) such that total completion time (TCT) is bounded above. Customer satisfaction is vital in today's economics which face harsh international competition. Customer satisfaction is achieved by minimizing total tardiness as loss of customer goodwill is related to unfulfilled due dates, Ding et al. (2015). Therefore, minimizing TT is essential. As reported by Arabameri and Salmasi (2013), no-wait flowshop scheduling applications with the minimization of TT include refineries, as chemical activities necessitate processes to be completed without delays as much as possible. This is due to penalties which result from tardiness in production. Tardiness of productions may have various penalties. Moreover, for some manufacturing environments, jobs are needed as soon as possible, which indicates that minimizing total completion time is important. Minimizing total completion time is predominantly significant when reducing holding cost is of main concern. Many researchers have discussed the importance of minimizing total cost of inventory or holding cost.
The m-machine no-wait flowshop scheduling problem to minimize TT (Fm/no-wait/ΣTj) was addressed by Ding et al. (2015), Aldowaisan and Allahverdi (2012), and Liu et al. (2013). Aldowaisan and Allahverdi (2012) proposed algorithms including simulated annealing (SA) and genetic algorithm (GA). A new version of the algorithm NEH was presented by Liu et al. (2013). Ding et al. (2015) presented an accelerated NEH algorithm and also presented iterated greedy algorithms. They showed that their algorithm outperforms the others. Many researchers addressed the m-machine no-wait flowshop scheduling problem with the objective of minimizing total completion time, e.g., Rajendran and Chaudhuri (1990), Chen et al. (1996), Fink and Voß (2003), Pan et al. (2008a). Moreover, Aldowaisan and Allahverdi (2004) proposed different heuristics and showed that their heuristics perform better than the algorithms of Rajendran and Chaudhuri (1990) and those of Chen et al. (1996). An Ant Colony Optimization heuristic was proposed by Shue et al. (2004) for the problem while a constructive heuristic was presented by Framinan et al. (2010), where they showed that their constructive heuristic performs better than the earlier ones. Nagano et al. (2012) addressed the same problem but considered setup times separately. A single criterion was addressed in the aforementioned research. However, there are some other scheduling environments with more than a single criterion, which is called multi-criteria scheduling. Multi-criteria flowshop scheduling problems are addressed by utilizing different approaches. For example, Jenabi et al. (2010), Ruiz and Allahverdi (2009), Allahverdi and Aldowaisan (2004) used a weighted linear combination of all the criteria as their objective function. On the other hand, Pan et al. (2008bPan et al. ( , 2009 and Qian et al. (2009) used The Pareto analysis. Additionally, another approach for multi-criteria scheduling problems is constraint optimization, e.g., Allahverdi and Aydilek (2013), Allahverdi (2012, 2013), Allahverdi et al. (2020). In constraint optimization, using the notation of T' Kindt and Billaut (2002), the problem can be characterized by ε(PM-1/ PM-2), where the objective is to minimize PM-1 such that PM-2 is bounded by a predetermined value. Allahverdi and Aydilek (2014) addressed the Fm/no-wait, STsi/∈(ΣCj/Cmax) problem. They presented several algorithms such SA, GA and a Differential Evolution (DE) and showed that SA outperformed the others. Allahverdi et al. (2018) presented different algorithms to the Fm/no-wait/ε(ΣTj/Cmax) problem and presented an algorithm showing that their proposed algorithm significantly outperforms the other algorithms. Allahverdi et al. (2020) addressed the Fm/no-wait/∈ (Tj/Cmaj) problem and presented an algorithm. In the current paper, we consider the no-wait flowshop scheduling problem on an m-machine to minimize TT with an upper bound on TCT, i.e., the Fm/no-wait/∈ (Tj/Cj) problem. We propose a new algorithm for the problem and compare it with the three benchmark algorithms in the literature.
The problem is defined in the next section while the proposed algorithm is presented in Section 3. Sections 4, 5, and 6 present the evaluation of the proposed algorithm, statistical analysis, and concluding remarks, respectively.

Problem description
We investigate the problem of Fm/no-wait/ε(Tj /Cj), which can be represented as follows: where UTCT is an upper bound on the total completion time which is practically specified by the scheduler. The investigated problem is NP-hard since it is known that a special case of our problem, the two-machine no-wait flowshop problem of minimizing Lmax, is NP-hard. Hence, we propose different algorithms in the following section. Let tj,k denote the processing time of job j (j= 1, …, n) on machine k (k=1, …, m), and dj represent the due date of job j. Moreover, let Cj and Tj denote the completion time and tardiness of job j, respectively, where Tj = max{0, Cj -dj}. Then, the total tardiness and total completion time can be computed as:

The proposed method
As stated earlier, the m-machine no-wait scheduling problem of minimizing total tardiness subject to a constraint on the total completion time is NP-hard. In general, two methodologies are commonly utilized in the scheduling literature for NP-hard problems. One of the methodologies is to use implicit enumeration techniques, such as dynamic programming, while another methodology is to use approximate algorithms. In this research, the second methodology will be taken as problems of any reasonable size can be solved in a short time if algorithms are utilized while problems of a limited size can be solved if implicit enumeration techniques are utilized. In this paper, we propose an algorithm for the Fm/no-wait/ε(Tj /Cj) problem. Specifically, we propose an algorithm which is merged with an iterated insertion and a constructive algorithms. No algorithm exists for our problem in the literature since the investigated problem has not been addressed earlier. In order to evaluate our proposed algorithm's performance, we also adapted a few algorithms, which have been presented for closely related scheduling problems and shown to be performing very well, to our problem as benchmarks. Our proposed algorithm along with the adapted algorithms are described in the next subsection.

Adapted Benchmark Algorithms
The unconstrained problem of Fm/no-wait/Tj is a special case of our constrained problem of Fm/no-wait/ε(Tj/Cj). In other words, our problem Fm/no-wait/ε(Tj/Cj) reduces to the problem Fm/no-wait/TT when the upper bound UTCT is set to a large value. Even though our problem Fm/no-wait/ε(Tj /Cj) has not been addressed earlier, the problem Fm/no-wait/Tj has been investigated and several algorithms were proposed. Therefore, we consider a few existing well performing algorithms designed for the unconstrained problem Fm/no-wait/Tj to compare our proposed algorithm. It is known that the algorithm MNEH performs the best among six algorithms that Liu et al. (2013) considered for the unconstrained problem of Fm/no-wait/Tj. Therefore, we adapted their algorithm MNEH to our problem and we represented it by Adp-L. Moreover, Ding et al. (2015) also provided three algorithms for the unconstrained problem and showed that one of their algorithms, AIG1, outperformed the other two. Hence, we adapted their algorithm AIG1 to our problem of Fm/no-wait/ε(Tj /Cj). We denote the adapted algorithm with Adp-D. Allahverdi et al. (2018) investigated the Fm/no-wait /ε(Tj/Cmax) problem, which is also related to our problem since they consider minimizing TT with a constraint on the makespan. IIn this paper we consider the same objective but with a constraint on TCT. We also adapt their algorithm to our problem, which is denoted by Adp-A.

The Proposed Constructive Algorithm (PCA)
The proposed constructive algorithm consists of three stages: constructing an initial sequence based on the performance measure of TT, applying an insertion to the initial sequence to satisfy the constrain on TCT, and utilizing an iterated search to improve TT such that the constraint is not violated. The PCA algorithm requires a parameter I which denotes the number of iterations, used in Step 3 of the algorithm, which is obtained based on a fair computational time of CPU with the benchmark algorithms.

Steps of PCA
Step 1: Constructing the initial sequence Select the job for the first position of the initial sequence as the job with the smallest due date. For the remaining position of the sequence, choose the job that minimizes TT. Next, insert the last selected job in all the previous positions, and select the sequence that yields the minimum TT. Continue this step for all the n jobs. The obtained sequence at the end is denoted by π1.

Step 2: Checking the constraint on TCT
Check if the sequence π1 satisfies the constraint on TCT. If so, then go to Step 3. Otherwise, conduct a pairwise exchange of the jobs in the sequence π1 until the constraint on the TCT is satisfied. The resulting sequence is denoted by π2.

Step 3: Improving TT
Conduct an iterated search on the sequence π2 to improve TT such that the TCT constraint is not violated. The search is continued until the parameter I is reached. The final sequence is denoted by π3.

Evaluation of the PCA
The performance of the proposed algorithm PCA is evaluated by comparing its performance with those of the adapted three benchmark algorithms stated earlier, which are Adp-L, Adp-D, and Adp-A. The earlier stated upper bound UTCT, which is a constraint on TCT, is required to perform computational experiments. In practice, the value of the parameter UTCT is determined by the manager of the manufacturing unit. For computational experiments, we set the UTCT value to the average value of TCT of randomly selected ten sequences. Obtaining such a value for UTCT results in neither a large nor a small TCT. This is essential since a large value of UTCT results in a problem without a constraint. On the other hand, a small value of UTCT results in an infeasible solution. A uniform distribution with a large variance is recommended for computational purposes. Therefore, we generate processing times of jobs from a uniform distribution with range of 1 to 100, which has a large variance. Generating data sets using this approach is common in the literature, e.g., Ruiz-Torres et al. (2017) and Liu et al. (2013). Moreover, due dates of jobs are needed to be generated as well. The uniform distribution with the range of LB(1-T-R/2) and LB(1-T+R/2) is usually used in the literature to generate job due dates. The parameter LB is a lower bound on makespan. The following LB is used.
The parameters T and R denote the tardiness factor and due date range, respectively. Both parameters are chosen between 0 and 1, and usually the values 0.25, 0.50, and 0.75 are used in the literature. Generating due dates utilizing this approach is common in the literature, e.g., Lee and Kim (2017), and Shao et al. (2017). The parameters of m, n, T, and R, which are used The error of an algorithm is defined as = 100 × where TT is the total tardiness of the algorithm and TTbest is the smallest total tardiness among the considered algorithms. It should be noted that we use the average of the 40 replicates and present the results as a percentage. The computational values of RE for the algorithms Adp-A, PCA, Adp-D, and Adp-L are given in Tables 2-5 for m = 2, 5, 10, and 12, respectively. The computational times and CPU times of all the algorithms were maintained to be the same for a fair comparison. In the tables, the first column indicates the number of jobs, the second column shows the algorithm, the next three columns Among the benchmark algorithms, Adp-A performs better than the benchmark algorithms Adp-D and Adp-L. Moreover, the proposed algorithm PCA performs much better than the benchmark algorithm Adp-A. Fig. 2 shows the same results by excluding the two benchmark algorithms Adp-D and Adp-L. It is clear from Fig. 2 that the performance of the benchmark algorithm Adp-A deteriorates, while that of the proposed algorithm PCA improves slightly as the number of jobs increases. Fig. 3 indicates the results with respect to the number of machines for the average errors over R, T, n, and 40 replicates. As in Figs. 1-2, the benchmark algorithm Adp-A is the best among the benchmark algorithms, and the proposed algorithm PCA performs better than the algorithm Adp-A. Fig. 4 illustrates the errors with respect to R values by taking the averages over the parameters T, n, m, and 40 replications. Similarly, Fig. 5 gives the errors for T values by taking the averages over the parameters R, n, m, and 40 replications. The figures yield the same results of the benchmark algorithm Adp-A being the best benchmark algorithm, and of the algorithm PCA performing much better than the benchmark algorithm Adp-A. The average error of all the algorithms do not seem to be dependent to either R or T values.   The overall average errors of the algorithms Adp-A, PCA, Adp-D, and Adp-L are 1.56, 0.18, 3.16, and 4.70, respectively. The error of Adp-A is 50% and 67% smaller than the errors of Adp-D, and Adp-L, respectively. Moreover, the error of the proposed algorithm PCA is 88% smaller than the error of the best benchmark algorithm Adp-A.

Statistical Analysis
An ANOVA analysis is conducted to statistically compare the performances of the proposed algorithm PCA and the three benchmark algorithms Adp-A, Adp-D, and Adp-L. Specifically the following null and alternative hypotheses are performed at a significance level of 0.01.

H1: At least one is different
where μ(.) shows the average error of the stated algorithm. The null hypothesis is rejected (at a significance level of 0.01) indicating that there is a significant difference between the performances of the algorithm. In order to justify the given results in the previous section, we further statistically compare the performance of the proposed algorithm PCA and the best benchmark algorithm Adp-A by using a test of hypothesis. A two-sample t-test is performed to statistically verify that the proposed algorithm PCA is better than the best existing benchmark algorithm Adp-A. The following hypotheses testing were performed.

Concluding Remarks
We addressed the problem of an m-machine no-wait flowshop scheduling with the objective of minimizing total tardiness such that total completion time is bounded above. We proposed an algorithm (PCA) for the problem and compared its performance with three well performing benchmark algorithms (Adp-A, Adp-D, Adp-L) from the literature. We conducted extensive computational experiments. On the average, the error of Adp-A is 50% smaller than that of Adp-D. Moreover, on average, the error of Adp-A is 67% smaller than the error of Adp-L. In other words, Adp-A performs the best among the benchmark algorithms. The computational experiments also reveal that the proposed algorithm PCA reduces the error of the best benchmark algorithm Adp-A by 88% on average under the same CPU times. Statistical analysis (ANOVA and test of hypothesis) reveals that the proposed algorithm PCA outperforms the best benchmark algorithm at a significance level of 0.01. Setup times are assumed to be zero in the current paper. Even though this assumption is valid for some manufacturing environments, it may not be valid for some other manufacturing environments, e.g., Allahverdi (2015). Therefore, an extension to the problem addressed in this paper is to consider non-zero setup times.