A single machine multi-job integer batch scheduling problem with multi due date to minimize total actual flow time

. by the authors; licensee Growing Science, Canada 1 2 20 ©


Introduction
We discuss a batch scheduling of multi-job with multiple delivery dates on a single machine where every job consists of a number of parts along with a respective due date. The objective is to minimize the total actual flow time, defined by Halim et al. (1994) as the time interval of all parts on all batches to flow on the shop, starting from when that arrives until the due date. This research is relevant to the company that adopts the Just-In-Time system where the company can manage the arrival of the part when the machine is already to process it. This problem is categorized as the serial batch problem where the length of a batch is equal to the sum of processing time of part in it, and common setup time is needed before the machine processes a new batch (Baptiste, 2000). The motivation of this research is to solve the problem in an Indonesian plastic company. A single machine, the so-called extruder machine, is assigned to process a number of jobs where every job consists of a number of units with a respective due date. We identify that the processing time of jobs is different from each other. Since the warehouse capacity is limited, the companies manage the arrival of material to be a number of batches. The company should minimize the time of jobs flowing in the shop and keep on-time delivery (It is the same as minimizing the total actual flow time). The problems determine the number of batches for every job, the arrival time of the baches, the batch sizes, the schedule of the resulting batches, and the schedule of the jobs. Halim et al. (1994) have discussed batch scheduling with multi-jobs and delivery of all completed jobs at a common due date. This research assumes that the machine can process different parts in a batch and deliver all completed products at the common due date. The researcher proposes some properties and algorithms to solve the problems with the objective is to minimize the total actual flow time. Hazir and Sidhoum (2014) also study the problem to minimize the sum of the weighted earliness and tardiness penalty and the setup cost to create a new batch. They assume that there are K planned customer orders, which all orders ready to process by a single machine at time zero, and all completed jobs delivered on a common due date. They propose some properties to determine the optimal schedule and construct the optimal algorithm to solve the problem. In the literature of batch scheduling, there is a situation where a multi-job is scheduled on a single machine, and the completed job is delivered in a batch (batch delivery). Basir and Karimian (2018) have discussed that problem to minimize tardiness cost and delivery cost simultaneously. They assume that the company can control both delivery time and the quantity of product to the customer. Its decision could decrease the delay cost; however, it also increases the number of transportation. Researchers propose batch delivery to accommodate the trade-off between both tardiness cost and delivery cost. They construct a mixed-integer linear programming (MILP) model and solve it by the genetic algorithm. Another researcher, among of Yin et al. (2013), Rasti-Barzoki et al. (2013), Hamidinia et al. (2012) and Mazdeh et al. (2011) has discussed the similar problem using various objective and construct the solution by dynamic algorithm, branch and bound and Genetic Algorithm. Research on Yusriski et al. (2015a) studies a single machine batch scheduling problem with a common due date, especially on integer batch size cases. The model is similar to Hazir and Sidhum (2014); the difference is that research assumes the delivery of finished parts must coincide with the due date. The researchers adopt the backward approach to schedule the resulting batches, and using the objective the so-called total actual flow time, defined in Halim et al. (1994) as "the total of parts in all batches flowing on the shop start from that arrival to the common due date." The researcher solves the problem using the proposed algorithm and shows that the algorithm produces an optimal solution after comparing tests with an enumeration one. The reader can find similar research in Yusriski et al. (2015b), Yusriski et al. (2016), Yusriski et al. (2018), andYusriski et al. (2019).

