A Novel Approach for the Process Planning and Scheduling Problem Using the Concept of Maximum Weighted Independent Set
β Department of Mechanical & Aerospace Engineering, College of Engineering & Computer Science, Syracuse University, Syracuse, NY 13244, USA. ([email protected])
A Novel Approach for the Process Planning and Scheduling Problem Using the Concept of Maximum Weighted Independent Set
Kai Sun β Abstract
Process Planning and Scheduling (PPS) is an essential and practical topic but a very intractable problem in manufacturing systems. Many research use iterative methods to solve such problems; however, they cannot achieve satisfactory results in both quality and computational speed. Other studies formulate scheduling problems as a graph coloring problem (GCP) or its extensions, but these formulations are limited to certain types of scheduling problems. In this paper, we propose a novel approach to formulate a general type of the PPS problem with resource allocation and process planning integrated towards a typical objective, minimizing the makespan. The PPS problem is formulated into an undirected weighted conflicting graph, where nodes represent operations and their resources; edges represent constraints, and weight factors are guidelines for the node selection at each time slot. Then, the Maximum Weighted Independent Set (MWIS) problem can be solved to find the best set of operations with their desired resources for each discrete time slot. This proposed approach solves the PPS problem directly with minimum iterations. We establish that the proposed approach always returns a feasible optimum or near-optimum solution to the PPS problem. The different weight configurations of the proposed approach for solving the PPS problem are tested on a real-world PPS example and further designated test instances to evaluate the scalability, accuracy, and robustness. Introduction
Process Planning and Scheduling (PPS) is to process a set of prismatic parts into completed products effectively and economically in a manufacturing system. A prismatic part to be produced is generally described by features. For each feature, one or more corresponding operations are determined according to its feature geometry and available machining resources. Each operation requires a selection of critical resources; some examples of these vital resources include machines, tools, fixtures, or specially qualified technicians. The resource constraints are that one critical resource cannot be occupied by more than one operation at the same time. There are precedence relationship constraints among operations, according to the geometrical and technological considerations. Process planning in PPS is the determination of an optimum process plan, i.e., operations and their sequences, within the precedence relationship constraints and resource constraints. The scheduling is the allocation of the resources in the machine shop over time to manufacture the various parts (Zhang et al., 2003). One of the common objectives is to find the feasible schedule with the earliest finishing time of all parts, or formally, minimizing the makespan.
PPS as one of the main functions of Computer-Aided Process Planning (CAPP) system, it becomes more critical for the effective allocation and utilization of resources in modern flexible manufacturing systems. The challenges are, firstly, a closer integration of process planning and scheduling is required. More specifically, the determination of the operation processing order in a machine shop and the allocation of resources for each operation need to be considered interactively. Secondly, non-iteration or light-iteration methodologies with satisfactory accuracy are desired for the PPS problem. More specifically, the PPS problem is usually solved in a trial and error fashion using methods such as generic algorithms and metaheuristics. However, such methodologies do not guarantee an optimal solution is ever found, and they usually do not scale well with complexity. Also, these methods operating on dynamic data sets is difficult, as genomes begin to converge early on towards solutions which may no longer be valid for later data. In this paper, we propose a novel approach for formulating and solving the resource-constrained PPS optimization problem. The two procedures, the resource selection and process scheduling, are integrated and formulated into an undirected weighted conflicting graph due to the nature of sequencing and resource constraints. A node in the conflicting graph represents one operation with one possible combination of its required resources during one time slot, and an edge indicates that there is a conflict between the two nodes at both ends of the edge. Each node in the graph is assigned with a weight factor as the guidance for the node selection process to fulfill the optimization objective. The node with a higher possibility leading to the objective, is given a larger weight, so that they are more likely to be selected when generating the schedule. We utilize algorithms proposed in our work (Sun et al., preprint) to solve the Maximum Weighted Independent Set (MWIS) problem to realize this node selection process to get the optimum or a near-optimum solution. Note that this is a preprint of the paper that is scheduled to submit to Applied Discrete Mathematics. The remainder of the paper is organized as follows. Section 2 provides a comprehensive literature review on the PPS problem. Section 3 provides the mathematical modeling and implements the Integer Programming (IP) model. Section 4 discusses how the conflicting graph is generated for the resource-constrained PPS problem. Section 5 explains how we configure the weight factors in the conflicting graph with the proposed MWIS algorithms (Sun et al., preprint) to achieve the optimization objective. In Section 6, a simplified PPS example problem from the literature (Zhang et al., 2014) is employed to illustrate the proposed approach. Section 7 describes our approach with a real-world problem (Zhang et al., 2014; Chu & Gadh, 1996; Zhang et al., 2003; Li et al., 2005; Li & McMahon, 2007) to verify the practicability. Section 8 discusses and analyzes the results of test instances. Finally, a few concluding remarks are given in Section 9. Literature Review
Process planning and scheduling are usually complementary procedures. The former, process planning, can be used to plan manufacturing resources and operations for a part to ensure the application of good manufacturing practice and maintain the consistency of the desired functional specifications of the part during its production processes. Process planning activities include interpretation of design data, selection and sequencing of operations to manufacture the part, selection of machines and cutting tools, determination of cutting parameters, choice of jigs and fixtures, allocation of other resources required by the processes, and calculation of machining times and costs. To clarify process planning, parts are represented by manufacturing features. Figure 1 shows a part composed of π features in which each feature can be manufactured by one or more machining operations ( π operations in total for the part). Each operation can be executed by several alternative plans if different machines, cutting tools, or set-up plans are chosen for this operation (Case & Harun Wan, 2000; Maropoulos & Baker, 2000). The latter, scheduling, specifies the schedule of manufacturing resources on each operation of the parts according to the importance of parts (jobs), availability of resources and time constraints, and in the meantime, achieves the optimization objectives (Zhang et al., 2003). Figure 1. Representation of the Process Plan (adapted from Salehi & Bahreininejad, 2011) PPS problems vary in complexity. However, seeking an optimum solution rapidly and effectively from all of the permutations, combinations of all of the tasks, manufacturing resources according to specified criteria is very difficult for decision-makers. Lenstra et al. (Lenstra et al., 1977) show that while some classical machine scheduling problems are efficiently solvable, others are NP-hard. Due to its importance, practicality, and difficulty, in the past decade, many research studies have addressed the PPS problem. Traditionally, such a problem is usually solved in a trial and error fashion adopting methods such as generic algorithms and metaheuristics (Alander, 2014; Milosevic et al., 2016). These approaches include simulated annealing algorithm (Zhang et al., 2003; Tiwari et al., 2006; Li & McMahon, 2007; Chan et al., 2009), tabu search algorithm (Yan et al., 2003), agent-based approach (Shen et al., 2006; Wong et al., 2006), particle swarm optimization algorithm (Guo et al., 2006) and genetic algorithm (Zhang et al., 1997; Morad & Zalzala, 1999; Jia et al., 2002, 2003, 2007; Kim et al., 2003; Chan et al., 2005, 2006, 2008; Moon & Seo, 2005; Li et al., 2005; Zhang & Yan, 2005; Chan et al., 2006; Zhang & Gen, 2010; Salehi & Bahreininejad, 2011; Chaube et al., 2012; Qiao & Lv, 2012; Zhang et al., 2014). Researchers also solved the PPS problem partially as an operation sequencing problem with individual parts (Salehi & Bahreininejad, 2011; Su et al., 2018). According to the discussions above, the integration and interactions of PPS are through an iterative and empirical Part i Feature F i1 Feature F im Operation O i1 Operation O i2 Applicable machinesApplicable tools
Other applicable parameters
Applicable machinesApplicable tools
Other applicable parameters
Operation O in Applicable machinesApplicable tools
Other applicable parameters fashion. The process planning system first generates a reasonable process plan for each part. Crucial processes in the system include determining suitable manufacturing resources (such as machines and tools), selecting set-up plans, and sequencing machining operations of the part. The scheduling system then specifies the schedule of manufacturing resources on each operation (task) of the parts according to the importance of operations, availability of resources, and time constraints. It is usually difficult to produce a satisfactory result in a single iteration of the execution of the two systems. For the process planning system, the decision of selecting machines and tools is usually made based on objectives to achieve the minimal manufacturing cost and ensure the good manufacturability of a part. Not all the generated process plans for a group of parts could be schedulable according to the time and resource feasibility in a job shop. To overcome this issue, it is necessary iteratively to re-invoke the process planning system to produce alternative plans for further trials until an acceptable scheduling solution is obtained. However, the above iterative process brings forth two severe problems in practical applications. First, it is quite tedious and time-consuming to search for a feasible solution to meet the requirements of process planning and scheduling simultaneously, and an overall optimized target is even more difficult to achieve. Meanwhile, the value of a process plan can be severely discounted since the assumption that all resources are available during the process planning stage might not be entirely valid in the scheduling stage. For instance, the generated process plans sometimes cause some machines to be overloaded, further, to create bottlenecks and restrict the capabilities of machines. Second, the PPS problem has vast solution spaces due to its combinatorial nature. Each time period can schedule one of the feasible operation sets, a feasible operation set can be any non-empty combination of feasible operations, and each operation can be one instance among all the feasible combinations of the available resources. The iteration-based approach needs to be carried out again and again in this vast discrete solution space. Furthermore, the outputs of such methodologies are easily trapped at local optimum, and the local optimum is hard to detect due to the combinatorial nature of such a problem. Modeling a PPS problem as a Graph Coloring Problem (GCP) is particularly relevant in the presence of incompatible jobs. Extensions of the GCP have been proposed to cope with these scheduling environments (Epstein et al., 2009; Fukunaga et al., 2007; De Werra et al., 2005; Giaro et al., 2009; HalldΓ³rsson et al., 2004; Meuwly et al., 2010; Thevenin et al., 2018). As we identify in the previous section, the structural nature of some scheduling problems makes graph coloring an attractive formulation. Gamache et al. (Gamache et al., 2007) use graph coloring methods to determine a feasible schedule for crew scheduling problems within the airline industry. Moreover, they propose a new methodology to determine the existence of a feasible solution based on a graph coloring model and a tabu search algorithm. However, these methodologies often require a specific application environment. For example, BlΓΆchliger and Zufferey (BlΓΆchliger & Zufferey, 2013), Thevenin et al. (Thevenin et al., 2018) formulate the PPS problem as a graph multi-coloring problem. They require that the production system uses continuous flow production, and each job is leading to the end product with no resource change. And still, unlike the particular case of the scheduling problem they are attempting, a typical PPS problem often requires multiple operations to be performed with different resource selections for each job following sequencing constraints. For those reasons, the graph multi-coloring formulations of the PPS problem could be limited in terms of universality. As a consequence of the review, the requirements are, firstly, a closer integration of process planning and scheduling is required. More specifically, determining the operation processing order in a machine shop and allocation of resources for each operation needs to be considered interactively. Secondly, a direct method or a method with fewer iterations is desired to solve the PPS problem. Starting with the nature of the PPS problem, we proposed a novel approach to formulate a general type of the PPS problem with resource allocation and process planning integrated towards a typical objective, minimizing the makespan. The PPS problem is formulated into an undirected weighted conflicting graph. In this conflicting graph, nodes stand for operations and their resources; edges stand for constraints; weight factors are the guidelines for the node selection at each time slot. A variation of GCP, the MWIS problem, can be solved to find the best set of operations with their desired resources for each discrete time slot. This proposed approach can solve the problem directly, or it can be applied with few iterations for improving the quality of results. The performance of the proposed approach depends on the accuracy and computational speed of the MWIS algorithms. We utilize algorithms reported in our work (Sun et al., preprint) to solve the MWIS problem to realize this node selection process to get the optimum or a near-optimum solution. Process Planning and Scheduling Problem
Problem Description
As an example of the PPS problem in a manufacturing system, there are four parts to be processed by four machines with a number of tools. Each part requires several operations (four parts have 4, 3, 3, and 4 operations, respectively), and each operation can be performed on at least one available machine with different processing times. Table 1 shows the operation information of the four parts. Each column describes the part ID, operation ID, successors, operation name, machine candidates, tool candidates, and machining time, respectively. The illustration of one feasible solution to this example problem is shown in Figure 2.
Table 1. Operation Information of Part 1-4
Part-ID Op-ID Successor Operations Machine Candidates Tool Candidates Machining time (time unit) Part 1 O O , O Milling M , M , M T , T
40, 40, 30 O O Milling M , M , M T , T
40, 40, 30 O O Milling M , M , M T , T
20, 20, 15 O - Drilling M , M , M , M T
12, 10, 10, 7.5
Part 2 O O , O Drilling M , M , M , M T
12, 10, 10, 7.5 O - Milling M , M , M T
20, 20, 15 O - Milling M , M , M T , T T
18, 18, 13.5
Part 3 O O Milling M , M , M T , T
20, 20, 15 O - Milling M , M , M T , T
20, 20, 15 O O Milling M , M , M T , T
15, 15, 11.25
Part 4 O O Milling M , M T , T
12, 15 O O Milling M , M T , T
21, 18 O - Milling M , M T
18, 25 O - Milling M , M T , T
27, 25
The PPS problem herein is to determine a process plan and schedule (Gantt chart is shown in the lower part of Figure 2), which provides the information for decision-makers on how, when, and in which sequence to allocate these operations of parts to suitable manufacturing resources effectively. When determining the process plan, the best practice operation sequence should be decided first. Then, manufacturing resources such as a machine and one tool should be assigned to every operation. All the manufacturing resources are assumed available in this phase. The determination of schedule is to decide the most appropriate moment to execute each operation with competitive resources like machines, tools, and other possible critical resources. Precedence constraints and resource constraints should be satisfied while determining the process plan and schedule. Moreover, this process plan and schedule should also satisfy the optimization objectives (in this case, minimizing the makespan) concurrently while maintaining the feasibility.
The problem can be defined as follows: (i)
Part scheduling: determining how and when to allocate the manufacturing resources to the parts and satisfying the best practice operation sequencing for all the parts. (ii)
Machine and tool selecting: determining the resource selection according to the feature geometry and available machining resources.
The PPS problem subjects to the following assumptions: A1.
Each resource set (a set of resources needed for processing an operation) can only handle one operation at each time;
A2.
Each operation is completed before another operation is loaded;
A3.
The sequence of the operations of each part complies with manufacturing constraints;
A4.
All parts, machines, tools and other possible resources are available at time zero simultaneously;
A5.
Each operation is performed on a single resource set, and each resource can only be occupied by one operation at a time;
A6.
The time for setup change is considered as part of the operation. The time for a machine change or a tool change follows the same assumption;
A7.
Machines are continuously available for production. As for the constraints, there are precedence constraints among the operations of each part. These precedence relationships must not be violated in the manufacturing process. For example, a best practice operation sequence of 14 operations from example PPS problem is shown as in the top part of Figure 2. According to this operation sequence, the manufacturing resources can be specified (machines, tools, and other possible critical resources), and then, the schedule can be determined.
Figure 2. Illustration of the PPS Example Problem
Mathematical Formulation of the PPS Problem
Many important and frequently-used objectives in both literature and real-life are applied in the PPS problem. To name a few, there are minimizing the makespan, variation of workload for each machine, minimizing cost, maximizing capacity utilization, delivery dates, or profit optimizations. In this work, we are focusing on minimizing the makespan as the main objective for our solution to the PPS problem. Minimizing the makespan means that the
M1M2
M3M4 O : 12 O : 40 O : 20 O : 20 O : 18O : O : 18 O : 25 O : 15 O : 25 O : 1520 O : 30 O : 15 O :
60 80 98 T9 T10T11T12 O : 12 O : 40 O : 20 O : 20 O : 18O : : 18 O : 25 O : 15 O : 25 O : 15 O : 30 O : 15 O : T8T7
T6T5T3T2 T1 Part O O O O O O O O O O O O O O Part
Part
Part manufacturing system can get high production in a limited period. Or, in other words, the earliest time for finishing all the planned parts. The mathematical model of the problem is expressed in the following notations:
Indices π, π : indices of part, (π, π = 1, 2, . . . , πΌ ) . π, β : indices of operation for part π , (π, β = 1, 2, . . . , π½ π ) . π : index of machine, (π = 1, 2, . . . , π) . π : index of tool, (π = 1, 2, . . . , πΏ) . Parameters πΌ : number of parts. π½ π : number of operations for part π . π : number of machines. πΏ : number of tools. π π : set of operations for part π , π π = {π π,π | π = 1, 2, . . . , π½ π } . π π,π : the π th operation of part π . π π : the π th machine. π‘ π : the π th tool. π π,π : a set of machines that can process π π,π . πΏ π,π : a set of tools that can process π π,π . π΄ π : a set of operations that can be processed on machine π . π΄ π : a set of operations that can be processed with tool π . π π,π,β : precedence constraints. if π π,π is predecessor of π π,β , π π,π,β = 1 ; otherwise, 0. π‘ π,π,ππ : processing time of π π,π by machine π . All the process related time such as setup time, tool and machine change time are integrated with π‘ π,π,ππ . π‘ π,π,ππΆ : completion time of π π,π by machine π , it should satisfy the inequality π‘ πβ²,π,(πβ1)πΆ + π‘ π,π,ππ β€ π‘ π,π,ππΆ that means for every operation, its direct predecessorβs completion time plus its processing time might be shorter than its completion time. Decision variables π₯ π,π,ππ = {1, ππ π π,π ππ πππππππππ ππ¦ πππβπππ π,0, ππ‘βπππ€ππ π (1) π₯ π,π,ππΏ = {1, ππ π π,π ππ πππππππππ ππ¦ π‘πππ π,0, ππ‘βπππ€ππ π (2) π¦ π,π,π,β = {1, ππ π π,π ππ πππππππππ ππ π‘βπ π πππ πππβπππ πππβπ‘ ππππππ π π,β ,0, ππ‘βπππ€ππ π (3) Ξ©(π, π) = { 1, ππ π β π,0, ππ‘βπππ€ππ π (4)
The mathematical model for minimization of makespan can be formulated as the following the mixed-integer programming model: min π‘ π = max π,π,π {π‘ π,π,ππΆ } (5) π . π‘. (π‘ π,π,βπΆ β π‘ π,π,βπ β π‘ π,π,ππΆ ) β π₯ π,π,ππ β π₯ π,π,βπ β π¦ π,π,π,β = 0, β(π, π), (π, β), π (6) π . π‘. (π‘ π,π,βπΆ β π‘ π,π,βπ β π‘ π,π,ππΆ ) β π₯ π,π,ππΏ β π₯ π,π,βπΏ β π¦ π,π,π,β = 0, β(π, π), (π, β), π (7) π π,π,β β π¦ π,β,π,π = 0, β(π, π), β (8) π¦ π,π,π,π = 0, β(π, π) (9) β π₯ π,π,ππππβ1 = 1 , β(π, π) (10) β π₯ π,π,ππΏπΏπβ1 = 1 , β(π, π) (11) π₯ π,π,ππ = 0, β(π, π) β π΄ π , βπ (12) π₯ π,π,ππΏ = 0, β(π, π) β π΄ π , βπ (13) π¦ π,π,π,β β {0,1}, β(π, π), (π, β) (14) π₯ π,π,ππ β {0,1}, βπ, (π, π) (15) π₯ π,π,ππΏ β {0,1}, βπ, (π, π) (16) π‘ π,π,ππΆ β₯ 0, βπ, (π, π) (17) π‘ π,π,ππ β₯ 0, βπ, (π, π) (18) Firstly, the objective function for the PPS problem. Equation (5) illustrates the objective function, which is the minimization of makespan π‘ π . Makespan π‘ π is the last operationβs finishing time, i.e., the maximization of completion time among all the operations. Secondly, the sequencing constraints. Equations (6) and (7) imposes that any machine or tool cannot be selected for one operation until the predecessor is completed. The precedence constraint is defined as Equation (8). Equation (9) ensures the feasible operation sequence. Thirdly, the incompatible resource constraints. The feasible resource selection is defined by Equations (10) and (11). Equation (10) ensures that one operation is only performed on a single machine, and Equation (11) ensures that one operation requires only one tool. Equation (12) and (13) denotes that the assignment of machine and tool for each operation should be selected from the available machine candidates and tool candidates. Lastly, Equations (14), (15), (16), (17) and (18) impose nonnegative condition. Implementation of Integer Programming (IP) Model
In order to get the optimum solution to the PPS problem, the IP model is implemented and tested based on the mathematical modeling discussed in Section 3.2. The IP model is implemented with python package βpyomoβ in Python 3.7.5. The solver utilized in this implementation is βglpk (GNU Linear Programming Kit).β Figure 3. Parts Information with Simplified Duration Information Figure 4. Input of Part π [(π ,π ,π ) ]2 β π [(π ,π ,π ) ]1 β π [(π ,π ,π ) ]2 β π [(π ) ]1 Part π [(π ,π ,π ) ]1 β π [(π ) πππ(π ,π ) ]2 β π [(π ) ]1 Part π [(π ,π ) ]1 β ( π [(π ,π ) ]1π [(π ) ]2 ) β π [(π ,π ) ]3 Part π [(π ,π ,π ) ]1 β π [(π ,π ,π ) ]2 β π [(π ,π ,π ) ]1 β π [(π ,π ,π ) ]1 β π [(π ) ]1 Where, π , π , π , π are the four different resources. For π [(π ,π ,π ) ]2 , it means that the first operation (task π ) of Part (π , π , π ) and the duration is 2 time slots. ( π [(π ,π ) ]1π [(π ) ]2 ) means that the task π can be processed with two task options π and π . machines, tools and all other possible resources as π number of resources, (π , π , β¦ , π π ) . The input format, taking Part The variables β’ model.start = pyo.Var(PARTS, RESOURCES, domain = pyo.NonNegativeReals) β’ model.makespan = pyo.Var(domain=pyo.NonNegativeReals) β’ model.y = pyo.Var(PARTS,PARTS,RESOURCES, domain = pyo.Boolean) (2) The objective β’ model.Obj = pyo.Objective(expr = model.makespan, sense = pyo.minimize) (3) The constraints For the instances of the same tasks but different resources, these instances must have the same start time. β’ model.cons.add(model.start[j,r] <= model.start[m,n]) β’ model.cons.add(model.start[m,n] <= model.start[j,r]) The makespan is the finishing time for all tasks. β’ model.cons.add(model.start[j,m] + TASKS[(j,m)]['dur'] <= model.makespan) For a task which requires a predecessor, it can only be scheduled after the predecessor is finished. β’ model.cons.add(model.start[j,m] >= model.start[k,n] + TASKS[(k,n)]['dur']) For the tasks who shares resources, they cannot be scheduled in the same time. β’ model.cons.add(model.start[j,m] + TASKS[(j,m)]['dur'] <= model.start[k,m] or model.cons.add(model.start[k,m] + TASKS[(k,m)]['dur'] <= model.start[j,m] Numerical Results of IP Model
We introduce the I nput C omplexity I ndex (ICI) to measure the complexity of inputs. It is essentially a reference value describing the relative size of the possible number of combinations of results of the PPS problem. The PPS problem can be understood as a conflicting graph so that we can utilize some parameters of this graph to calculate the ICI. The ICI can be defined as, πΌπΆπΌ = |π| (|π||π|β1) β |π| β |π| β |π·|
Where, |π| is the number of parts; |π| is the number of tasks; |π| is the total number of the options of the tasks. |π·| is the density of the conflicting graph, and |π| is the number of nodes of the conflicting graph. The graph density is defined as follows (Diestel, 2006),
π· = 2|πΈ||π|(|π| β 1)
Where, |πΈ| is the number of edges in the conflicting graph. IP is NP-complete on discrete problems, which means that its computation time should increase exponentially with the size of the inputs. To verify this hypothesis, we simulated 10 PPS problems considering a different number of parts and operations, as well as diverse information for operations. The results are shown in Table 2. In Table 2, each column describes the test ID, number of parts, number of tasks, number of edges, number of nods, graph density, number of options, ICI, 3-run average clock time in seconds, minimum makespan, respectively. Note that all computational experiments in this work are performed on a virtual server at Syracuse University. The CPU is Intel Xeon E5-2699 with a fixed maximum speed at 2.3 GHz, and the memory is 32 GB. All the implementations mentioned in this paper are in single threading. Figure 6. Computation Time with Changing ICI Figure 7. Logarithmic Computation Time with Changing ICI C o m pu t a t i o n T i m e ( s ) Input Complexity Index
Computation Time with Changing Input Complexity
Clock Time (s) Expon. (Clock Time (s))00.511.522.533.544.5 0 5000 10000 15000 20000 25000 l o g o f ( C o m pu t a t i o n T i m e ( s )) Input Complexity Index
Logarithm of Computation Time with Changing Input Complexity log10 of Computation Time Linear (log10 of Computation Time) Table 2. Integer Programming Model Numerical Results
Test-ID
2 7 111 24 0.40 1 218.40 6.59 7
3 10 227 35 0.38 2 3119.84 68.67 8
3 11 307 37 0.46 1 2873.64 26.97 16
4 12 315 41 0.38 2 8064 118.94 11
4 12 390 41 0.48 2 9984 150.77 10
5 13 316 40 0.41 2 10640.80 643.77 7
5 14 396 41 0.48 2 17938.30 5794.50 10
5 14 504 45 0.51 2 20755.05 12196.93 10
4 14 375 41 0.46 1 9600 213.92 18
4 14 1074 63 0.55 1 17738.32 2959.31 18
The computation time follows an exponential trendline with increasing input ICI in Figure 6, and the logarithmic computation time follows a straight trendline with increasing input ICI in Figure 7. It can be seen that the IP model follows an exponential complexity of the PPS problem. Although the solution of the IP model can provide the optimum solution to the PPS problem, the computational speed is unacceptable. But we can manipulate inputs based on the outputs of our approach, so that the outputs of our approach can be verified in terms of accuracy.
Discussions on Formulating and Solving the PPS Problem via Conflicting Graph
The PPS problem considered in this work, mainly have two types of constraints, the sequencing constraints and the incompatible recourse constraints. The former ensures the best practice operation sequence for each part, and the latter ensures no resource conflict for operations scheduled in parallel. Since the operation sequence of the parts is usually predefined, the PPS problem can be considered as selecting the best set of feasible operations that can be processed in parallel during every discrete time period (a time slot). The feasible operations refer to operations that can be scheduled for the current time period without resource and precedence conflicts. Usually, there is more than one set of feasible operations can be selected for the current time period. The best set of feasible operations is that by scheduling the set of feasible operations for the current time period, the global optimization objective, minimizing the makespan, is most likely to be achieved. If we consider each operation-resource pair (the operation along with one combination of the required resources during a unit discrete time period) as a node, and apply the edges to represent the constraints, a conflicting graph can be generated for the PPS problem. Furthermore, with a weight factor assigned to each operation-resource node as the guidance for selecting the best set of feasible operations, solving the PPS problem becomes solving the MWIS problem for each unit discrete time period. The output of the PPS problem is a combination of the best sets of feasible operations of each unit discrete time period. In the following Sections 4, 5, and 6, we discuss how the conflicting graph is generated, how the weight factor is calculated and assigned, and how we get the optimal or near-optimal solution. The discussions are based on the example problem, as shown in Figure 2 and Table 1. Generating the Conflicting Graph Based on previous discussions, the PPS problem can be naturally represented as a conflicting graph. Then, the optimization is to find and schedule the best qualified M aximal I ndependent S et (MIS) for each time period, so that an optimal processing schedule can be constructed. In this section, we discuss how to construct the conflicting graph. There are two steps to construct the conflicting graph, Step 1, Operation Data Preparation, and Step 2, Generating the Conflicting Graph. Step 1. Operation Data Preparation Before we start to generate the conflicting graph, let us reformulate all operations of the parts that need to be produced. In this step, we need three types of information on the operations of the parts, they are (1) the best practice operation sequence, (2) the resource options of each operation, and (3) the processing time of each operation with each of its resource combinations. The top part of Figure 2 illustrates the best practice operation sequence of each part. And from Table 1, we understand machine candidates, tool candidates, and machining time associated with the machines, respectively. With this information, we can reformulate the operation information of the parts as Figure 8. As described in Figure 8, it can be interpreted as the four operations for Part π β π β π β π . Each operation of each part is corresponding to a detailed task unit. For instance, the first operation π is corresponding to the detailed task unit, ( T [(M , M ) and (T ,T ) ]40T [(M ) and (T ,T ) ]30 ) , which means that operation π can be processed with one of the two task options, π and π . The π and π here indicate that we can choose one of the options β π β or β π β for the operation π as the first operation (task) to produce part π has its detail resource information, T [(M , M ) and (T ,T ) ]40 . It means that for the task option π , it requires one of the machines among (M , M ) and one of the tools among (π , π ) . And the duration of task option π is 40 time units. Each operation with its resource selection needs a certain period of time to process; we can simplify the problem by fitting the processing time of an operation into a discrete number of time slots. For example, if an operation π π,π requires 35 time units to finish, and we define each time slot (1TS) stands for 10 time units. Therefore, the operation π π,π needs 4 time slots (4TS) to process. Based on this assumption, we can translate Figure 9 to Figure 10 with the simplified processing time (duration) information. Figure 8. Interpretation for Operation Data Preparation Figure 9. Reformatted Parts Information Since we want to use the node in the conflicting graph to represent a task with its resource instance, while choosing the best qualified MIS of nodes, tasks with different durations may cause unbalanced conflicting constraints. Because a long duration task only causes one conflicting count with another conflicting task. In order to capture all the possible constraints, as well as simplify the weight factor calculation and fulfill different weights factor assignment strategies, we want to ensure every node in the conflicting graph stands for one task with one combination instance of its required resources for one time slot. Based on the task information in Figure 10, we break down all tasks into single time slots. We name a task that is broken down in such a way as a Unit Task. For example, T [(M , M ) and (T ,T ) ]1ππ is a Unit Task, it can be marked as T , which means that it is the first Unit Task of option βaβ in part T , it requires one of the machines among Part π β π β π β π (T [(M , M ) and (T , T ) ]40T [(M ) and (T , T ) ]30 ) β (T [(M , M ) and (T , T ) ]40T [(M ) and (T , T ) ]30 ) β (T [(M , M ) and (T , T ) ]20T [(M ) and (T , T ) ]15 ) β ( T [(M ) and (T ) ]12T [(M , π ) and (T ) ]10T [(M ) and (T ) ]7.5 ) Part π β π β π ( T [(M ) and (T ) ]12T [(M ,π ) and (T ) ]10T [(M ) and (T ) ]7.5 ) β ( T [(M , M ) and (T ) ]20T [(M ) and (T ) ]15 ) β ( T [(M , M ) and (T ,T ,T ) ]18T [(M ) and (T ,T ,T ) ]13.5 ) Part π β π β π ( T [(M , M ) and (T ,T ) ]15T [(M ) and (T ,T ) ]11.25 ) β ( T [(M , M ) and (T ,T ) ]20T [(M ) and (T ,T ) ]15 ) β ( T [(M , M ) and (T ,T ) ]20T [(M ) and (T ,T ) ]15 ) Part π β π β π β π ( T [(M ) and (T ,T ) ]21T [(M ) and (T ,T ) ]18 ) β ( T [(M ) and (T ,T ) ]27T [(M ) and (T ,T ) ]25 ) β ( T [(M ) and (T ,T ) ]12T [(M ) and (T ,T ) ]15 ) β( T [(M ) and (T ) ]18T [(M ) and (T ) ]25 ) (M , M ) and one of the tools among (π , π ) . Based on the information from Figure 10, the transformed tasks information in Unit Tasks is shown in Figure 11. The information in Figure 11 can be formulated into a dictionary for the implementation of the proposed approach. The format is shown in Figure 12; there are 47 Unit Tasks after breaking up. In the next step, we discuss how we can generate the nodes and edges for generating the conflicting graph for the PPS problem. Figure 10. Tasks Information with Simplified Duration Information Part π β π β π β π (T [(M , M ) and (T , T ) ]4ππT [(M ) and (T , T ) ]3ππ ) β (T [(M , M ) and (T , T ) ]4ππT [(M ) and (T , T ) ]3ππ ) β (T [(M , M , M ) and (T , T ) ]2ππ ) β ( T [(M ) and (T ) ]2ππT [(M , M , M ) and (T ) ]1ππ ) Part π β π β π ( T [(M ) and (T ) ]2ππT [(M , M , M ) and (T ) ]1ππ ) β (T [(M , M , M ) and (T ) ]2ππ ) β (T [(M , M , M ) and (T , T , T ) ]2ππ ) Part π β π β π (T [(M , M , M ) and (T , T ) ]2ππ ) β (T [(M , M , M ) and (T , T ) ]2ππ ) β (T [(M , M , M ) and (T , T ) ]2ππ ) Part π β π β π β π (T [(M ) and (T , T ) ]3ππT [(M ) and (T , T ) ]2ππ ) β (T [(M , M ) and (T , T ) ]3ππ ) β (T [(M , M ) and (T , T ) ]2ππ ) β (T [(M ) and (T ) ]2ππT [(M ) and (T ) ]3ππ ) Figure 11. Transformed Tasks Information in Unit Tasks
Part π β π β π β π (T [(M , M ) and (T , T ) ]1ππ β T [(M , M ) and (T , T ) ]1ππ β T [(M , M ) and (T , T ) ]1ππ β T [(M , M ) and (T , T ) ]1ππT [(M ) and (T , T ) ]1ππ β T [(M ) and (T , T ) ]1ππ β T [(M ) and (T , T ) ]1ππ ) β (T [(M , M ) and (T , T ) ]1ππ β T [(M , M ) and (T , T ) ]1ππ β T [(M , M ) and (T , T ) ]1ππ β T [(M , M ) and (T , T ) ]1ππT [(M ) and (T , T ) ]1ππ β T [(M ) and (T , T ) ]1ππ β T [(M ) and (T , T ) ]1ππ ) β (T [(M , M , M ) and (T , T ) ]1ππ β T [(M , M , M ) and (T , T ) ]1ππ ) β (T [(M ) and (T ) ]1ππ β T [(M ) and (T ) ]1ππT [(M , M , M ) and (T ) ]1ππ ) Part π β π β π (T [(M ) and (T ) ]1ππ β T [(M ) and (T ) ]1ππT [(M , M , M ) and (T ) ]1ππ ) β (T [(M , M , M ) and (T ) ]1ππ β T [(M , M , M ) and (T ) ]1ππ ) β (T [(M , M , M ) and (T , T , T ) ]1ππ β T [(M , M , M ) and (T , T , T ) ]1ππ ) Part π β π β π (T [(M , M , M ) and (T , T ) ]1ππ β T [(M , M , M ) and (T , T ) ]1ππ ) β (T [(M , M , M ) and (T , T ) ]1ππ β T [(M , M , M ) and (T , T ) ]1ππ ) β (T [(M , M , M ) and (T , T ) ]1ππ β T [(M , M , M ) and (T , T ) ]1ππ ) Part π β π β π β π (T [(M ) and (T , T ) ]1ππ β T [(M ) and (T , T ) ]1ππ β T [(M ) and (T , T ) ]1ππT [(M ) and (T , T ) ]1ππ β T [(M ) and (T , T ) ]1ππ ) β (T [(M , M ) and (T , T ) ]1ππ β T [(M , M ) and (T , T ) ]1ππ β T [(M , M ) and (T , T ) ]1ππ ) β (T [(M , M ) and (T , T ) ]1ππ β T [(M , M ) and (T , T ) ]1ππ ) β ( T [(M ) and (T ) ]1ππ β T β 2[(M ) and (T ) ]1ππT [(M ) and (T ) ]1ππ β T [(M ) and (T ) ]1ππ β T [(M ) and (T ) ]1ππ ) Figure 12. Scheduling Problem Input Format Step 2. Generating Nodes and Edges of the Conflicting Graph A conflicting graph consists of two essentials, the nodes and edges. A node is representing one possible resource combination instance of a Unit Task. And the edges are representing the resource constraints of the instances of the Unit Tasks. Step 2.1 Generating the Nodes In order to explain how to generate nodes for the conflicting graph, let us take a Unit Task example from Figure 11, T , which is the first Unit Task in option βbβ of the first operation in part T [(M ) and (T ) ]1ππ , of this Unit Task, it can be represented by one node, because it only has one possible resource instance, machine π and tool π . On the same idea, all the nodes stand for all the possible resource instance of all the Unit Tasks can be generated for the conflicting graph. The node details of the example problem are shown in the first two columns in Figure 15. Step 2.2 Generating the Edges We developed the following four rules for generating edges in the conflicting graph. (1) For any two nodes from the same Unit Task, they are connected by an edge. It implies the constraint that for each Unit Task, it can only be scheduled once. (2)
For any two nodes from the same operation, if they belong to different task options, they are connected by an edge. It implies the constraint that for each operation, we can only schedule it with only one task option. (3)
For any two nodes from the same operation and the same task option, but different Unit Task, if their resources are not the same, they are connected by an edge. It implies the constraint that once an operation is started, the resources have been selected cannot be changed until it is finished. (4)
For the nodes from different parts, if any of their resources is the same, they are connected by an edge. It implies the resource constraints that one resource can be occupied by only one operation during the same time period. Besides the rules mentioned above, note that there are no edges between the nodes of two different operations for the same part because they cannot be scheduled in the same time slot, and the selection has no effect on each other. This situation is ensured by the weight assignment strategies, which are discussed in detail in the following sections. To better illustrate the rules for generating the edges of the conflicting graph, let us take the two operations π βπ ( π β π ) of Part π π,1 ( π π,1 ) of Part π , tasks details are shown as below: ( T [(M , M , M ) and (T ) ]1ππT [(M ) and (T ) ]1ππ β T [(M ) and (T ) ]1ππ ) β (T [(M , M , M ) and (T ) ]1ππ β T [(M , M , M ) and (T ) ]1ππ ) And (T π,1aβ1 [(M ) and (T ) ]1ππ ) A conflict graph can be constructed, as shown in Figure 13. The colors differentiate the Unit Tasks, and the numbers on edges indicate the rule used while generating the edges. T [(M , T ) ] T [(M , T ) ] T [(M , T ) ] T [(M , T ) ] (1) T [(M , T ) ]T [(M , T ) ]T [(M , T ) ] T [(M , T ) ]T [(M , T ) ]T [(M , T ) ] ( )( ) ( )( ) ( )( ) T [(M , T ) ] T i ,1a-1 [(M , T ) ] Figure 13. The Conflict Graph of operations π β π of Part π π,1 ( π π,1 ) of Part π With the same idea, a conflicting graph for all four parts in the example problem is constructed as Figure 14. The graph has 161 nodes and 4718 edges. The node labels and the connection details of the conflicting graph are shown in Figure 15. For example, the node β0β represents T (π , π ) , which is one of the resource selections of the Unit Task, T [(M , M ) and (T ,T ) ]1ππ . Note that the color clusters in Figure 15 are for differentiating different operations. With the conflicting graph ready, in the next section, we explain how we generate weights for Unit Tasks and how we assign weight factors to nodes so that the MWIS algorithms can be configured to schedule the nodes to achieve the objective of minimizing the makespan for the PPS problem. Figure 14. Conflict Graph for the Example Problem Figure 15. Graph Connection Details for the Example Problem Weight Factors Calculation and the Configurations of MWIS Algorithms
With the problem formulated as a conflicting graph, our goal is to find the nodes to schedule for each time slot towards the objective of minimizing the total number of required time slots to finish all the operations. The weight factors assigned to nodes in the conflicting graph are used as the guidance for task and resource selections towards the optimal solution of the PPS problem. From Figure 10, only the node from the first Unit Task of each option of each part can be scheduled for the current time slot. We name such a Unit Task as a Unit Task Candidate, and the nodes from Unit Task Candidates as Candidate Nodes. The simple idea is that we want to schedule as much as possible Unit Task Candidates at each time slot, and we want to ensure that these scheduled Unit Task Candidates have the most constraints for the rest of Unit Tasks. Because once a Unit Task is scheduled for the current time slot, it is removed from the graph of the following procedures. By doing so, we can remove as many as possible Candidate Nodes at each time slot, and if we can ensure that by removing those nodes, we can remove the most constraints for the remaining Unit Tasks. By discharging the most constraints at each time slot, we have more freedom to schedule more Unit Task Candidates in the following time slots. In this sense, we can achieve the optimal or near-optimal result of the PPS problem. In order to execute this idea, we developed heuristics to generate weights and configure these heuristics with MWIS algorithms proposed in our work (Sun et al., preprint). We are focusing on the weight calculation and the configurations with MWIS algorithms for the PPS problem in Section 5.
The Weights Calculation
From the edges generating rules, Candidate Nodes, which are not compatible due to constraints, are connected. In other words, they are not independent. By applying the MWIS algorithms, we can find the most weighted set of independent candidate nodes, which can be scheduled for the current time slot. We assume that the nodes belong to the same Unit Task should have the same weights. Then, the weight of a Unit Task can be determined based on the conflicting condition of this Unit Task among all Unit Tasks remaining. We can calculate the weights for all Unit Tasks remaining and configure the weight factors for Unit Tasks Candidates with different MWIS algorithms. We define two types of weight to describe the conflicting condition of a Unit Task. 1.
The Unit Task connection weight, π πππππππ‘πππ (π π,π‘ , π π β² ,π‘ β² ) The Unit Task length weight, π πππππ‘β (π π,π‘ ) Where the two Unit Tasks, π π,π‘ and π π β² ,π‘ β² , belong to two different parts, π π and π π β² . π β π β² , π‘ β [1, π‘ π_πππ₯ ] , π‘β² β[1, π‘β² πβ²_πππ₯ ] , π & πβ² β [1, π πππ₯ ] , where π‘ π_πππ₯ is the last Unit Task (the task with the greatest index) in part π π and π‘β² πβ²_πππ₯ is the last Unit Task in part π πβ² . π πππ₯ is the index of the last part (the part with the greatest index). The Unit Task connection weight, π πππππππ‘πππ (π π,π‘ , π π β² ,π‘ β² ) , is based on the connection rate between two Unit Tasks π π,π‘ and π π β² ,π‘ β² from different parts π π and π π β² . Being inspired by the graph density definition. Let π(π π,π‘ ) be a set of π(π π,π‘ ) number of nodes from the Unit Task π π,π‘ , and π(π π,π‘ , π π β² ,π‘ β² ) is the number of edges between set π(π π,π‘ ) and set π(π πβ²,π‘β² ) . Then, we have the Unit Task connection weights: π πππππππ‘πππ (π π,π‘ , π π β² ,π‘ β² ) = π(π π,π‘ , π π β² ,π‘ β² )π(π π,π‘ ) β π(π πβ²,π‘β² ) The Unit Task length weight, π πππππ‘β (π π,π‘ ) , is the length weight coefficient, πΏπ π , multiply by the number, π(π π,π‘ ) , of remaining time slots needed to finish part π π . Where we have: π πππππ‘β (π π,π‘ ) = πΏπ π β π(π π,π‘ ) Note that the length weight coefficient, πΏπ π , is used to describe the level priority given to a Unit Task based on the number of time slots remaining for finishing the part individually. Based on our testing, we define three levels of length weight coefficient, median, high and low, as πΏπ ππ , πΏπ ππ» and πΏπ ππΏ respectively. And they are defined as follows: β’ Let πΏπ ππ = 1 , to keep the length weight coefficient in the same scale as the Unit Task connection weight. In this case, the resource constraints and sequencing constraints are considered as equal while selecting nodes. β’ Let πΏπ ππ» = π πππ₯ + β π(π π,1 ) π=π πππ₯ π=1 , which is the total number of time slots of all the parts, to ensure the parts need more remaining time slots are given priority. β’ πΏπ ππΏ = 0.01 , to keep the length weight coefficient a minimum effect on node selection. In this case, the resource constraints are more emphasized compare to the sequencing constraints while selecting nodes. The total weight, π π‘ππ‘ππ (π π,π‘ ) , of the nodes of a Unit Task, π π,π‘ , is the sum of the Unit Task connection weight between itself and all other Unit Tasks of different parts, plus the Unit Task length weight. Formally, π π‘ππ‘ππ (π π,π‘ ) = π πππππ‘β (π π,π‘ ) + β π πππππππ‘πππ (π π,π‘ , π π β² ,π‘ β² ) π β² =π πππ₯ ,π‘ β² =π‘ π_πππ₯ π β² =1,π‘ β² =1 Note that the total weight, π π‘ππ‘ππ (π π,π‘ ) , as the initial weight value, its purpose is to describe the conflicts that a Unit Task can possibly cause in a PPS problem. The final weight factors need to be configured with the MWIS algorithms for solving the PPS problem. An instance of the weights of the example problem can be calculated as Table 3 below. Each column describes the part ID, operation ID, Unit Tasks, nodes, and the value of the initial weights, respectively. Note that in Table 3, we choose to use the high length weight coefficient, πΏπ ππ» = 32 . Table 3. Unit Tasks and Nodes
Part-ID Op-ID Unit Tasks Nodes Initial Weights Part 1 O T
0, 1, 2, 3 157.097 T
4, 5, 6, 7 141.097 T
8, 9, 10, 11 125.097 T
12, 13, 14, 15 117.097 T
16, 17 154.722 T
18, 19 138.722 T
20, 21 122.722 O T
22, 23, 24, 25 101.097 T
26, 27, 28, 29 85.097 T
30, 31, 32, 33 69.097 T
34, 35, 36, 37 61.097 T
38, 39 98.722 T
40, 41 82.722 T
42, 43 66.722 O T
44, 45, 46, 47, 48, 49 88.611 T
50, 51, 52, 53, 54, 55 56.611 O T
56 8.5 T
57 0.5 T
58, 59, 60 11.417
Part 2 O T
61, 62, 63 76.750 T
64 73.25 T
65 65.25 O T
66, 67, 68 104.499 T
69, 70, 71 72.499 O T
72, 73, 74, 75, 76, 77, 78, 79, 80 43.389 T
81, 82, 83, 84, 85, 86, 87, 88, 89 11.389
Part 3 O T
90, 91, 92, 93, 94, 95 169.722 T
96, 97, 98, 99, 100, 101 137.722 O T T O T T Part 4 O T T T T T O T T T O T T O T
156 27.167 T
157 11.167 T
158 3.167 T
159 27.168 T
160 11.167
Weight Factor Arrangements with MWIS Algorithms
We have calculated the weight factors for the Unit Tasks, and now we explain how to finalize the weight factors with the MWIS algorithms. We developed three weight factor arrangements for the MWIS-based algorithms and seven weight factor arrangements for the AMISL-based algorithms. The weight factor arrangements, together with the MWIS algorithms, make twenty-eight different heuristics configurations for solving the PPS problem. Before we start to talk about the weight factor arrangements, let us first recall the eight MWIS algorithms from our work (Sun et al., preprint). These algorithms are: β’ Algorithm A1 MWIS: the proposed exact MWIS algorithm. β’ Algorithm A2 AMISL: the proposed exact AMISL-based MWIS algorithm. β’ Algorithm A3 GWMIN: the GWMIN approximation algorithm from literature. β’ Algorithm A4 MWIS_CS_GWMIN: it is an algorithm composed of Algorithm A1 and Algorithm A3. This algorithm computes Compare Sets based on the whole induced subgraph at each level using Algorithm A3 GWMIN. β’ Algorithm A5 MWIS_SubCS_GWMIN: it is an algorithm composed of Algorithm A1 and Algorithm A3. This algorithm computes Compare Sets based on the induced CSSs, excluding the current removed node, using Algorithm A3 GWMIN. β’ Algorithm A6 GWMIN2: the GWMIN2 approximation algorithm from literature. β’ Algorithm A7 MWIS_CS_GWMIN2: it is an algorithm composed of Algorithm A1 and Algorithm A6. This algorithm computes Compare Sets based on the whole induced subgraph at each level using Algorithm A6 GWMIN2. β’ Algorithm A8 MWIS_SubCS_GWMIN2: it is an algorithm composed of Algorithm A1 and Algorithm A6. This algorithm computes Compare Sets based on the induced CSSs, excluding the current removed node, using Algorithm A6 GWMIN2. The algorithms list above except Algorithm A2 AMISL are MWIS-based algorithms; they require the weights of all nodes to be positive ( β₯ 0 ) to make valid comparations in steps so that the final MWIS can be calculated. In this case, the flexibility of weight arrangements is limited, but this is easy to apply approximation strategies to reduce the complexity to speed up the computation. However, Algorithm A2 AMISL first look for all the M aximal I ndependent S ets (MIS), then get the set with the maximum total weight. In this case, the negative and zero weights are allowed. But Algorithm A2 AMISL may have an unreasonable complexity when there is a large number of large size MISs. Algorithm A2 AMISL is also hard to applied approximation strategies. The details of the three weight factor arrangements for the MWIS based algorithms and the seven weight factor arrangements for the AMISL based MWIS algorithms are discussed below. The idea is that while searching for the nodes for the current time slot, the Unit Tasks that can only be scheduled a good number of time slots later may have limited impact. Based on this idea, the wright factor arrangements are created by only checking different limited numbers of steps ahead and aiming to find the best set of the nodes for the current time slot to achieve the objective of minimizing the makespan. (1) The weight factor arrangements for MWIS based algorithms For the MWIS based algorithms, we assign weight factors to the Candidate Nodes of Unit Task Candidates according to the three arrangements described below. Then, a small positive value (for instance, 0.0000001) is assigned to the non-candidate nodes. With the weight factors ready, we can apply one of the seven MWIS-based algorithms to find the set of Candidate Nodes with the maximum total weight with the maximum number of nodes. For this setup, the Candidate Nodes associated with the most uncommon resources for the non-candidate nodes are scheduled for the current time slot. So that there are fewer conflicts for the following time slots if the operations scheduled for the current time slot must be continued for more time slots. The Unit Tasks Candidates with the associated resources represented by the set of nodes are scheduled for the current time slot. The three weight factor arrangements are as follows: (1.1) MWIS A1: MWIS Weights 1 In each time slot, for each π β [1, π πππ₯ ] , assign weight factors to the Unit Task Candidates, π π,π‘ πππ πΆ , which is the first Unit Task, π π,π‘ πππ , that can be scheduled for part π π . The value of weight factors of the candidate nodes in π π,π‘ πππ πΆ is the weight of π π,π‘ πππ , as the equation below, π πππΌπ_π΄1_ππππππππ‘π (π π,π‘ πππ πΆ ) = π π‘ππ‘ππ (π π,π‘ πππ ) (1.2) MWIS A2: MWIS Weights 2 In each time slot, for each π β [1, π πππ₯ ] , assign weight factors to the Unit Task Candidates, π π,π‘ πππ πΆ . The value of weight factors of the Candidate Nodes in π π,π‘ πππ πΆ is the sum of the weights of π π,π‘ πππ and π π,( π‘ πππ +1) , where π π,( π‘ πππ +1) is the following Unit Task of π π,π‘ πππ , as the equation below, π πππΌπ_π΄2_ππππππππ‘π (π π,π‘ πππ πΆ ) = π π‘ππ‘ππ (π π,π‘ πππ ) + π π‘ππ‘ππ (π π,π‘ πππ +1 ) (1.3) MWIS A3: MWIS Weights 3 In each time slot, for each π β [1, π πππ₯ ] , assign weight factors to the Unit Task Candidates, π π,π‘ πππ πΆ . The value of weight factors of the Candidate Nodes in π π,π‘ πππ πΆ is the sum of the weights of π π,π‘ πππ , π π,( π‘ πππ +1) and π π,( π‘ πππ +2) , where π π,( π‘ πππ +2) is the following Unit Task of π π,( π‘ πππ +1) , as the equation below, π πππΌπ_π΄3_ππππππππ‘π (π π,π‘ πππ πΆ ) = π π‘ππ‘ππ (π π,π‘ πππ ) + π π‘ππ‘ππ (π π,π‘ πππ +1 ) + π π‘ππ‘ππ (π π,π‘ πππ +2 ) (2) The weight factor arrangements for Algorithm A2 AMISL For the AMISL based algorithms, we assign weight factors to the nodes indicated by the seven different weight factor arrangements described below. Then, a small negative value (for instance, -0.0000001) is assigned to the unaddressed nodes. With the weight factors ready, applied Algorithm A2 AMISL to find the set of Candidate Nodes with the maximum total weight with the minimum number of nodes. For this setup, the Candidate Nodes associated with the most common resources for the unaddressed nodes are scheduled for the current time slot, so that the most constraints are removed for the following time slots by scheduling such a set of Candidate Nodes. The Unit Tasks Candidates with the associated resources represented by the set of nodes are scheduled for the current time slot. The seven weight factor arrangements are as follows: (2.1)
AMISL A1: AMISL Weights 1 In each time slot, for each π β [1, π πππ₯ ] , assign weight factors to the Unit Task Candidates, π π,π‘ πππ πΆ . The value of weight factors of the Candidate Nodes in π π,π‘ πππ πΆ is the weight of π π,π‘ πππ , as the equation below, π π΄ππΌππΏ_π΄1_ππππππππ‘π (π π,π‘ πππ πΆ ) = π π‘ππ‘ππ (π π,π‘ πππ ) (2.2) AMISL A2: AMISL Weights 2 Aggregation In each time slot, for each π β [1, π πππ₯ ] , assign weight factors to the Unit Task Candidates, π π,π‘ πππ πΆ . The value of weight factors of the Candidate Nodes in π π,π‘ πππ πΆ is the sum of the weights of π π,π‘ πππ and π π,( π‘ πππ +1) , where π π,( π‘ πππ +1) is the following Unit Task of π π,π‘ πππ , as the equation below, π π΄ππΌππΏ_π΄2_ππππππππ‘π (π π,π‘ πππ πΆ ) = π π‘ππ‘ππ (π π,π‘ πππ ) + π π‘ππ‘ππ (π π,π‘ πππ +1 ) (2.3) AMISL A3: AMISL Weights 2 Aggregation + Non-aggregation In each time slot, for each π β [1, π πππ₯ ] , assign weight factors to the Unit Task Candidates, π π,π‘ πππ πΆ , and the following Unit Task, π π,( π‘ πππ +1) . The value of weight factors of the Candidate Nodes in π π,π‘ πππ πΆ is the sum of the weights of π π,π‘ πππ and π π,( π‘ πππ +1) , as the equation below, π π΄ππΌππΏ_π΄3_ππππππππ‘π (π π,π‘ πππ πΆ ) = π π‘ππ‘ππ (π π,π‘ πππ ) + π π‘ππ‘ππ (π π,π‘ πππ +1 ) The value of weight factors of nodes in π π,π‘ πππ +1 is the weight of π π,π‘ πππ +1 , as the equation below, π π΄ππΌππΏ_π΄3_ππππππ€πππ (π π,π‘ πππ +1 ) = π π‘ππ‘ππ (π π,π‘ πππ +1 ) (2.4) AMISL A4: AMISL Weights 2 Non-aggregation In each time slot, for each π β [1, π πππ₯ ] , assign weight factors to the Unit Task Candidates, π π,π‘ πππ πΆ , and the following Unit Task, π π,( π‘ πππ +1) . The value of weight factors of the Candidate Nodes in π π,π‘ πππ πΆ is the weight of π π,π‘ πππ , as the equation below, π π΄ππΌππΏ_π΄4_ππππππππ‘π (π π,π‘ πππ πΆ ) = π π‘ππ‘ππ (π π,π‘ πππ ) The value of weight factors of nodes in π π,π‘ πππ +1 is the weight of π π,π‘ πππ +1 , as the equation below, π π΄ππΌππΏ_π΄4_ππππππ€πππ (π π,π‘ πππ +1 ) = π π‘ππ‘ππ (π π,π‘ πππ +1 ) (2.5) AMISL A5: AMISL Weights 3 Aggregation In each time slot, for each π β [1, π πππ₯ ] , assign weight factors to the Unit Task Candidates, π π,π‘ πππ πΆ . The value of weight factors of the Candidate Nodes in π π,π‘ πππ πΆ is the sum of the weights of π π,π‘ πππ , π π,( π‘ πππ +1) and π π,( π‘ πππ +2) , as the equation below, π π΄ππΌππΏ_π΄5_ππππππππ‘π (π π,π‘ πππ πΆ ) = π π‘ππ‘ππ (π π,π‘ πππ ) + π π‘ππ‘ππ (π π,π‘ πππ +1 ) + π π‘ππ‘ππ (π π,π‘ πππ +2 ) (2.6) AMISL A6: AMISL Weights 3 Aggregation + Non-aggregation In each time slot, for each π β [1, π πππ₯ ] , assign weight factors to the Unit Task Candidates, π π,π‘ πππ πΆ , and the two following Unit Tasks, π π,( π‘ πππ +1) and π π,( π‘ πππ +2) . The value of weight factors of the Candidate Nodes in π π,π‘ πππ πΆ is the sum of the weights of π π,π‘ πππ , π π,( π‘ πππ +1) and π π,( π‘ πππ +2) , as the equation below, π πππΌπ_π΄6_ππππππππ‘π (π π,π‘ πππ πΆ ) = π π‘ππ‘ππ (π π,π‘ πππ ) + π π‘ππ‘ππ (π π,π‘ πππ +1 ) + π π‘ππ‘ππ (π π,π‘ πππ +2 ) The value of weight factors of nodes in π π,π‘ πππ +1 is the weight of π π,π‘ πππ +1 , as the equation below, π π΄ππΌππΏ_π΄6_ππππππ€πππ (π π,π‘ πππ +1 ) = π π‘ππ‘ππ (π π,π‘ πππ +1 ) The value of weight factors of nodes in π π,π‘ πππ +2 is the weight of π π,π‘ πππ +2 , as the equation below, π π΄ππΌππΏ_π΄6_ππππππ€πππ_π‘π€π (π π,π‘ πππ +2 ) = π π‘ππ‘ππ (π π,π‘ πππ +2 ) (2.7) AMISL A7: AMISL Weights 3 Non-aggregation In each time slot, for each π β [1, π πππ₯ ] , assign weight factors to the Unit Task Candidates, π π,π‘ πππ πΆ , and the two following Unit Tasks, π π,( π‘ πππ +1) and π π,( π‘ πππ +2) . The value of weight factors of the Candidate Nodes in π π,π‘ πππ πΆ is the weights of π π,π‘ πππ , as the equation below, π πππΌπ_π΄7_ππππππππ‘π (π π,π‘ πππ πΆ ) = π π‘ππ‘ππ (π π,π‘ πππ ) The value of weight factors of nodes in π π,π‘ πππ +1 is the weight of π π,π‘ πππ +1 , as the equation below, π π΄ππΌππΏ_π΄7_ππππππ€πππ (π π,π‘ πππ +1 ) = π π‘ππ‘ππ (π π,π‘ πππ +1 ) The value of weight factors of nodes in π π,π‘ πππ +2 is the weight of π π,π‘ πππ +2 , as the equation below, π π΄ππΌππΏ_π΄7_ππππππ€πππ_π‘π€π (π π,π‘ πππ +2 ) = π π‘ππ‘ππ (π π,π‘ πππ +2 ) Heuristics Configurations
The eight MWIS algorithms, together with the ten weight arrangements, can be configured into twenty-eight heuristics configurations for solving the PPS problem. The heuristics configurations are shown in Table 4. Each column describes the heuristics configuration ID, algorithm ID, weight arrangement strategies, whether it is an MWIS-based algorithm and whether it is an approximation algorithm, respectively.
Table 4. Heuristics Configurations
Heuristics-ID Algorithm-ID Weight arrangement strategies MWIS based? Appr? 1
A1 MWIS MWIS A1: MWIS Weights 1 Yes No A1 MWIS MWIS A2: MWIS Weights 2 Yes No A1 MWIS MWIS A3: MWIS Weights 3 Yes No A2 AMISL AMISL A1: AMISL Weights 1 No No A2 AMISL AMISL A2: AMISL Weights 2 Agg No No A2 AMISL AMISL A3: AMISL Weights 2 Agg + Nagg No No A2 AMISL AMISL A4: AMISL Weights 2 Nagg No No A2 AMISL AMISL A5: AMISL Weights 3 Agg No No A2 AMISL AMISL A6: AMISL Weights 3 Agg + Nagg No No A2 AMISL AMISL A7: AMISL Weights 3 Nagg No No A3 GWMIN MWIS A1: MWIS Weights 1 Yes Yes A4 MWIS_CS_GWMIN MWIS A1: MWIS Weights 1 Yes Yes A5 MWIS_SubCS_GWMIN MWIS A1: MWIS Weights 1 Yes Yes A3 GWMIN MWIS A2: MWIS Weights 2 Yes Yes A4 MWIS_CS_GWMIN MWIS A2: MWIS Weights 2 Yes Yes A5 MWIS_SubCS_GWMIN MWIS A2: MWIS Weights 2 Yes Yes A3 GWMIN MWIS A3: MWIS Weights 3 Yes Yes A4 MWIS_CS_GWMIN MWIS A3: MWIS Weights 3 Yes Yes A5 MWIS_SubCS_GWMIN MWIS A3: MWIS Weights 3 Yes Yes A6 GWMIN2 MWIS A1: MWIS Weights 1 Yes Yes A7 MWIS_CS_GWMIN2 MWIS A1: MWIS Weights 1 Yes Yes A8 MWIS_SubCS_GWMIN2 MWIS A1: MWIS Weights 1 Yes Yes A6 GWMIN2 MWIS A2: MWIS Weights 2 Yes Yes A7 MWIS_CS_GWMIN2 MWIS A2: MWIS Weights 2 Yes Yes A8 MWIS_SubCS_GWMIN2 MWIS A2: MWIS Weights 2 Yes Yes A6 GWMIN2 MWIS A3: MWIS Weights 3 Yes Yes A7 MWIS_CS_GWMIN2 MWIS A3: MWIS Weights 3 Yes Yes A8 MWIS_SubCS_GWMIN2 MWIS A3: MWIS Weights 3 Yes Yes Solving the Example Problem via the Proposed Approach
In this section, we summarize the proposed method for solving the PPS problem with the example PPS problem, as shown in Figure 2 and Table 1. The major steps of the proposed approach are described below: Step πΏπ ππ» , which πΏπ ππ» = 32 for the example problem. The final weight factors at the first time slot for the Unit Task Candidates and Candidate Nodes of the example problem are shown in Table 5. Each column describes the part ID, operation ID, Unit Tasks, nodes of the Unit Tasks and the Final weight factors, respectively. The MWIS found by Heuristics T [(M ) and (T ) ] , T [(M ) and (T ) ] , T [(M ) and (T ) ] and T [(M ) and (T ) ] , are scheduled for the current time slot. Step shown as Figure 17 and Figure 18, respectively. Table 5. Final Weight Factors Unit Task Candidates and Candidate Nodes via Heuristics
Part-ID Op-ID Unit Tasks Nodes Final Weights Part 1 O T
0, 1, 2, 3 157.097 T
4, 5, 6, 7 141.097 T
8, 9, 10, 11 125.097 T
12, 13, 14, 15 117.097 T
16, 17 154.722 T
18, 19 138.722 T
20, 21 122.722
Part 2 O T
61, 62, 63 76.750 T
64 73.25 T
65 65.25
Part 3 O T
90, 91, 92, 93, 94, 95 169.722 T
96, 97, 98, 99, 100, 101 137.722
Part 4 O T T T T T Step Figure 16. Updated Remaining Tasks Information for the Following Time Slot
Job π β π β π β π (T [(M , M ) and (T , T ) ]1ππ β T [(M , M ) and (T , T ) ]1ππ β T [(M , M ) and (T , T ) ]1ππ ) β (T [(M , M ) and (T , T ) ]1ππ β T [(M , M ) and (T , T ) ]1ππ β T [(M , M ) and (T , T ) ]1ππ β T [(M , M ) and (T , T ) ]1ππT [(M ) and (T , T ) ]1ππ β T [(M ) and (T , T ) ]1ππ β T [(M ) and (T , T ) ]1ππ ) β (T [(M , M , M ) and (T , T ) ]1ππ β T [(M , M , M ) and (T , T ) ]1ππ ) β (T [(M ) and (T ) ]1ππ β T [(M ) and (T ) ]1ππT [(M , M , M ) and (T ) ]1ππ ) Job π β π β π (T [(M ) and (T ) ]1ππ ) β (T [(M , M , M ) and (T ) ]1ππ β T [(M , M , M ) and (T ) ]1ππ ) β (T [(M , M , M ) and (T , T , T ) ]1ππ β T [(M , M , M ) and (T , T , T ) ]1ππ ) Job π β π β π (T [(M , M , M ) and (T , T ) ]1ππ ) β (T [(M , M , M ) and (T , T ) ]1ππ β T [(M , M , M ) and (T , T ) ]1ππ ) β (T [(M , M , M ) and (T , T ) ]1ππ β T [(M , M , M ) and (T , T ) ]1ππ ) Job π β π β π β π (T [(M ) and (T , T ) ]1ππ ) β (T [(M , M ) and (T , T ) ]1ππ β T [(M , M ) and (T , T ) ]1ππ β T [(M , M ) and (T , T ) ]1ππ ) β (T [(M , M ) and (T , T ) ]1ππ β T [(M , M ) and (T , T ) ]1ππ ) β ( T [(M ) and (T ) ]1ππ β T β 2[(M ) and (T ) ]1ππT [(M ) and (T ) ]1ππ β T [(M ) and (T ) ]1ππ β T [(M ) and (T ) ]1ππ ) Figure 17. Updated Remaining Conflicting Graph for the Following Time Slot Figure 18. Updated Remaining Edge Connection Details for the Following Time Slot Figure 19. Schedule Created with Heuristics
Part O O O O O O O O O O O O O O Part
Part
Part
T9T10
T11T12
T8T7T6
T5T3
T2T1 : 4TS O : 2TSO : 2TS O : 2TS O : 2TSO : 3TS O : 4TSO : 2TS O : 2TSO : 2TS O : 2TS O : 2TS O : 2TS O : M1M2
M3M4 O : 2TSO : 4TS O : 2TSO : 2TS O : 2TSO : 2TSO : 2TS O : 3TS O : 2TS O : 2TS O : 2TS2TS : 4TS O : 2TS O : Table 6. Outputs of the Heuristics Configurations on the Example PPS Problem
Methods Minimum makespan (in time slots) Clock time, 3-run average Is approx? Error Error rate Heuristics
11 11768.55 No 1 10%
Heuristics
11 14392.62 No 1 10%
Heuristics
11 13370.07 No 1 10%
Heuristics
11 13344.73 No 1 10%
Heuristics
11 10904.36 No 1 10%
Heuristics
11 12042.11 No 1 10%
Heuristics
14 11942.88 No 4 40%
Heuristics
11 10178.87 No 1 10%
Heuristics
11 10496.09 No 1 10%
Heuristics
11 10833.84 No 1 10%
Heuristics
12 8.75 Yes 2 20%
Heuristics
11 38.73 Yes 1 10%
Heuristics
11 26.02 Yes 1 10%
Heuristics
11 9.23 Yes 1 10%
Heuristics
11 39.22 Yes 1 10%
Heuristics
11 28.09 Yes 1 10%
Heuristics
11 9.16 Yes 1 10%
Heuristics
11 37.66 Yes 1 10%
Heuristics
11 26.74 Yes 1 10%
Heuristics
14 9.99 Yes 4 40%
Heuristics
11 43.34 Yes 1 10%
Heuristics
11 27.02 Yes 1 10%
Heuristics
14 9.78 Yes 4 40%
Heuristics
11 41.62 Yes 1 10%
Heuristics
11 27.59 Yes 1 10%
Heuristics
14 9.91 Yes 4 40%
Heuristics
11 40.42 Yes 1 10%
Heuristics
11 28.64 Yes 1 10% A Real-world Example Using the Proposed Approach
Based on the case study from Zhang et al.βs work (Zhang et al., 2014) and combined with the details from Zhang et al.βs references (Chu & Gadh, 1996; Zhang et al., 2003; Li et al., 2005; Li & McMahon, 2007), we constructed a real-world PPS problem to verify our approach. The resources, machines, and cutting tools of a specific job shop are defined in Table 7. The four parts of the problem are shown in Figure 20. The relevant technical specifications of the four parts are defined in Tables 8 to 11.
Table 7. The Resource of a Job Shop β Machines and Tools Types No. Machines
Drilling press M Three-axis vertical milling machine I M Three-axis vertical milling machine II M CNC three-axis vertical milling machine M Boring machine M Cutting tools
Drill 1 T Drill 2 T Drill 3 T Drill 4 T Tapping tool T Mill 1 T Mill 2 T Mill 3 T Reaming tool T Boring tool T Slot cutter T Chamfer tool T Figure 20. The description of 4 parts of PPS
Table 8. The Technical Specifications for Part
Features Operations Machine Candidates Tool Candidates Machining time for each candidate machine (s) F1
Milling (Oper1) M , M , M T , T , T
40, 40, 30 F2 Milling (Oper2) M , M , M T , T , T
40, 40, 30 F3 Milling (Oper3) M , M , M T , T , T
20, 20, 15 F4 Drilling (Oper4) M , M , M , M T
12, 10, 10, 7.5
Part 4 F5 Milling (Oper5) M , M , M T , T
35, 35, 26.25 F6 Milling (Oper6) M , M , M T , T
15, 15, 11.25 F7 Milling (Oper7) M , M , M T , T
30, 30, 22.5 F8 Milling (Oper8) M , M , M , M T , T , T Reaming (Oper9) M , M , M T
10, 10, 7.5
Boring (Oper10) M , M , M , M T
10, 10, 7.5, 12 F9 Milling (Oper11) M , M , M T , T
15, 15, 11.25
F10
Drilling (Oper12) M , M , M , M T , T , T
48, 40, 40, 30
Reaming (Oper13) M , M , M T
25, 25, 18.75
Boring (Oper14) M , M , M , M T
25, 25, 18.75, 30
F11
Milling (Oper15) M , M , M , M T Tapping (Oper16) M , M , M T
20, 20, 15
F12
Milling (Oper17) M , M , M T , T
16, 16, 12
F13
Milling (Oper18) M , M , M T , T
35, 35, 26.25
F14
Reaming (Oper19) M , M , M T
12, 12, 9
Boring (Oper20) M , M , M , M T
12, 12, 9, 14.4
Table 9. The Technical Specifications for Part
Features Operations Machine Candidates Tool Candidates Machining time for each candidate machine (s) F1
Drilling (Oper1) M , M , M , M T
12, 10, 10, 7.5 F2 Milling (Oper2) M , M , M T
20, 20, 15 F3 Milling (Oper3) M , M , M T , T , T
18, 18, 13.5 F4 Milling (Oper4) M , M , M T , T , T
16, 16, 12 F5 Milling (Oper5) M , M , M T , T , T
15, 15, 11.25 F6 Drilling (Oper6) M , M , M , M T
30, 25, 25, 18.75
Reaming (Oper7) M , M , M T
25, 25, 18.75 F7 Drilling (Oper8) M , M , M , M T F8 Milling (Oper9) M , M , M T , T , T
15, 15, 11.25 F9 Drilling (Oper10) M , M , M , M T F10
Milling (Oper11) M , M , M T , T , T
10, 10, 7.5
F11
Milling (Oper12) M , M , M T , T , T
10, 10, 7.5
F12
Drilling (Oper13) M , M , M , M T F13
Milling (Oper14) M , M , M T , T , T
16, 16, 12
F14
Drilling (Oper15) M , M , M , M T F15
Milling (Oper16) M , M , M , M T , T , T
36, 30, 30, 22.5
Table 10. The Technical Specifications for Part
Features Operations Machine Candidates Tool Candidates Machining time for each candidate machine (s) F1
Milling (Oper1) M , M , M T , T , T
20, 15, 20 F2 Milling (Oper2) M , M , M T , T , T
20, 15, 20 F3 Milling (Oper3) M , M , M T , T , T
15, 15, 11.25 F4 Milling (Oper4) M , M , M , M T
15, 15, 11.25, 18 F5 Milling (Oper5) M , M , M T , T , T
15, 15, 11.25 F6 Milling (Oper6) M , M , M T , T
15, 15, 11.25 F7 Milling (Oper7) M , M , M T , T , T
15, 15, 11.25 F8 Milling (Oper8) M , M , M T , T , T , T
25, 25, 18.75 F9 Drilling (Oper9) M , M , M , M T , T , T
30, 25, 25, 18.75
Reaming (Oper10) M , M , M T
20, 20, 15
Boring (Oper11) M , M , M , M T
20, 20, 15, 24
F10
Drilling (Oper12) M , M , M , M T Tapping (Oper13) M , M , M T
8, 8, 6
F11
Drilling (Oper14) M , M , M , M T
6, 5, 5, 3.75 Table 11. The Technical Specifications for Part
Features Operations Machine Candidates Tool Candidates Machining time for each candidate machine (s) F1
Milling (Oper1) M , M T , T F2 Milling (Oper2) M , M T , T F3 Milling (Oper3) M , M T F4 Milling (Oper4) M , M T , T F5 Drilling (Oper5) M , M , M T F6 Milling (Oper6) M , M T , T F7 Drilling (Oper7) M , M , M T We define each time slot representing 15 time units. The top segment of Figure 22 illustrates the best practice operation sequence of the four parts. All the operations are then transformed into the input format. Figure 21 shows the transformed operations of Part πΏπ ππ = 1 . The schedule with the resource allocations generated is shown in Figure 22. Table 12 shows the outputs of Heuristics Table 12. Outputs of Heuristics on Real-world PPS Problem
Methods Length Weight Minimum makespan (in time slots) Clock time 3-run average (s) Error Error rate Heuristics
LW=86 37 2533.453125 6 19.35%
Heuristics
LW=86 33 9576.869792 2 6.45%
Heuristics
LW=1 32 7474.770833 1 3.23%
Heuristics
LW=86 33 2542.958333 2 6.45%
Heuristics
LW=86 32 8680.5 1 3.23%
Heuristics
LW=1 32 7131.817708 1 3.23%
Heuristics
LW=1 33 2498.739583 2 6.45%
Heuristics
LW=1 33 9011.416667 2 6.45%
Heuristics
LW=1 31 6256.010417 0 0.00% Heuristics
LW=1 53 6122.572917 22 70.97%
Heuristics
LW=1 36 23818.79167 5 16.13%
Heuristics
LW=86 32 10684.86458 1 3.23%
Heuristics
LW=0.001 52 4757.463542 21 67.74%
Heuristics
LW=1 33 21079.84375 2 6.45%
Heuristics
LW=86 35 9119.651042 4 12.90%
Heuristics
LW=1 58 4884.520833 27 87.10%
Heuristics
LW=0.001 35 19428.39583 4 12.90%
Heuristics
LW=86 32 8462.151042 1 3.23%
Figure 21. Transformed Operations of Part Figure 22. Schedule Created with Heuristics P a r t : O , O , O , O , O , O , O , O , O , O , O , O , O , O , P a r t : P a r t : P a r t : O , O , O , O , O , O , O , O , O , O , O , O , O , O , O , O , O , O , O , O , O , O , O , O , O , O , O , O , O , O , O , O , O , O , O , O , O , O , O , O , O , O , O , M M M M O , : T S O , : T S O , : T S O , : T S T S T S T S T S T S O , : T S T S T S T S T S T S T S T S T S T S T S T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S M O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S T T T T O , : T S O , : T S O , : T S O , : T S T S T S T S T S T S O , : T S T S T S T S T S T S T S T S T S T S T S T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S T O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S O , : T S T T T T T T T Table 13. Outputs of Heuristics on Real-world PPS Problem without Tool Constraints
Methods Length Weight Minimum makespan (in time slots) Clock time 3-run average (s) Error Error rate Heuristics
LW=86 37 147.2188 6 19.35%
Heuristics
LW=1 35 704.8594 4 12.90%
Heuristics
LW=86 33 521.4063 2 6.45%
Heuristics
LW=1 33 134.8698 2 6.45%
Heuristics
LW=1 32 671.2188 1 3.23%
Heuristics
LW=1 35 467.6979 4 12.90%
Heuristics
LW=1 34 124.8281 3 9.68%
Heuristics
LW=1 32 686.7813 1 3.23%
Heuristics
LW=1 34 449.1823 3 9.68%
Heuristics
LW=1 43 287.8906 12 38.71%
Heuristics
LW=0.001 35 1629.25 4 12.90%
Heuristics
LW=86 32 580.8958 1 3.23%
Heuristics
LW=1 43 293.9688 12 38.71%
Heuristics
LW=0.001 35 1671.74 4 12.90%
Heuristics
LW=1 31 591.6198 0 0.00%
Heuristics
LW=1 43 283.3698 12 38.71%
Heuristics
LW=1 36 1806.609 5 16.13%
Heuristics
LW=1 33 598.1563 2 6.45% Results and Discussions on Test Instances
We create nineteen test instances based on the structure of the real-world PPS example problem with randomized sequencing constraints and resource combinations. Since our approach returns feasible results on all the test instances and the real-world example, we assume that our approach has a satisfactory robustness on similar types of the PPS problem. Then, the discussion is focusing on the scalability and accuracy. The scalability analysis shows how the proposed approach behaves on different size and variance of the inputs. It can be evaluated based on the computation time versus the different input sizes, node numbers, and edge numbers of the different conflicting graphs. The accuracy refers to how likely the proposed approach can get to the optimum solution. It can be measured by the average and maximum error rate of all the test instances.
Scalability
The essential understanding of our approach to PPS problems, MWIS algorithms are the determinant of the computation speed of different heuristics configurations. For those heuristics configurations based on the same MWIS algorithm, the ones with more complex weight factor calculations are slower. But this difference is minimal. Figures 23 and 24 show how the computation time is changing with node number and edge number on Heuristics Figure 23. Computation Time with Node Number of Heuristics C l o c k T i m e ( s ) Node Number
Computation Time with Node Number of Heuristics
H1 H2 H3 H4 H5 H6H7 H8 H9 H10 Poly. (H1) Expon. (H1)Poly. (H2) Poly. (H3) Poly. (H4) Poly. (H5) Poly. (H6) Poly. (H7)Poly. (H8) Poly. (H9) Poly. (H10)02000400060008000100001200014000-200 300 800 1300 1800 2300 2800 3300 3800 4300 4800 C l o c k T i m e ( s ) Edge Number
Computation Time with Edge Number of Heuristics
H1 H2 H3 H4 H5 H6H7 H8 H9 H10 Poly. (H1) Expon. (H1)Poly. (H2) Poly. (H3) Poly. (H4) Poly. (H5) Poly. (H6) Poly. (H7)Poly. (H8) Poly. (H9) Poly. (H10) Figure 25. Computation Time with Node Number of Heuristics C l o c k T i m e ( s ) Node Number
Computation Time with Node Number of Heuristics
H11 H12 H13 H14 H15 H16H17 H18 H19 H20 H21 H22H23 H24 H25 H26 H27 H28Poly. (H11) Poly. (H12) Poly. (H13) Poly. (H20) Poly. (H21) Poly. (H22) Figure 26. Computation Time with Edge Number of Heuristics
Accuracy
Figure 27 shows the average and maximum error rate for all heuristics configurations. The detailed information of the Heuristics configurations is as Table 4. The detailed accuracy summary of all the heuristics configurations on all tests is in Appendix I. Assume ππ πππ‘πππ’π is the minimum number of time slots need for the PPS problem on the test instance, and ππ is the number of time slots found by our approach. The error rate is calculated using the function below. πΈππππ π ππ‘π = ππ β ππ πππ‘πππ’π ππ πππ‘πππ’π Γ 100% Note that the ππ πππ‘πππ’π is calculated based on the IP model with manipulating inputs to get the optimum result with reasonable computation time, and the error rate of each heuristics configuration is calculated based on the best accuracy among the three different length weight factors. Let the threshold for heuristics configuration selection be the average error of less than 7% and the maximum error of less than 20%. For Heuristics C l o c k T i m e ( s ) Edge Number
Computation Time With Edge Number of Hueristics
H11 H12 H13 H14 H15 H16H17 H18 H19 H20 H21 H22H23 H24 H25 H26 H27 H28Poly. (H11) Poly. (H12) Poly. (H13) Poly. (H20) Poly. (H21) Poly. (H22) approximation MWIS algorithms, from the best to the worst, Heuristics β’ Algorithm A1 MWIS
H2H8H16H5H19H3H28H25H15H4H18H14H17H1H13H24H12H22H6H11H9H27H10H21H7H23H20H26
ERROR RATE FOR ALL HEURISTICS
Heuristics Average ErrorHeuristics Max Error β’ Algorithm A2 AMISL (same as Algorithm MWIS) β’ Algorithm A5 MWIS_SubCS_GWMIN β’ Algorithm A8 MWIS_SubCS_GWMIN2 β’ Algorithm A4 MWIS_CS_GWMIN β’ Algorithm A3 GWMIN β’ Algorithm A7 MWIS_CS_GWMIN2 β’ Algorithm A6 GWMIN2 Compare with the results shown in Figure 27, with the same weight factors assignment, a more accurate MWIS algorithm leads to a better accuracy output of the PPS problem. None of the satisfactory heuristics is using the least accurate MWIS algorithms, Algorithm A7 MWIS_CS_GWMIN2 and A6 GWMIN2. In other words, while using the proposed approach for the PPS problem, a relatively accurate MWIS algorithm is required. This is the evidence of the necessity of the better accuracy MWIS algorithms proposed in our work (Sun et al., preprint). Figure 28. Details of Test Instances T24 The above-mentioned heuristics configurations may not able to reach the optimum results on some of the test instances. These bad instances are T6, T11, T12, T13, T14, T17, T18, T19, T20, and T24. Figure 29 shows the average and maximum error rate for all heuristics configurations on these bad instances. These instances have concentrated resource requirements. Let us take the instance T24 (Figure 28) as an example. The jobs in the instances have a significant difference in the number of time slots for finishing. Also, the beginning Unit Tasks are concentrated on the resources π , π , and π , and the ending Unit Tasks are concentrated on the resources π . Since the MWIS algorithm tries to schedule as many nodes as possible, it may cause the ending Unit Tasks all leftover, but they cannot be processed on parallel machines. We iterate the three levels of length weight coefficient, median, high and low, as πΏπ ππ , πΏπ ππ» and πΏπ ππΏ , respectively with the proposed heuristics configurations to balance the length of each job and the concentrated resources requirements. So that the maximum error rate of each satisfactory heuristics configuration is not exceeding 20%. Job T [(R ,R ,R ) ]2 β T [(R ,R ,R ) ]1 β T [(R ,R ,R ) ]2 β T [(R ) ]3 Job T [(R ,R ,R ) ]1 β T [(R ) and(R ,R ) ]2 β T [(R ) ]3 Job T [(R ,R ) ]1 β ( T [(R ,R ) ]1T [(R ) ]2 ) β T [(R ,R ) ]3 Job T [(R ,R ,R ) ]2 Job T [(R ,R ,R ) ]2 Figure 29. The Average and Maximum Error Rate on Bad Test Instances Another interesting finding is that the Heuristics
H14H15H18H16H17H25H2H8H19H28H5H6H24H3H12H4H11H9H10H13H22H27H1H21H7H23H20H26
ERROR RATE FOR BAD TEST INSTANCES
Heuristics Average ErrorHeuristics Max Error β’ Heuristics β’ Heuristics β’ Heuristics β’ Heuristics β’ Heuristics β’ Heuristics β’ Heuristics β’ Heuristics Conclusions
This paper considers a general type of PPS problem, and proposes a novel graph-based approach for formulating and solving the resource-constrained PPS optimization problem. Unlike the commonly used iteration type of approaches, such as generic algorithms and metaheuristics, or the mixed-integer programming approaches, our approach provides a different angle to address the PPS problem by enabling graph theory concepts and tools. It shows advantages over other approaches, as illustrated in Table 14. The PPS problem is formulated as a conflicting weighted graph, and the two procedures, the resource selection and process scheduling, of the PPS problem, are integrated. This idea extends the universality of the formulation of the graph coloring based scheduling. The new approach requires minimum iteration. And it is guaranteed to return a feasible solution due to the nature of solving the MWIS problem on a conflicting weighted graph. We develop different weight factor calculation strategies and arrangements as the guidance for achieving the optimization objective. With carefully defined weight factors and βgood-performanceβ MWIS algorithms, the new approach has satisfactory accuracy and computational speed. A set of βgood-performanceβ heuristics configurations are found based on test results. Figure 30 is the summary of the performance of the heuristics configurations. All these heuristics configurations considered as satisfactory have the average error of less than 7% and the maximum error of less than 20%.
Table 14. Comparing the New Approach with Other Methods*
Measurements Generic Algorithms Simulated Anneal Tabu Search Mixed-integer Programming Partial Solutions Graph Coloring Scheduling Accuracy = = = - + NA
Computational speed = = = + = NA
Universality - - = - NA +
Dependence on iterations + + + + + NA
Feasibility + + + = + NA
Separated solutions of each time slot + + + + + NA *β+β: The new approach is better on the measurement to compare with the other method. β=β: The new approach is similar or potentially better compare with the other method. β-β: The new approach is not as good as the other method. βNAβ: It is hard to compare the new approach with the other method. Figure 30. Performance of the Heuristics Configurations In the future work, we aim to improve the graph-based PPS problem formulation in the following three aspects: (1) To speed up the computation, (2) to improve the accuracy, and (3) to improve the universality. (1)
To speed up the computation: β’ For the MWIS algorithms, the NHHA framework (Sun et al., preprint) can be transformed into multi-threading. Each connected subgraph after node removal is independent so that the computation of each connected subgraph can be assigned to different threads. β’ For the formulation of the PPS problem, Unit Tasks of the operations that are constrained to be processed in the far future (a good number of time slots later) may have a very limited impact on the scheduling of earlier time slots. While generating the conflicting graph, we may only consider the most recent several Unit Tasks of each part so that the size of the conflicting graph can be reduced. (2)
To improve the accuracy: β’ The current weight calculation and weight factor arrangements can be fine-tuned and closely- integrated with the MWIS algorithms based on the part and resource information to achieve better node selections. The examples can be specific heuristics for weight calculation, machine learning methods to optimize the value of the weight factor. H i g h er E rr o r R a t e More Computation Time β’ Stochastic Optimization (SO) methods are optimization methods that generate and use random variables (Spall, 2003). This method can be applied to bring in probabilistic in the schedule generation process when solving the MWIS problem for each time slot. It enables the possibility of iteratively selecting different sets of nodes for each time slot. By applying this method, the trapping of bad node selections may be avoided. (3)
To improve the universality: β’ Our approach for the PPS problem can be easily implemented for a dynamic job taking environment by updating the conflicting graph for each time slot. The traditional approach requires taking consideration of known operations and iterates to get an optimum schedule for recent periods, which requires searching in a vast solution space. Unlike iteration-based approaches, the new approach computes the schedule of each time slot separately, which may only require partial operation information of each job. And for each time slot, the new approach tries to utilize the resources as much as possible by solving the MWIS problem. β’ Our approach for the PPS problem can be easily implemented with the flexible operation sequencing constraints by updating the conflicting graph for each time slot. In this case, all the Unit Tasks that are not restricted by the sequencing constraints are considered as Unit Task Candidates to be selected by solving the MWIS problem. The conflicting weighted graph may be extended to a multi-connected graph, directed graph, weighted edges to represent more information for the optimization problem modeling. We wish to improve the approach by, such as enabling the multi-objective optimization, introducing more variables for the details of the PPS problem, introducing probabilistic variables. And further, we are willing to extend this graph-based formulation technique to real-world applications such as logistics and transportation, supply-chain management, product design, development and manufacturing, and analysis and optimization of complex systems.
Appendix I: The PPS Test Results Summary on Accuracy
Test Accuracy Summary (different length weight coefficients) Heuristics Length Weight Error Sum Min Error Max Error Standard Deviation Average Error H1 LW median 146.79% 0.00% 30.00% 0.116101709 7.73% H1 LW high 66.79% 0.00% 14.29% 0.054035859 3.52% H1 LW low 379.65% 0.00% 50.00% 0.215917236 19.98% H2 LW median 116.79% 0.00% 20.00% 0.079669269 6.15% H2 LW high 96.79% 0.00% 20.00% 0.073307066 5.09% H2 LW low 425.39% 0.00% 60.00% 0.20627864 22.39% H3 LW median 82.34% 0.00% 14.29% 0.063872671 4.33% H3 LW high 96.79% 0.00% 20.00% 0.073307066 5.09% H3 LW low 337.89% 0.00% 50.00% 0.199032284 17.78% H4 LW median 132.67% 0.00% 30.00% 0.107201134 6.98% H4 LW high 72.67% 0.00% 14.29% 0.05359337 3.82% H4 LW low 377.15% 0.00% 60.00% 0.227042888 19.85% H5 LW median 132.67% 0.00% 20.00% 0.090325798 6.98% H5 LW high 92.67% 0.00% 20.00% 0.06424635 4.88% H5 LW low 467.89% 0.00% 60.00% 0.211785288 24.63% H6 LW median 239.09% 0.00% 28.57% 0.103530837 12.58% H6 LW high 157.31% 0.00% 28.57% 0.074081227 8.28% H6 LW low 503.60% 0.00% 60.00% 0.21305678 26.51% H7 LW median 274.65% 0.00% 40.00% 0.117823431 14.46% H7 LW high 264.65% 0.00% 40.00% 0.11744188 13.93% H7 LW low 423.74% 0.00% 60.00% 0.213851589 22.30% H8 LW median 72.67% 0.00% 14.29% 0.05359337 3.82% H8 LW high 92.67% 0.00% 20.00% 0.06424635 4.88% H8 LW low 266.55% 0.00% 50.00% 0.194635336 14.03% H9 LW median 168.06% 0.00% 28.57% 0.066280593 8.85% H9 LW high 157.31% 0.00% 28.57% 0.074081227 8.28% H9 LW low 453.60% 0.00% 50.00% 0.188410498 23.87% H10 LW median 238.06% 0.00% 28.57% 0.120058681 12.53% H10 LW high 177.15% 0.00% 28.57% 0.069662802 9.32% H10 LW low 487.89% 0.00% 60.00% 0.204165627 25.68% H11 LW median 275.40% 0.00% 40.00% 0.132007015 14.49% H11 LW high 201.21% 0.00% 36.36% 0.102077836 10.59% H11 LW low 371.62% 0.00% 42.86% 0.166448838 19.56% H12 LW median 219.18% 0.00% 40.00% 0.127558102 11.54% H12 LW high 144.00% 0.00% 18.18% 0.06672139 7.58% H12 LW low 393.70% 0.00% 42.86% 0.129630104 20.72% H13 LW median 194.71% 0.00% 42.86% 0.137130947 10.25% H13 LW high 89.69% 0.00% 14.29% 0.062333895 4.72% H13 LW low 325.46% 0.00% 50.00% 0.146692817 17.13% H14 LW median 209.92% 0.00% 30.00% 0.104197662 11.05% H14 LW high 151.82% 0.00% 30.00% 0.089640345 7.99% H14 LW low 319.95% 0.00% 40.00% 0.157068297 16.84% H15 LW median 205.23% 0.00% 40.00% 0.112344169 10.80% H15 LW high 114.64% 0.00% 18.18% 0.059177995 6.03% H15 LW low 418.39% 0.00% 50.00% 0.126877852 22.02% H16 LW median 146.14% 0.00% 20.00% 0.094973115 7.69% H16 LW high 106.14% 0.00% 20.00% 0.06475161 5.59% H16 LW low 423.45% 0.00% 50.00% 0.130585361 22.29% H17 LW median 192.74% 0.00% 30.00% 0.090580368 10.14% H17 LW high 147.55% 0.00% 18.18% 0.063333126 7.77% H17 LW low 233.49% 0.00% 30.00% 0.114784161 12.29% H18 LW median 161.10% 0.00% 40.00% 0.100517064 8.48% H18 LW high 132.16% 0.00% 28.57% 0.076243832 6.96% H18 LW low 340.30% 0.00% 40.00% 0.106109163 17.91% H19 LW median 104.92% 0.00% 14.29% 0.06548711 5.52% H19 LW high 125.82% 0.00% 20.00% 0.071838329 6.62% H19 LW low 347.65% 0.00% 50.00% 0.18967755 18.30% H20 LW median 534.04% 5.56% 70.97% 0.193136428 28.11% H20 LW high 567.68% 5.56% 80.65% 0.214868683 29.88% H20 LW low 553.39% 5.56% 80.65% 0.21783028 29.13% H21 LW median 242.68% 0.00% 30.00% 0.11708745 12.77% H21 LW high 184.85% 0.00% 20.00% 0.077665972 9.73% H21 LW low 365.80% 0.00% 30.00% 0.092706741 19.25% H22 LW median 277.62% 0.00% 50.00% 0.191346926 14.61% H22 LW high 99.69% 0.00% 14.29% 0.062348484 5.25% H22 LW low 375.14% 0.00% 50.00% 0.166974759 19.74% H23 LW median 580.58% 5.56% 87.10% 0.232079338 30.56% H23 LW high 580.58% 5.56% 87.10% 0.232079338 30.56% H23 LW low 518.50% 5.56% 67.74% 0.186594926 27.29% H24 LW median 201.95% 0.00% 22.58% 0.085814202 10.63% H24 LW high 159.04% 0.00% 20.00% 0.067677392 8.37% H24 LW low 353.30% 0.00% 30.00% 0.101758463 18.59% H25 LW median 162.59% 0.00% 20.00% 0.094948821 8.56% H25 LW high 142.27% 0.00% 20.00% 0.071557047 7.49% H25 LW low 408.11% 0.00% 50.00% 0.144216269 21.48% H26 LW median 580.58% 5.56% 87.10% 0.232079338 30.56% H26 LW high 580.58% 5.56% 87.10% 0.232079338 30.56% H26 LW low 571.49% 5.56% 87.10% 0.233725333 30.08% H27 LW median 233.95% 0.00% 30.00% 0.113169757 12.31% H27 LW high 219.46% 0.00% 28.57% 0.108478598 11.55% H27 LW low 325.79% 0.00% 30.00% 0.105947041 17.15% H28 LW median 128.47% 0.00% 14.29% 0.07665969 6.76% H28 LW high 149.69% 0.00% 20.00% 0.103908679 7.88% H28 LW low 360.55% 0.00% 50.00% 0.175904418 18.98%
References [1] [2]
Bloechliger, I. & Zufferey, N. (2013). Multi-coloring and Project-scheduling with Incompatibility and Assignment Costs. Annals of Operations Research, 211, 83-101. [3]
Case, K. & Wan Harun, W. A. (2000). Feature-based representation for manufacturing planning. International Journal of Production Research, 38 (17), 4285β4300. [4]
Chan, F. T. S., Chung, S. H. & Chan, P. L. Y. (2005). An adaptive genetic algorithm with dominated genes for distributed scheduling problems. Expert Systems with Applications, 29 (2), [5] Chan, F. T. S., Chung, S. H. & Chan, P. L. Y. (2006). Application of genetic algorithms with dominant genes in a distributed scheduling problem in flexible manufacturing systems. International Journal of Production Research, 44 (3), 523β543. [6]
Chan, F. T. S., Chung, S. H. & Chan, P. L. Y. (2008). An introduction of dominant genes in genetic algorithm for FMS. International Journal of Production Research, 46 (16), 4369β4390. [7]
Chan, F. T. S., Kumar, V. & Tiwari, M. K. (2009). The relevance of outsourcing and leagile strategies in performance optimization of an integrated process planning and scheduling model. International Journal of Production Research, 47(1), 119β142. [8]
Chaube, A., Benyouef, L. & Tiwari, M. K. (2012). An adapted NSGA-2 based dynamic process plan generation for a reconfigurable manufacturing system. Journal of Intelligent Manufacturing, 23 (4), 1141β1155. [9]
Chu, C. P. & Gadh, R. (1996). Feature-based approach for set-up minimization of process design from product design. Computer-Aided Design, 26 (5), 321-332. [10]
De Werra, D., Demange, M., Monnot, J. & Paschos, V. T. (2005). A hypocoloring model for batch scheduling, Discrete Applied Mathematics, 146 (2005), 3β26. [11]
Epstein, L., HalldΓ³rsson, M. M., Levin, A. & Shachnai, H. (2009). Weighted sum coloring in batch scheduling of conflicting jobs. Algorithmica, 55, 643β665. [12]
Fukunaga, T., HalldΓ³rsson, M. M. & Nagamochi, H. (2007). ββRent-or-buyββ scheduling and cost coloring problems. Proceedings of the 27th Int. Conference on Foundations of Software Technology and Theoretical Computer Science, Springer-Verlag, Berlin, Heidelberg, 84-95. [13]
Giaro, K., Kubale, M. & Obszarski, P. (2009) A graph coloring approach to scheduling of multiprocessor tasks on dedicated machines with availability constraints, Discrete Applied Mathematics, 157 (2009), 3625β3630. [14]
Guo, Y. W., Mileham, A. R., Owen, G. W. & Li, W. D. (2006). Operation sequencing optimization using a particle swarm optimization approach, Proceedings of the Institution of Mechanical Engineers, Part B: Journal of Engineering Manufacture, 220 (12), 1945-1958. [15]
HalldΓ³rsson, M. M. & Kortsarz, G. (2004). Multicoloring: Problems and techniques. Editors, Fiala, J., Koubek, V. & KratochvΓl, J., Mathematical Foundations of Computer Science. Lecture Notes in Computer Science, volume 3153, Springer, Berlin, Heidelberg, New York, 21β45. [16]
Jia, H. Z., Fuh, J. Y. H., Nee, A. Y. C. & Zheng, Y. F. (2002). Web-based multi-functional scheduling system for a distributed manufacturing environment. Concurrent Engineering, 10 (1), 27β39. [17]
Jia, H. Z., Fuh, J. Y. H., Nee, A. Y. C. & Zhang, Y. F. (2007). Integration of genetic algorithm and Gantt chart for job shop scheduling in distributed manufacturing systems. Computers and Industrial Engineering, 53 (2), 313β320. [18]
Jia, H. Z., Nee, A. Y. C., Fuh, J. Y. H. & Zhang, Y. F. (2003). A modified genetic algorithm for distributed scheduling problems. Journal of Intelligent Manufacturing, 14 (3), 351β362. [19]
Kim, Y. K., Park, K. & Ko, J. (2003). A symbiotic evolutionary algorithm for the integration of process planning and job shop scheduling. Computers and Operations Research, 30, 1151β1171.
6 [20]
Lenstra, J. K., Kan, A. R. & Brucker, P. (1977). Complexity of machine scheduling problems. Annals of discrete mathematics, 1, pp. 343-362. [21]
Li, L., Fuh, J., Zhang, Y. & Nee, A. (2005). Application of genetic algorithm to computer-aided process planning in distributed manufacturing environments. Robotics and Computer Integrated Manufacturing, 21 (6), 568β578. [22]
Li, W. & McMahon, C. (2007). A simulated annealing-based optimization approach for integrated process planning and scheduling. International Journal of Computer Integrated Manufacturing, 20 (1), 80β95. [23]
Maropoulos, P. G. & Baker, R. P. (2000). Integration of tool selection with design (part 1. Feature creation and selection of operations and tools). Journal of Material Process Technology, 107, 127β134. [24]
Meuwly, F. X., Ries, B. & Zufferey, N. (2010). Solution methods for a scheduling problem with incompatibility and precedence constraints. Algorithmic Operations Research, 5 (2010), 75β85. [25]
Milosevic, M., Lukic, D., Durdev, M., Vukman, J. & Antic, A. (2016). Genetic algorithms in integrated process planning and scheduling β a state of the art review. Proceedings in Manufacturing Systems, 11 (2), 83β88. [26]
Moon, C. & Seo, Y. (2005). Evolutionary algorithm for advanced process planning and scheduling in a multi-plant. Computers and Industrial Engineering, 48, 311β325. [27]
Morad, N. & Zalzala, A. M. S. (1999). Genetic algorithms in integrated process planning and scheduling. Journal of Intelligent Manufacturing, 10 (2), 169β179. [28]
Qiao, L. & Lv, S. (2012). An improved genetic algorithm for integrated process planning and scheduling. International Journal of Advanced Manufacturing Technology, 58 (5), 727β740. [29]
Salehi, M. & Bahreininejad, A. (2011). Optimization process planning using hybrid genetic algorithm and intelligent search for job shop machining. Journal of Intelligent Manufacturing, 22 (4), 643β652. DOI: 10.1007/s10845-010-0382-7. [30]
Shen, W., Hao, Q., Yoon, H. J. & Norrie, D. H. (2006). Applications of agent-based systems in intelligent manufacturing: An updated review. Advanced Engineering Informatics, 20 (4), 415-431. [31]
Su, Y., Chu, X., Chen, D. & Sun, X. (2018). A genetic algorithm for operation sequencing in CAPP using edge selection based encoding strategy. Journal of Intelligent Manufacturing, 29:313β332. [32]
Sun, K., Dannenhoffer, J. F. & Roy, U. (preprint available). An algorithm framework for the exact solution and improved approximation of the maximum weighted independent set (MWIS) problem. Discrete Applied Mathematics. [33]
Thevenin, S., Zufferey, N. & Potvin, J. (2018). Graph multi-coloring for a job scheduling application. Discrete Applied Mathematics, 234, 218β235. [34]
Tiwari, M. K., Kumar, S. & Shankar, R. (2006). Solving part-type selection and operation allocation problems in an FMS: An approach using constraints-based fast simulated annealing algorithm. IEEE Transactions on Systems, Man, and Cybernetics-Part A: Systems and Humans, 36, 6, 1170-1184. [35]
Wong, T. N., Leung, C. W., Mak, K. L. & Fung, R. Y. K. (2006). An agent-based negotiation approach to integrate process planning and scheduling. International Journal of Production Research, 44, 1331-1351. [36]
Yan, H. S., Xia, Q. F., Zhu, M. R., Liu, X. L. & Guo, Z. M. (2003). Integrated production planning and scheduling on automobile assembly lines. IIE Transactions, 35, 711-725. [37]
Zhang, F., Zhang, Y. & Nee, A. (1997). Using genetic algorithms in process planning for job shop machining. IEEE Transactions on Evolutionary Computation, 1 (4), 278β289. [38]
Zhang, W. & Gen, M. (2010). Process planning and scheduling in distributed manufacturing system using multiobjective genetic algorithm. IEEJ Transactions on Electrical and Electronic Engineering, 5 (1), 62β72. [39]
Zhang, W., Gen, M. & Jo, J. (2014). Hybrid sampling strategy-based multi-objective evolutionary algorithm for process planning and scheduling problem. Journal of Intelligent Manufacturing 25, 881β897. [40]
Zhang, X. & Yan, H. (2005). Integrated optimization of production planning and scheduling for a kind of job-shop. International Journal of Advanced Manufacturing Technology, 26 (7), 876β886. [41][41]