A simulated multi-objective model for flexible job shop transportation scheduling

Abstract

This paper proposes a new dynamic algorithm based on simulation approach and multi-objective optimization to solve the FJSP with transportation assignment. The objectives considered in scheduling jobs and transportation tasks in a flexible job shop manufacturing system include makespan, robot travel distance, time difference with due date and critical waiting time. The results obtained from the computational experiments have shown that the proposed approach is efficient and competitive.

1 Introduction

Scheduling is a process of assigning sets of tasks, or jobs to different resources. The classic job shop scheduling problem (JSP) has been considerably investigated by researchers (Adams et al. 1988; Van Laarhoven et al. 1992). In the JSP, there are n jobs and m machines in a manufacturing system. A job is comprised of j operations with a pre-defined order of execution. Generally, the JSP strives to find a feasible schedule to execute all operations on the machines available. However, jobs are independent of each others and can be processed on machines in any sequence.  Sotskov and Shakhlevich (1995) proved that a JSP with three jobs and three machines $J=3 \mid M=3 \mid Cmax$ is an NP-hard problem.

The increasing variety of manufactured products helps customization service to satisfy customers, while results in more and more complex manufacturing systems (Doganis and Sarimveis 2008). The demand of intelligent data analytic tools and flexible manufacturing systems (FMS) are increasing under the move to Industry 4.0 (Lee et al. 2014). The flexible job shop scheduling extends the classic job shop, assuming that more than one machine is able to run a specific operation (Brandimarte 1993). It allows a workshop to carry out more operations without investing extra resources or machines. Since the JSP is considered as a particular case of the flexible job shop problem (FJSP), the FJSP is also regarded as NP-hard (De Giovanni and Pezzella 2010; Tay and Ho 2008).

In this paper, we employ simulation along with optimization techniques to solve the FJSP with various uncertain parameters inherently existent in the manufacturing environment. Our main contributions are as follows:

• Development of a novel algorithm to solve the FJSP with transportation assignment.

• Optimization of the FJSP with multiple objectives. Previous research hasn’t considered robot transportation distance as an objective.

• Application of dynamic lexicographic order objectives to avoid issues with one absolute importance order given by decision makers.

• Embedding the proposed method in a simulation model which reduces computational time significantly while providing equivalent results.

• Obtaining a unique solution, as opposed to a set of Pareto solutions, to make decision-making more effective.

The rest of the paper is organized as follows. Section 2 gives a review of the recent research on the FJSP. In Sect. 3, the FJSP is redefined and our programming background is presented. Section 4 describes the proposed simulation model and its input requirements, whereas the dynamic scheduling algorithm is explained in Sect. 5. In Sect. 6, the test data and computational results are shown. Finally, we provide our conclusions and suggestions for future research in Sect. 7.

2 Related work

Brucker and Schlie (1990), among the first to deal with the FJSP, proposed a polynomial algorithm to solve a two-job flexible job shop problem with one objective to minimize the makespan. Since then, Makespan, the completion time of finishing all jobs, has been taken as mono-objective to solve the FJSP by many researchers (Liouane et al. 2007; Pezzella et al. 2008; Xing et al. 2010; Li et al. 2011; Yuan et al. 2013).  Gambardella and Mastrolilli (1996) introduced a tabu search (TS) based algorithm with two novel neighborhood functions and demonstrated the effectiveness of his algorithm through a benchmark on five sets of experiments. Zandieh et al. (2008) proposed a genetic algorithm (GA) with several initial populations and several strategies for generating new populations. Nouiri et al. (2018) proposed hybrid metaheuristics based on a clustered holonic multi-agent model to solve the FJSP with many robots. Buddala and Mahapatra (2019) incorporated a new local search technique to teaching–learning-based optimization to solve the FJSP with one objective to minimize makespan.