Literatur Review
The research on batch scheduling problems considering due date can be found in Xie and Wang (2014). A study by Xie and Wang (2014) discusses a single-machine scheduling problem with batch delivery. The researcher assumes that there are a number of jobs with identical processing times so that the machine can process and then deliver the completed jobs together as a batch. The problem is determining the sequencing of the jobs and the batch sizes (the set of jobs contained in every batch) to minimize the sum of total weighted earliness, tardiness, holding, due date, and delivery costs. The researcher proposes an algorithm developed based on the dynamic programming approach and proved that the optimal sequence is found by batch-LPT order. They also show that the complexity of the algorithm is O(n 3 ). For a similar study, we refer the reader to the work of Prasetyaningsih et al. (2017) and Maulidya et al. (2019). Mohri et al. (2011) have studied a batch scheduling multi-job with multi due dates. The research is motivated by a real problem in the food manufacturing industry, which is bread production. They describe the situation where the factory makes a number of bread batches and delivers them to several stores with different due dates. Since the bread has expired so the quality of bread should deteriorate along with time, the flow time and delivery coincide at the due dates are very important. The researchers construct the algorithm and find the optimal solution to minimize the total flow time. Nurainun et al. (2016) have deals with batch scheduling on dynamic flow shop. In that research, the researcher considers the multi-item case. Albers and Bruker (1993), Ji et al. (2007) show that most of the batching problem is now polynomially solvable and some of the cases known as NP-Hard. Yet, the literature on this problem is small relatively.

The Problem Formulation
Let there be a number of jobs ( , ℎ = 1,2,3, . . , ) ordered by the customer to be scheduling on a single machine. The processing time of every job is not identical ( ). Each order consist of a set of demand ( ) to be processed into a number of batches ( ) respectively. Hence, The batch sizes per jobs are ( , = 1,2,3, … , ). There is a common setup time ( ) before a new batch to be processed by the machine. Also, all completed products of must be delivered to the customer together at their respective common due date ( ). We assume that the company can manage the arrival of materials at the time when the machine is ready to process a batch ( ). The objective is to minimize the sum of the total actual flow time of jobs ( ). The decision is to determine Jobs' sequence, the number of batches, batch sizes, and the sequence of the resulting batches.

A Mathematical Model
In this section, we describe a mathematical model of the problem. Firstly, let us understand the notation to be used in the model as follows. [ℎ] : The index of the sequence of the job, (ℎ = 1, . . . , ) using a backward approach [ ] : The index of the batch sequence, ( = 1, . . . , ) using a backward approach Eq.
(1) describes the objective function of the total actual flow time. Constraint (2) shows the makespan of all jobs scheduled in the machine must be shorter than the schedule period (start from time zero to the longest due date). It shows that the batches are scheduled using a backward approach. The Constraint (3) means material balances of jobs: the total parts on batches of a job must be the same as their demand. Constraint (4) describes that the first batch in every job could complete at the due date or before it, which means that the first batch's scheduled ready time depends on the due date and the time the previous job is scheduled. The time lag between the scheduled ready time of a job and their due date notated by [ ] , where the value of [ ] ≥ 0. Constraint (5) shows both the batch size minimum and the minimum number of bathes.

The Solution Methods
The problem of batch scheduling with multiple jobs and multiple due dates can be viewed as a single job batch scheduling problem with recurring common due dates. However, this problem's decision is not only in determining the number of batches, batch size, and batch scheduling but also in deciding on the sequence of jobs to be scheduled. The simple case is shown by determining the jobs' sequence where the distance between consecutive due dates is sufficient to schedule the jobs. However, in some cases, the distance between the two or more consecutive due dates is very narrow and close together, so it is necessary to determine which job priority should be scheduled first.

The sequence of jobs
In this section, we are determining the job sequence influenced by the characteristics of the job. There are two characteristics, namely independent and dependent jobs. Independent jobs could be scheduled without being influenced by another job. It is due to the job's completion time, including setup time , is less than the available time or the length of schedule [ ] . Meanwhile, dependent jobs always need to be scheduled simultaneously, and sharing capacity is required. The completion time of a job is the total time it takes for a machine to complete the demand. Completion time job can be calculated using the formula = 1,2,3, … . , ; ℎ = 1,2,3, … . , However, the Length of the schedule is the distance-time between two consecutive due dates. The length of the schedule period can be calculated as follows A job can be scheduled without being affected by other jobs if that completion time is shorter than its length. However, if the job completion time is longer than the length, the job scheduling decision needs to consider other jobs. In the backward scheduling approach, it is necessary to view jobs with the next index.
Proposition 1. Suppose there are K jobs with their respective due date scheduled on a single machine using the backward scheduling approach. Assume that the completion time plus setup time of jobs scheduled is less than the length . Minimizing the total actual flow time can be obtained by scheduling the jobs to non-increasing due dates in a backward scheduling approach.
It keeps the positive value of length. Since we adopted a backward scheduling approach, where the first position job on a sequence is a job close to the due date, the job must be arranged by a non-increasing due date.  [ ] . Base on Proposition 1, the job sequence must arrange according to the non-increasing due date (Longest due date, LDD). It shows that the arrangement is 1-2-3 ∎   There are three resulting pairs: 1-2, 1-3, and 2-3. Each pair of jobs has two possible sequences: 1-2 and 2-1, 1-3 and 3-1, 2-3 and 3-2. For this case, we combine the value between each pair. For example, we compare 1-2 and 2-1, and we found the value of 1-2 less than 2-1, so we give asterisks to 1-2. The complete sequence is arranged by arranging the job by a nonincreasing number of asterisks, that is 1-2-3. ∎

