Minimizing Mean Completion Time in a Batch Processing System

Batch processing machines are capable of processing several jobs in a batch simultaneously. These machines are used in many real-life applications. This paper presents solution approaches to schedule batch processing machines arranged in a permutation flowshop in order to minimize its makespan (or completion time of the last batch). The processing time of each job on all the machines and their sizes are given. Each machine can process a batch of jobs as long as its capacity is not violated. The batch processing time is equal to the longest processing job in the batch. Since the problem under study is NP-hard, commercial mixed-integer solvers may require prohibitively long run time to solve even modest sized problems. Consequently, a particle swarm optimization (PSO) algorithm is proposed. Three heuristics to update the particle’s positions are also proposed. The effectiveness of the proposed PSO algorithm is compared with a commercial solver (which was used to solve a mathematical model) and several heuristics from the literature. The experimental study conducted indicates that the proposed PSO algorithm outperforms both the commercial solver and the heuristics in terms of solution quality. The commercial solver requires longer run times compared to PSO.

This paper considers a two-stage flow shop scheduling problem with a batch processing machine (BPM) in each stage. The processing time of the batch on the first machine is equal to the longest processing job in the batch, and the batch processing time on the second machine is equal to the sum of processing times of all the jobs in the batch. The jobs cannot wait between the two stages. The problem under study with the makespan objective is NP-hard. An ant colony optimisation (ACO) algorithm combined with batch forming and local search heuristics is proposed and its solution is compared with: a particle swarm optimisation (PSO) algorithm; a greedy randomised adaptive search procedure (GRASP) algorithm; and a commercial solver used to solve the mixed-integer linear formulation. The experimental study helps to highlight the advantages, in terms of solution quality and run time, of using ACO to solve large-scale problems.

This research aims to adopt two robust optimisation approaches for a real-world flow shop manufacturing system with batch processing machines, where the processing time and size of job are non-deterministic and uncertain. Each machine can process multiple jobs simultaneously as long as the machine capacity is not exceeded. Two important decisions are required: (1) grouping jobs into batches and (2) scheduling the established batches on machines. A mathematical optimisation model is presented, and then two famous robust optimisation approaches are adopted for the purpose of converting the deterministic model to the robust one. An efficient particle swarm optimisation (PSO) algorithm is developed to solve the problem in a reasonable time. In order to verify the developed model and evaluate the performance of our proposed algorithm, a set of small to large test problems are generated, and a simulation approach and a commercial optimisation solver are used to solve these problems. Analysis of the implementation of two independent robust optimisation methods is performed by the paired t-test on all of the test problems. Furthermore, the Taguchi method, as a statistical optimisation technique, is employed to investigate the appropriate level of PSO parameters.

An effective hybrid multi-objective genetic algorithm for bi-criteria scheduling on a single batch processing machine with non-identical job sizes

We consider a batch processing system {pi : i = 1, 2,..., n} where pi is the processing time of job i, and up to B jobs can be processed together such that the handling time of a batch is the longest processing time among jobs in the batch. The number of job types m is not fixed and all the jobs are released at the same time. Jobs are executed nonpreemptively. Our objective is to assign jobs to batches and sequence the batches so as to minimize the total completion time. The best previously known result is a 2-approximation algorithm due to D. S. Hochbaum and D. Landy [6]. In this paper, we establish the first polynomial time approximation scheme (PTAS) for the problem.

This paper considers single-machine just-in-time scheduling of jobs that may be grouped into batches subject to a constraint on batches' weights. A job has a weight, due date, and earliness and tardiness penalties per unit time. A batch's processing time is determined by its jobs. Each job inherits its batch's completion time. The objective is to minimize the weighted sum of earliness and tardiness penalties of all jobs. This problem is challenging: Jobs-to-batch assignment changes the batch's processing time; thus, affects the structure of the entire solution and most importantly of its cost components. This problem is an excellent benchmark for testing linkage learning techniques, which exploit a problem's structure. We propose a matheuristic LTGA, which integrates evolutionary algorithms with mixed-integer programming (MIP). It builds a linkage tree that extracts the dependency among decision variables of MIP solutions. We compare its performance to a state of the art matheuristic CMSA, which combines the learning component of an ant colony system (ACS) with MIP within a construct, solve, merge, and adapt framework. It uses knowledge extracted from ACS' ants to construct a restricted MIP, solves it efficiently, and feeds it back to ACS. Computational tests indicate that LTGA outperforms MIP solvers and CMSA.