However, minimizing one objective is unsuitable in real manufacturing systems as different criteria are often considered simultaneously over the production flow (Thörnblad et al. 2013). The multi-objective FJSP has gained the attention of some researchers (Kacem et al. 2002; Gao et al. 2008; Moslehi and Mahnam 2011; Karthikeyan et al. 2015; Kumar and Pandey 2015) over the last two decades. Brandimarte (1993) described a hierarchical algorithm based on a tabu search metaheuristic and a two-way information flow, with makespan and tardiness as separate objectives. Xia and Wu (2005) developed a hybridized particle swarm optimization (PSO) and simulated annealing (SA) to minimize makespan, total machine workload and maximum machine workload at the same time. Gao et al. (2016) proposed a discrete harmony search algorithm (DHS) with a weighted combination of makespan, the mean of earliness and tardiness. Li et al. (2019) introduced an elitist non-dominated sorting hybrid algorithm to solve the FJSP by minimizing makespan and total setup costs.

In general, the FJSP can be decomposed into two sub-tasks: assignment of an operation to an appropriate machine, and sequencing the operations on each machine. For solving the FJSP with more than two jobs, two basic approaches are available (Brandimarte 1993). Concurrent/integrated approaches are proposed to solve assignment and sequencing problems simultaneously (Hurink et al. 1994; Dauzère-Pérès and Paulli 1997; Gao et al. 2008; Yuan and Xu 2013; Buddala and Mahapatra 2019), whereas hierarchical approaches addresses the two sub-tasks separately with the aim to reduce complexity (Brandimarte 1993; Xia and Wu 2005; Gao et al. 2015; Karthikeyan et al. 2015; Wang et al. 2018). However, most the above mentioned references assume that move times between different machines are negligible, and transportation resources are unlimited during the production.

 Langston (1987) and some other researcher (Boudhar and Haned 2009; Naderi et al. 2009, 2010) considered uniformly distributed or sequence-dependent transportation times between different stages in the flow shop scheduling problem(FSP). In the classic job shop problem (JSP), researchers (Hurink and Knust 2005; Zhang et al. 2014) introduced disjunctive graph models with machine-dependent transportation times as constraints. For the FJSP, researchers (Rossi and Dini 2007; Zhang et al. 2012; Rossi 2014; Nouri et al. 2016; Karimi et al. 2017) used transportation time matrices, including the times to move a job between two different machines, as input data to develop mathematical models or metaheuristics to find optimal schedules.

One disadvantage of considering transportation times between machines is the underestimate of empty move times, the time a robot moves without a job between machines $M_{i}$. In practice, a certain distance separates machine input and output buffers. Therefore, the empty move time from $M_{l}$ to $M_{l}$ cannot be neglected. The extended shifting bottleneck heuristic (SBH) developed by Drießel and Mönch (2012) considers transportation times between machine buffers/stockers, rather than between machines to solve a JSP where a path to move a job is static since each operation can only be executed on one machine (or one of a group of identical machines). Nevertheless, to the best of our knowledge, none has considered transportation times between buffers in the FJSP.

In this paper, we develop a multi-agent simulation model to solve the multi-objective FJSP with transportation assignment of robots, a problem hasn’t been studied yet. Compared to other simulation techniques such as discrete-event simulation and micro simulation, agent-based simulation is more straight-forward and adequate to deal with heterogeneous agents (Macal and North 2005; Siebers et al. 2010) and agents with geo-spatial movement (Siebers et al. 2010). A novel dynamic scheduling algorithm is proposed and embedded in the simulation model to lexicographic-optimize transportation operation schedules. All critical real-time information, such as remaining jobs, robot positions and machine conditions, can be obtained from the simulation model and inputted into the dynamic algorithm.

3 Problem formulation

The FJSP has a set of n jobs $J = \{ J_{1}, J_{2}, \ldots , J_{n}\}$ and a set of m machines $M = \{ M_{1}, M_{2}, \ldots , M_{m}\}$. Each job $J_{i}$ has j operations $O_{i} = \{ O_{i1}, O_{i2}, \ldots , O_{ij}\}$ with a precedence constraint and each operation $O_{ij}$ can be processed on any among a subset $M_{ij} \subseteq M$ of compatible machines.