the number of the batches, the batch size, and the sequence of the resulting batches
The next step is to calculate the number of the batches and also the batch sizes. We adopt the formula in Halim et al. (1994) and Yusriski et al. (2015a). Assume there are G jobs (h=1,2,3,…, G), the formulas for calculating both the number of batches and the batch sizes for every single job as shown in equation () The multi-item problem could be seen as the repetition of a common due date single item problem. We can prove that nonincreasing batch sizes obtain the optimal sequence of the resulting batches on the backward scheduling approach.  The total actual flow time of ( ) is less than or equal to the schedule of We must sequence the batches in a backward approach by non-increasing the batch sizes. Halim et al. (1994) has proposed the algorithm, the so-called common due date single machine (CSM) algorithm, to solve a common due date single machine batch scheduling problem to minimize total actual flow time. Yusriski et al. (2015a) have developed a similar on Halim et al. (1994) on integer batch case. We develop both of the two algorithms on Halim and Yusriski with an adjustment; the last batch setup could be scheduled on a length of schedule period. The adjustment CSM algorithm, namely ICSM-A-Algorithm, is shown as follows.
Step 4: Base on Proposition 4, sequence the resulting batches in non-increasing [ ] .
Continue to Step 5.

The proposed algorithm
This section discusses the proposed algorithm for solving problems. There are three algorithms. The First is the P1-LDD algorithm; It is developed based on the Latest Due Date (LDD) approach. The second is the so-called P2-API algorithm; It is built based on a combination of LDD with the adjacent pairwise interchange (API) approach. The latest algorithm is the P3-PM algorithm, which is developed using the permutation (PM) method.