Lot streaming technology enables continuous overlapping operations, which is of great significance in shortening production cycles, reducing unnecessary waiting time, and increasing production capacity. However, the capacity constraint of batch processing machines may lead to inevitable variations in sublots. Therefore, the key focus of our research is to control variations of sublot for maximising benefits. In view of this, we investigate a hybrid flowshop scheduling problem (HFSP) with batch processing machines and variable sublots (HFSP-BVS) integrating sequence-dependent setup times and transportation times. To address HFSP-BVS, a MILP model is first established, and a novel collaborative iterative greedy (NCIG) algorithm is proposed to optimise the cumulative payoffs associated with delivery dates. In NCIG, a collaborative initialisation method by extracting good information from an archive is proposed, and a specific destruction-reconfiguration strategy is designed to control the variations of sublots in the batch processing stage. Furthermore, a dynamic acceptance criterion is designed to balance the algorithm's exploitation and exploration capabilities. Lastly, we conduct comparisons between the NCIG algorithm and five other metaheuristic algorithms on 100 test instances. The results show that NCIG outperforms them by 1.89% and 61.42% on average in terms of the total penalty and RPI values, respectively.

This paper presents a makespan minimization of -jobs -machines re-entrant flow shop scheduling problem (RFSP) under fuzzy uncertainties using Genetic Algorithm. The RFSP objective is formulated as a mathematical programme constrained by number of jobs and resources availability with traditional scheduling policies of First Come First Serve (FCFS) and the First Buffer First Serve (FBFS). Jobs processing times were specified by fuzzy numbers and modelled using triangular membership function representations. The modified centroid defuzzification technique was used at different alpha-cuts to obtain fuzzy processing times (FPT) of jobs to explore the importance of uncertainty. The traditional GA schemes and operators were used together with roulette wheel algorithm without elitism in the selection process based on job fuzzy completion times. A test problem of five jobs with specified Job Processing and Transit Times between service centres, Job Start Times and Job Due times was posed. Results obtained using the deterministic and fuzzy processing times were compared for the two different scheduling policies, FCFS and FBFS. The deterministic optimal makespan for FBFS schedule was 61.2% in excess of the FCFS policy schedule.  The results also show that schedules with fuzzy uncertainty processing times provides shorter makespans than those for deterministic processing times and those under FCFS performing better than those under FBFS policy for early jobs while on the long run the FBFS policy performs better. The results underscore the need to take account of comprehensive fuzzy uncertainties in job processing times as a trade-off between time and costs influenced by production makespan. http://dx.doi.org/10.4314/njt.v36i3.21

This paper considers a flow shop with two batch processing machines. The processing times of the job and their sizes are given. The batch processing machines can process multiple jobs simultaneously in a batch as long as the total size of all the jobs in a batch does not exceed its capacity. When the jobs are grouped into batches, the processing time of the batch is defined by the longest processing job in the batch. Batch processing machines are expensive and a bottleneck. Consequently, the objective is to minimize the makespan (or maximize the machine utilization). The scheduling problem under study is NP-hard, hence, a genetic algorithm (GA) is proposed. The effectiveness (in terms of solution quality and run time) of the GA approach is compared with a simulated annealing approach, a heuristic, and a commercial solver which was used to solve a mixed-integer formulation of the problem. Experimental study indicates that the GA approach outperforms the other approaches by reporting better solution.

New completion time algorithms for sequence based scheduling in multiproduct batch processes using matrix