In this paper, we address the FJSP with transportation assignment of robots. Each machine $M_{m}$ is with an input buffer $B^{I}_{m}$ and an output buffer $B^{O}_{m}$. Transfers between machines and their own buffers are automatic. Additionally, there are a system input buffer $B^{I}_{0}$ and a system output buffer $B^{O}_{0}$ to put raw jobs and completely finished jobs. A set of p robots $R = \{ R_{1}, R_{2}, \ldots , R_{p}\}$ transfers jobs between buffers, where the transportation time is distance-dependent. The path and distance between two different buffers are predetermined and fixed. In Fig. 1, we show the whole process of $J_{1}$ production and transportation $T_{1i}$. The five transportation tasks $T = \{ T_{1,1}, \ldots , T_{1,5}\}$ are possible to be operated by different robots. The processing time of an operation $O_{ij}$ on a machine $M_{ijm}$ is operation-dependent and machine-dependent , as shown in Table 1. Production and transportation can be processed independently, which allows robots to transfer some jobs while machines are treating others. The problem thus involves three sub-tasks: assignment of operations to machines, assignment of robots to operations and sequencing the operations on each machine. As we are not solving these sub-problems separately, we integrate them and optimize the schedule dynamically at each transportation assignment, step by step. The algorithm is detailed in Sect. 5.

Fig. 1

Production process and transportation

The proposed model includes the following assumptions:

• $\circ$ All jobs, machines, buffers and robots are available at time 0.

• $\circ$ Machine breakdown and robot failure are ignored (but possible).

• $\circ$ Jobs:

  • Jobs are independent of each other.

  • Each job can be processed on one and only one machine at a time.

  • Preemption of operations is not allowed.

• $\circ$ Machines:

  • Machines are independent of each other.

  • Each machine can process one and only one operation at a time.

  • Machine setup times are ignored (but possible).

• $\circ$ Buffers:

  • Machine buffers have an identical capacity limit.

  • System buffers are unlimited.

• $\circ$ Robots:

  • Robots are independent of each other.

  • Each robot can transfer one and only one job at a time.

  • Time required to load and unload jobs from buffers is included in processing time.

  • Robot collisions are ignored.

Our objectives are to minimize the following:

• $\circ$ F1: makespan, the completion time of all jobs.

• $\circ$ F2: transportation distance, total distance passed by all robots.

• $\circ$ F3: time difference between job finishing time and due time (including both earliness and tardiness).

• $\circ$ F4: critical waiting time, the longest time a job waits in a buffer.

Table 1 Processing times of operations

Generally, the approaches focused on solving multi-objective optimization problems (MOO) can be divided into two classes (Fonseca and Fleming 1998):

• Pareto-based approaches, optimizing all objectives concurrently.

• Non-Pareto approaches, treating objectives separately.

In this paper, our algorithm lies within the first group, Pareto-based approaches. We optimize all objectives simultaneously with dynamic lexicographic orders. Lexicographic ordering (Marchi and Oviedo 1992) requires decision makers to prioritize the objectives according to their absolute importance before the solution process. A more important objective is infinitely more important than a less important objective (Branke et al. 2008). After the ordering step is completed, the solution process starts working minimizing the most important objective function. If a unique solution is found, the solution process will stop. Otherwise, the second most important objective function will be considered and so on until a unique solution is found. The solution of lexicographic ordering can be proven to be Pareto optimal as it is a unique optimal solution of one of the objectives.

However, it is not that easy to derive the importance order of all objectives in practice and lexicographic orderings do not allow a small increment of a more important objective function to be traded off with a great decrement of a less important objective, which can be attractive to decision makers (Roy and Mousseau 1996).

To avoid these drawbacks, we use dynamic lexicographic orders based on two concepts, entropy (Shannon 1948) and goal programming (Charnes et al. 1955), at all transportation assignment steps. The importance orders of the objectives are dependent on their entropy values. When considering a group of jobs based on one objective, the larger entropy value the group has, the more similarity the jobs have, which leads to more difficulty in prioritizing members. At each assignment step, a robot obtains a new lexicographic order based on updated objective entropy values from the real-time information, such as job next operations, robot positions, jobs already in machine input buffers and so on. Before using goal programming to generate a solution, decision makers often need to specify aspiration levels for the objective functions and then, deviations from these aspiration levels are minimized in the solution process. An objective function combined with an aspiration level is regarded as a goal. In our algorithm, instead of aspiration levels given by decision makers, we use the best value of an objective and an acceptable deviation range to get the aspiration level of this objective. The solution process starts with the most important objective function based upon entropy calculation, all jobs better than the aspiration level of this objective are kept, then turns to the next most important objective. The solution process stops once we find a unique solution or the minimization of all objectives finishes. We provide a more detailed description and explanation of the proposed algorithm in Sect. 5.