The P1-LDD Algorithm
Step 0: input parameters , ℎ, , , , . Continue to Step 1 Step 1: Based on Proposition 1, sequence the jobs using the Latest Due Date (LDD) rules. Set that as the initial sequence.
Continue to Step 2 Step 2: Assume that each job is processed in one batch. For each job, calculate [ ] + [ ] dan [ ] using Eq (6) and (7) Step 7. Calculate the sum of total actual flow time = ∑ [ ] ∎ Example 4. Suppose three jobs (J1, J2, J3, and J4) are scheduled on a single machine with the backward scheduling approach. Determine the sequence of jobs, the number of baches each job, and the batches' sequence with the objective is to minimize the total actual flow time. Parameters for among that jobs can be seen in Table 4  The problem was solved using The P1-LDD Algorithm. The result of that is shown as follows, Step 1: The sequence is J1-J2-J3-J4.
Step 2 to Step 4: we found the jobs grouped into three groups. The first group consists of { J1}, The second group consist of {J2}, The third group consists of two jobs, that is (J3-J4).
Step 6 The P2-API Algorithm Step 0: input parameters , ℎ, , , , . Continue to Step 1 Step 1: Based on Proposition 1, sequence the jobs using the Latest Due Date (LDD) rules. Set that as the initial sequence.
Continue to Step 2 Step 2: Assume that each job is processed in one batch. For each job, calculate [ ] + [ ] dan [ ] using Eq (6) and (7) The problem was solved using the P2-API Algorithm. The result of that is shown as follows.
Step 2 to Step 4: we found the jobs grouped into three groups. The first group consists of { J1}, The second group consist of {J2}, The third group consists of two jobs, that is (J3-J4).
Step 6: Focus on jobs in Group 3 (J3-J4). The number of asterisks by pairwise interchange method shows in Table  5 as follows. Table 5 The result of the adjacent pairwise interchange (API) method Job 3 4 The number of asterisks 3 -1.2* 1* 4 2.2 -0 Since 1.2 less than 2.2 so the sequence is J3-J4 Step 7: the final sequence is J1-J2-J3-J4.
Step 9: The total actual flow time is 183 The P3-PM Algorithm Step 0: input parameters , ℎ, , , , . Continue to Step 1 Step 1: Generate all alternative job sequences using the permutation method. Save all alternatives into List alternative sequence. It could be K! alternate sequences. Continue to Step 2. Step 3: If there are negative positions of beginning time on the sequence, remove that sequence from the alternative list.
Continue to Step 4.
Step 4: Calculate the sum of [ ] for each alternative jobs on the list.
Step 5: Set the alternative sequence with the smallest value of the sum of [ ] as a solution ∎ Example 6. Suppose the problem similar to Example 4.
The problem was solved using the P3-PM Algorithm. The result of that is shown as follows.
Step 1: There are 24 sequence alternatives: The alternative of the sequence as follows.
Solving a similar case (Example 4) using the thee algorithm (the P1-LDD algorithm, the P2-API algorithm, and the P3-PM algorithm) has the same result. We can conclude that the thee proposed algorithm fit to solve the problem.

Numerical Experience
This section has been done to check the proposed algorithm's performance by numerical experience test. We coded among the proposed algorithm by Microsoft Visual C# 8 with .NET Framework 4.8 and reported the numerical experience test using the computer processor Intel ® i7 ® 860 @ 2,80 GHz (4 Cores -8 Threads) @ 8 GB RAM. We show 25 problems as a sample and analysis that by the total actual flow time and the time unit computation. The parameter is generated by randomly using the Mersenne Twister algorithm. We set a random generator for the parameter as follows: the number of jobs between 8 to 10, the demand between 10 to 35, the processing time between 2 to 5, the set up time between 2 to 5, and the due dates between 700 to 1500. The result of the test is shown in Table 6.

Table 6
The result of the numerical experience test Based on the Bonferroni comparison method, we can observe that The P3-PM Algorithm is better than another, followed by The P2-API Algorithm and The P1-LDD Algorithm consecutively. However, the comparison of time to compute shows vise versa. The P1-LDD Algorithm is shortest than another, followed by The P2-API Algorithm and The P3-PM Algorithm.
We have been done to check more than 1000 cases. We found that the P1-LDD Algorithm has the best performance when solving a simple problem, including more groups with one job in every group. The P3-PM Algorithm has the best performance when solving small complicated problems (the problem has more groups with fewer jobs in a group with fewer than ten jobs). However, The P2-API Algorithm has the best performance when solving a complicated problem, including more groups and more jobs in every group.

Concluding Remarks
This research deals with a batch scheduling of multi-job with multiple delivery dates on a single machine where every job consists of a number of parts. The objective is to minimize the total actual flow time. A problem addressing the combination of multi-job and multi-due dates is rather complicated and known as NP-Hard. We proposed three algorithms to solve the problem based on the longest due date rule (The P1-LDD Algorithm), the adjacent pairwise interchange method (The P2-API Algorithm), and the permutation method (The P3-PM Algorithm). The numerical experience test found insight: The P1-LDD Algorithm fit to solve a simple problem, including more groups with one job in every group; The P3-PM Algorithm has the best performance when solving small complicated problems (the problem has more groups with fewer jobs in a group less than ten jobs); The P2-API Algorithm has outstanding performance when solving a complicated problem, including more groups and more jobs in every group.
The problem in this research assumes that jobs are scheduled on a single machine. There are cases in a real system that the jobs should be scheduled on a serial or parallel machine. The model can be extended to discuss scheduling jobs on flow shop, job shop, or parallel machine.