Since its release, Spring Framework has transformed virtually every aspect of Java development including web applications, security, aspect-oriented programming, persistence, and messaging. Spring Batch, one of its newer additions, now brings the same familiar Spring idioms to batch processing. Spring Batch addresses the needs of any batch process, from the complex calculations performed in the biggest financial institutions to simple data migrations that occur with many software development projects. Pro Spring Batch is intended to answer three questions: What? What is batch processing? What does it entail? What makes it different from the other applications we are developing? What are the challenges inherent in the development of a batch process? Why? Why do batch processing? Why cant we just process things as we get them? Why do we do batch processing differently than the web applications that we currently work on? How? How to implement a robust, scalable, distributed batch processing system using open-source frameworks Pro Spring Batchgives concrete examples of how each piece of functionality is used and why it would be used in a real-world application. This includes providing tips that the school of hard knocks has taught author Michael Minelladuring his experience with Spring Batch. Pro Spring Batch includes examples of I/O options that are not mentioned in the official users guide, as well as performance tips on things like how to limit the impact of maintaining the state of your jobs. The author also walksyou through, from end to end, the design and implementation of a batch process based upon a theoretical real-world example. This includes basic project setup, implementation, testing, tuning and scaling for large volumes. What youll learn Batch concepts and how they relate to the Spring Batch framework How to use declarative I/O using the Spring Batch readers/writers Data integrity techniques used by Spring Batch, including transactions and job state/restartability How to scale batch jobs via distributed batch processing How to handle testing batch processes (Unit and functional) Who this book is for Java developers with Spring experience. Java Architects designing batch solutions More specifically, this book is intended for those who have a solid foundation in the core Java platform. Batch processing covers a wide spectrum of topics, not all of which are covered in detail in this book. Concepts in Java whichthe reader should be comfortable with include file I/O, JDBC, and transactions. Given that Spring Batch is a framework built upon the open-source IoC container Spring, which will not be covered in this book, it is expected that the reader will be familiar with its concepts and conventions. With that in mind, the reader is not expected to have any prior exposure to the Spring Batch framework. All concepts related to it will be explained in detail, with working examples.

We consider the problem of minimizing the makespan on a batch processing machine, in which jobs are not all compatible. Only compatible jobs can be included into the same batch. This relation of compatibility is represented by a split graph. Jobs have release dates. The capacity of the batch processing machine is finite or infinite. The processing time of a batch is given by the processing time of the longest job in the batch. We establish the NP-hardness of the general problem and present polynomial algorithms for several special cases. Relating scheduling theory and graph theory appears to be an interesting and important concept.

In this paper, we discuss a two-stage flow shop scheduling problem with batch processing machines. The jobs belong to different incompatible job families. Only jobs of the same job family can be batched together. The performance measure is the total weighted tardiness of the jobs. A decomposition heuristic is proposed that is based on the idea to iteratively determine due dates for the jobs in the first stage and earliest start dates of the jobs in the second stage. The two resulting subproblems are solved using a time window decomposition (TWD) heuristic and a variable neighborhood search (VNS) scheme. Results of computational experiments based on randomly generated problem instances are presented. We show that the VNS-based scheme outperforms the TWD heuristic. In addition, we show that the decomposition scheme can be parallelized in a very natural way. As a result, the amount of computing time is modest, even for the computational expensive VNS scheme.

This paper presents a low-complexity algorithm for online job scheduling at workcenters along a given route in a manufacturing system. At each workcenter, the job has to be processed by any one of a given set of identical machines. Each machine has a preset schedule of operations, leaving out time-windows during which the job's processing must be scheduled. The manufacturing system has no internal buffers and the job cannot wait between two consecutive operations. There is some flexibility in the job's processing times, which must be confined to given time intervals. The scheduling algorithm minimizes the job's completion time, and it is executable in real time whenever the job requirement is generated.

On the Capacity of a Process with Batch Processing and Setup times