4 Simulation model

In this section, we describe the developed simulation model. First, we discuss the required inputs and then move to present the simulation framework comprised of three main steps.

4.1 Inputs

To simulate different scenarios in the FJSP, we develop a multi-agent Netlogo model with four interdependent agents: Job, Machine, Buffer and Robot. Operations of jobs are defined as properties of Job Agents.

The following inputs are required to set up the model:

• $\circ$ Global Values

  • objective list

  • deviation space

  • due time list

  • simulation step (tick value)

• $\circ$ Job Agent:

  • ID and initial location (X- and Y-coordinates)

  • operations with a precedence constraint

• $\circ$ Machine Agent:

  • ID and location (X- and Y-coordinates)

  • associated input buffer and output buffer

  • processing times of compatible operations (a sample in Table. 1)

• $\circ$ Buffer Agent:

  • ID and location (X- and Y-coordinates)

  • buffer type (system input/output, machine input/output)

  • associated machine if it is machine buffer

  • capacity limit (no capacity limit for system buffers)

• $\circ$ Robot Agent:

  • ID and initial location (X- and Y-coordinates)

  • move speed.

4.2 Framework

The simulation model and the proposed method are coded in Netlogo 6.0.1. This software allows modellers to define hundreds or even thousands of independent agents for modeling complex systems, which could help us solve the FJSP at large scale. The provided interface works as a desktop application, making the proposed model able to be used directly and easily for industry users.

The proposed model is shown conceptually in Fig. 2. We list four agents and three main model steps. Input is the first step and includes model setup, capture and storage of all the required data. In the GO step, all agents work independently and robots/agents perform transportation assignments and optimize schedules as follows: TransportationAssignment function (defined and described in Sect. 5). The TransportationAssignment function gives each robot a task list, including job ID, machine ID and machine input buffer ID. If no job in the feasible set satisfies constraints (for example, all machine input buffers have reached their capacity limit), then no task is given to robots. After assignment, a robot leaves its current position to the system input buffer or the machine output buffer where the target job is in, then picks up the job and transfer it to the assigned machine input buffer. Machines execute jobs according to the arrival sequence. The GO process repeats until all jobs finish. Once all job operations complete, Output produces the final result and provides the job–machine–robot schedule and all relevant objective values.

Fig. 2

Proposed model with key agents and steps

5 Dynamic multi-objective scheduling algorithm

Most previous algorithms were applied to solve the FJSP with predetermined conditions, such as fixed numbers of jobs, job release times (Kacem et al. 2002) and machine breakdowns (Al-Hinai and ElMekkawy 2011). Ahmadi et al. (2016) addresses the stable scheduling of the FJSP with random machine breakdown, where the interval between every two breakdown occurrences follows an exponential distribution. They evaluated the change before and after machine breakdown to find optimal solutions with the maximal stability. Unlike the existing approaches, our dynamic algorithm makes it possible to adjust the remaining solution process whenever extra information are inputted into the system. For example, when new orders arrive or resources change unpredictably (machine breakdown or robot failure), robots (which are still working) will make decisions based on the updated information, whereas the finished operations are kept as a part of the final feasible solution.

In this section, we describe the proposed TransportationAssignment function in Fig. 2. As mentioned in Sect. 3, we apply dynamic lexicographic ordering based on entropy and use goal programming at transportation assignment steps. We extend the combination of entropy and lexicographic ordering introduced by Eloundou (2016). For the FJSP at large scale, the values regarding one objective are rarely identical. That means the optimization process very likely stops after minimizing the first objective, since a unique solution is found. In order to avoid this problem, we modify the procedure of obtaining lexicographic orders and introduce objective aspiration levels to allow a trade-off between a small decrement for a more important objective and a substantial increment for a less important objective.

Before transferring the last job to the system output buffer, TransportationAssignment function is called by different robots repeatedly. It contains three phases, namely the decision matrix formation phase, the lexicographic ordering phase and the job selection phase. We describe in detail as follows:

Phase I: The decision matrix formation phase

During this phase, the decision matrix, including all feasible jobs waiting for transfer and their corresponding objective values, is formatted according to the real-time information derived from the model.

When a robot is available, it checks the system input buffer and all machine output buffers to find feasible jobs. If no job is found (for example, the production of jobs is almost done and only one or two jobs are being processed in machines), the robot skips all remaining steps and waits on the spot. If only one job is feasible, the robot chooses this job directly without going through the algorithm. When two or more jobs ($n \ge 2$) are feasible, the robot builds a decision matrix (Table 2) with n rows and 7 columns (3 columns job information and 4 columns relevant objective values).

Table 2 Decision matrix

The operations of a job $J_{i}$ follow a precedence constraint, therefore the next operation $O_{ij}$ of this job is easy to acquire. To select feasible machines $M_{m}$ from a subset $M_{ij}$ of compatible machines which can process $O_{ij}$, we need to respect the machine buffer capacity constraint. If none of the buffers allow the transportation of $J_{i}$ due to previous transferred jobs, then $J_{i}$ is deleted from the feasible job set. Otherwise, we list all input buffers $B_{im}$ of feasible machines in the matrix. For the right part of the decision matrix, recall that we optimize makespan (F1), transportation distance (F2), time difference between job finishing time and due time (F3), and critical waiting time (F4). Since we schedule transportation assignments dynamically based on real-time information, the objectives listed in the matrix do not mean the total results, but basic values. For example, the makespan value $f_{1i}$ of $J_{i}$ is the finishing time of $O_{ij}$ on selected $M_{m}$. The critical waiting time value $f_{4i}$ is the maximal waiting time in the system after the robot puts $J_{i}$ into $B_{im}$. Once all jobs and objective values are inserted in the decision matrix, the formation phase ends.

Phase II: The lexicographic ordering phase

In this phase, we calculate entropy values and sort objectives in decreasing order of entropy. First, we normalize the objective values, because the value range and unit of objectives we consider in this model have large differences. Then we perform entropy calculation of each normalized value and sum entropy values in the same column to get objective entropy ($E_{k}$). The applied formulas are as followed:

$$\begin{aligned} N_{ki}= & {} \frac{f_{ki}}{\displaystyle \sum _{i=1}^{n}f_{ki}} \end{aligned}$$

(1)

$$\begin{aligned} E_{ki}= & {} -N_{ki} \times \ln N_{ki} \end{aligned}$$

(2)

$$\begin{aligned} E_{k}= & {} \displaystyle \sum _{i=1}^{n}E_{ki} \end{aligned}$$

(3)

The interval of $N_{ki}$ is (0,1) and ln $N_{k,i}$ is a negative value with an interval ($-\infty , 0$), therefore $E_{k,i}$ is always positive. From 0 to $\frac{1}{e}$, $E_{ki}$ increases while from $\frac{1}{e}$ to 1, $E_{ki}$ decreases. The decision matrix with entropy values is shown in Table 3.

The value of an objective entropy shows the level of difficulty in choosing jobs regarding this objective. If $E_{k} > E_{l}$, it means, compared to objective k, robots have more difficulties in distinguishing jobs at minimizing objective l, because the jobs have more similarities with each other in their objective l values. To avoid rejecting potential good solutions, the job selection starts from the objective with the largest entropy. We sort all objectives in decreasing order of entropy and relist these objectives in the matrix according to the order.

Phase III: The job selection phase

During this phase, we optimize objectives in the matrix from left to right sequentially based on their corresponding aspiration levels (AL). Recall that we use the best value of an objective and a corresponding acceptable deviation range to get the aspiration level of the objective. Once a unique solution is found or all objectives are optimized, the selection process stops. If more than one job remains in the matrix after all objectives are optimized, robots choose the job with the minimal value of the last optimized objective. For a dynamic feasible job set, the solution obtained by the decision matrix is efficient. We call this set ‘partwise’ efficient, which can be proven as follows:

For the optimization problem:

$$\begin{aligned} \min \limits _{j \in J} f(f_{1},\ldots ,f_{k}) \end{aligned}$$

Proposition

let ${\hat{j}}$ be the final solution from the matrix such that for at least one $k \in K$, we have $f_{k}({\hat{j}}) \le f_{k}(j)$ for all $j \in J$. Then ${\hat{j}} \in J_{E}$, where $J_{E}$ is the set of partwise efficient solutions.

Proof

Suppose that ${\hat{j}}$ is not efficient. Then there is a $j \in J$ such that $f(j) < f({\hat{j}})$. Let $K^{*} := \{k \in K: f_{k}(j) < f_{k}({\hat{j}})\}$. So we have $f_{k}(j) < f_{k}({\hat{j}})$ for $k \in K^{*}$, and $f_{k}(j) = f_{k}({\hat{j}})$ for $k \in K$ and $k \notin K^{*}$, which is contradicting the assumption that $f_{k}({\hat{j}}) \le f_{k}(j)$ for at least one $k \in K$. $\square$

Table 3 Decision matrix with entropy value

The selection starts with the first left objective column. First, we sort all jobs in increasing order of objective values (the decision matrix used here is the original one (Table 2), not the matrix with entropy (Table 3)). Then we screen out jobs based on the minimal objective value in the matrix and the objective aspiration level. The process stops when we find a unique solution. Otherwise, the process goes to the next objective. We depict the three phases of our dynamic scheduling algorithm in Fig. 3 and present a simple example in Table 4.

Assume we have five feasible jobs. The objective with the maximal entropy is F3, namely time difference between due time and finishing time, and its aspiration level is 120% of the best value. Therefore, the aspiration level here is 1368 s, then $J_{4}$ and $J_{5}$ are screened out. For the second objective F2, if the aspiration level is the same as that of F3, then only $J_{3}$ is left in the matrix. In this case, the selection process stops and $J_{3}$ is assigned to the robot as its transportation task. When a jobs is assigned, even if it still resides in a buffer, other robots are no longer able to consider it as feasible.

We display a detailed description of how a robot uses the proposed algorithm to find a proper job to transfer in Algorithm. 1.

Fig. 3

Dynamic scheduling algorithm

Table 4 A job selection example

6 Computational results and comparisons

In this section, we study the performance of our dynamic scheduling algorithm by experiments. First, we show some simulation results to illustrate that our model significantly reduces the computational time required to solve the FJSP at large scale. Since no existing method has been introduced to solve the same problem with the same objectives, we carry out some experiments to compare our method with another algorithm proposed for the FJSP without transportation. Finally, we introduce a novel genetic algorithm in order to compare our proposed method with the results of the metaheuristic.

6.1 Simulation results

In this section, we present test instances that we have simulated to validate the efficiency of the suggested approach. To ease the simulation, we assume that:

• The workshop has a fixed number of machines. It is possible to shut off some machines for small size productions, but not possible to add more machines since in practice it is difficult to get additional capital investments.

• In instances with different numbers of machines, the setting of machines, such as operation processing times or locations, remains the same. The distance between different buffers is fixed.

In Fig. 4, we show the workshop environment for all instances. The system has 4 machines, 8 machine buffers and 2 system buffers. The number of jobs and the number of robots can vary.

In Table 5, we present the results of different test. We show CPU times in seconds. Instances at really large scale (i.e., 200–500 jobs) not previously considered by other researchers, appear to be solvable in acceptable time frames by utilizing our algorithm.

Fig. 4

Workshop layout

Table 5 Simulation results

6.2 Comparisons in the FJSP without transportation

To show the flexibility of our simulation model and evaluate the efficiency of the proposed scheduling method, we carry out some experiments to compare our algorithm with another Pareto-based method proposed for solving the FJSP without transportation.

Kacem et al. (2002) applied a hybrid evolutionary algorithm with fuzzy logic (FL+EA) based on the Pareto concept to solve the multi-objective FJSP where move times between machines (buffers) are ignored. The objectives optimized are makespan, critical workload and total workload. They also considered the release times of jobs (some jobs are not available at time 0).

The comparison results are shown in Table 6 and we present the detailed solutions obtained by our model in Tables 7 and 8. The values of computational time are not provided in their paper. However, based on their algorithm, we can conclude that our proposed method is more effective as it generates efficient solutions with much less computational times.

Table 6 Comparison results of FL+EA and our method

Table 7 Our solution of instance $4 \times 5$

Table 8 Our solutions of instance $10 \times 7$ and of instance $10 \times 10$

6.3 Comparisons with genetic algorithm

GA methods are inspired by Darwin’s principle of natural evolution. Starting with a set of candidate solutions, the best candidates in each generation are selected to form offspring as new candidates through crossover and mutation operations. These offspring are inserted into the population by replacing some of the weaker individuals in the previous generation.

The proposed GA method follows the following general steps of evolutionary algorithms:

• 1. Initialization: The aim here is to obtain some feasible solutions with a given population size.

• 2. Fitness evaluation: We employ NSGA-II to find non-dominated solutions with the same four objectives as we optimize in our dynamic algorithm. We explain the details of this in Sect. 6.3.2.

• 3. Generation of offspring: Based on the results of the fitness evaluation, some of individuals are randomly selected as parents to generate offspring through crossover and mutation operations.

• 4. The second and third steps are repeated until a set of solutions satisfies decision maker or until reaching the stopping criterion. In our case, we use a given number of generations as the stopping criterion.

6.3.1 Chromosome presentation

In existing GA research work to solve the FJSP (Pezzella et al. 2008; Zandieh et al. 2008; Chaudhry et al. 2013), researchers built their chromosomes with triples, namely operation, job and machine (Fig. 5). In order to implement our GA to solve the FJSP with transportation assignment, we form adapted triples ($J_{i}, B_{m}, R_{p}$), one for each transportation task, where:

$J_{i}$ is the job to transfer;

$B_{m}$ is the buffer where the robot transfers $J_{i}$ to;

$R_{p}$ is the robot which executes this transportation task.

Fig. 5

Chromosomes proposed by Chaudhry et al. (2013) (a) and Zandieh et al. (2008) (b)

The length of the chromosome corresponds to the total number of transportation tasks. Recall that for each job, transportation tasks include transferring the job to machines which execute its operations and transferring it to system output system. Therefore, the number of transportation tasks for a job equals the number of operations belonging to this job added by 1.

However, for the FJSP with partial flexibility, not all machines can process all operations resulting in the generation of offspring naturally deemed infeasible when the crossover and mutation operations execute. In that case, we have to regenerate offspring to manage the population size. Therefore, we think it is better to use a triple string of indexes between 0 and 1 to code chromosomes and interpret the string depending on actual transportation assignment circumstances. To articulate the coding and interpretation process, we give a simple example here.

Assume we have 2 jobs ($J_{1},J_{2}$) each with two operations ($O_{i1}, O_{i2}$), two machines ($M_{1},M_{2}$) both able to process all operations, and two robots ($R_{1}, R_{2}$). The length of chromosomes is the total number of transportation tasks, which equals 6. Then we generate a random initial chromosome as

Job	0.23	0.53	0.32	0.35	0.75	0.67
Buffer	0.81	0.83	0.25	0.62	0.96	0.27
Robot	0.07	0.43	0.82	0.13	0.32	0.29

To interpret, we follow these steps:

Step 1: List all feasible jobs, $J = \{J_{1},J_{2}\}$. Use the function

$$\begin{aligned} I(x) = \lfloor x \times N + 1\rfloor \end{aligned}$$

where

• I(x):the item position in the list

• N: the number of items in the list

• $\lfloor \rfloor$: floor function, taking as input a real number and gives as output the greatest integer less than or equal to

to interpret the index 0.23 in the first gen, then the corresponding job is $J_{1}$, the first item ($I(0.23) = \lfloor 0.23 \times 2 + 1 \rfloor = 1$) in J.

Step 2: Find a subset of compatible machines for the next operation of $J_{1}$, $M = \{M_{1}, M_{2}\}$. By the same function, we can get $M_{2}$, the second item ($I(0.81) = \lfloor 0.81 \times 2 + 1 \rfloor = 2$) in M.

Step 3: With the robot list $R = \{R_{1}, R_{2}\}$, we get $R_{1}$, the first item in R.

After obtaining the first transportation task, the process is repeated with new feasible lists until we process all indexes. Therefore, the chromosome has the schedule as below:

Job	$J_{1}$	$J_{2}$	$J_{1}$	$J_{1}$	$J_{2}$	$J_{2}$
Buffer	$B^{I}_{2}$	$B^{I}_{2}$	$B^{I}_{1}$	$B^{O}_{0}$	$B^{I}_{2}$	$B^{O}_{0}$
Robot	$R_{1}$	$R_{1}$	$R_{2}$	$R_{1}$	$R_{1}$	$R_{1}$

6.3.2 Fitness evaluation

In NSGA-II methods, no objective is regarded as having priority over others. All individuals are sorted based on non-domination into each front. The individuals in the first front do not have any individual who dominates them in the current population, and the individuals in the second front are only dominated by the individuals in the first front. Individuals in different fronts are assigned different fitness values according to the rank of their front, for example, 1 for the first front and 2 for the second front.

The concept of crowding distance is introduced to rank individuals in the same front. It calculates how close an individual is to its neighbors. Fitness value and crowding distance are double standards to select elitist individuals from the population. Individuals are selected when their fitness value are minimal. If two individuals have the same fitness value the one with the greater crowding distance is preferential. The adopted method to take non-dominated sort and to calculate crowding distance follows the one proposed by Deb et al. (2002).

Note that we use the Netlogo simulator to calculate values of objectives for each individual. Rather than estimating the distance between different buffers, using the simulator to simulate how robots work and obtain the distance directly from the model could produce more accurate results and get closer to practical applications.

In our NSGA-II method, we sort the population with the same four objectives: makespan, transportation distance, time difference and critical waiting time. In the end, it offers users a set of Pareto solutions, rather than a single solution. This method requires decision makers to pick their preferred solution after seeing all Pareto solutions. In the case study, we show feasible solutions without bias and compare the results from the dynamic scheduling algorithm we discussed in Sect. 5.

6.3.3 Genetic operators

The NSGA-II method uses crossover and mutation operators to generate offspring. We assume that it is possible to generate good children even if the parents are relatively bad in the population. In each iteration, we generate children with the population size by randomly selecting parents from the population. The crossover operator divides the two parent chromosomes in the middle, and the second parts of the parent chromosomes are swapped to get new off-springs. The chromosome structure avoids generating infeasible off-springs and legalizing after. The mutation operator simulates the mutation observed in nature. With a given mutation rate, each point on a gen can be changed randomly.

The offspring and the parent populations are combined and sorted together based on non-domination. The new generation is filled by each front subsequently until it reaches the population size. If it needs to pick some individuals from a front, individuals are selected by the crowding distance in descending order. These processes repeat until reaching the stopping criterion.

6.4 Comparison results of GA and our method

To obtain potential efficient solutions, the population size and the number of generation are 50 and 1000, respectively. Table 9 indicates the comparison of the solutions by the two approaches. We have observed that the solutions from our method dominate most of GA solutions.

Table 9 Comparison results of GA and our method

7 Conclusion and future work

Research on the FJSP with transportation assignment is relatively rare. In this work, we develop a novel scheduling algorithm to solve the multi-objective flexible job shop problem with transportation assignment. A simulation model with 4 agents is proposed to simulate the whole production process. Whenever a robot agent is available, it employs the algorithm with all real-time data derived from the simulation model to generate partwise efficient dynamic feasible solutions.

We test the proposed algorithm by using several benchmarks. The comparative results show that our algorithm outperforms all the benchmarked algorithms. One of the major advantages of our method is the reduction of computational time required while providing equivalent or better results. Additionally, the single solution provided by the proposed method makes it easier for decision makers to execute production plans. For automatic manufacturing workshops, this model can be implemented directly to help robots execute transportation tasks. We recognize that the assumption constraints of our model impose limitations that would benefit from additional work. Some future research directions can be recommended. Additional machine conditions could be considered, such as setup time, maintenance, or breakdown situations, which makes the assumptions more realistic and more complete. The insertion or withdrawal of robots during production peak or slack period also can be interesting to investigate.