Flexible job shop with continuous material flow

A new scheduling problem, the continuous flow flexible job shop (CF-FJS) is proposed. The formulation combines the well-known flexible job shop (FJS) problem and a dedicated continuous material flow model (MFM). In the MFM, operations are represented by material flow functions derived by integration of arbitrarily defined speed patterns. Two main concepts of the MFM formalism, i.e. variable speed of processing and continuous material flow, lead to position-dependent processing times and overlapping in operations which extend standard FJS formulation. Properties of the CF-FJS are investigated. A tabu search sched uling algorithm utilising these properties is proposed. Effective neighbourhood functions are defined based on elimination approaches. Two auxiliary procedures: search intensification level switching and fast feasibility detection are added to improve algorithm efficiency. The algorithm is verified using dedicated benchmark instances which comprise non-trivial representations of the CF-FJS specific features, i.e. machine efficiency patterns and minimum inter-operation buffers. The research is motivated by task scheduling in a fastener factory, but the presented results can be useful in many domains, such as production of granular goods, steel details, glass and fluids. The solution can be used in real-world applications. The published results can be helpful in testing new CF-FJS scheduling algorithms.


Introduction
In this work, the continuous flow flexible job shop (CF-FJS) scheduling problem is introduced that combines the flexible job shop (FJS) production environment and dedicated continuous material flow model (MFM). The continuous material flow results from a continuous process or it approximates flow of small details processed in large number. The MFM formalism is based on the assumption that processing speed is defined by a piecewise constant time-varying function. Changes of processing speed can be an effect of shift plans, energy tariffs, variable number of workers and so on. In particular, the process or machine speed can be equal to zero in some time ranges that represent unavailability.
The proposed CF-FJS scheduling problem can be concisely characterised by enumeration of similarities and disparities between it and the standard FJS. The CF-FJS is similar to the FJS in the following aspects: • There is a set of jobs and each job is defined by an individual and arbitrary given sequence of operations. Processing order has to follow these sequences. • For each operation, a set of available machines is defined. • There is the resource constraint which allows any machine to process at most one operation at a time.
• Minimisation of the makespan is the objective.
There are, however, important differences between the two formulations: • In the FJS, machines are available without restrictions and have no individual parameters. In the CF-FJS, each machine has assigned an efficiency pattern, which is a function of time, such that the product of the efficiency pattern and a nominal processing speed of an operation represents the processing speed function of this operation. • Each operation in the FJS is represented by a fixed (i.e. position independent) interval of time, whereas operations in the CF-FJS are modelled by material flow functions (integrals of processing speed functions) and resulting processing time is, in general, position dependent. • In the FJS, a consecutive operation of a job can start when the previous one is completed. Because of continuous processing, in the CF-FJS, sequential operations can overlap, providing that minimum buffer between their material flow functions is maintained. • The CF-FJS is generalisation of the FJS and it can represent FJS instances as special cases.
A tabu search-based scheduling algorithm has been implemented for the CF-FJS. Properties of the CF-FJS have been taken into account in this implementation. The neighbourhood definition exploits proved features of the CJ-FJS to exclude from search a subset of the moves which cannot result in immediate objective improvement. A mechanism of search intensification level switching (SILS) has been implemented. It intensifies density of neighbourhood gradually while the objective is minimised. A procedure of fast feasibility detection (FFD) has been added to the algorithm. The FFD makes it possible to predict feasibility of a new solution obtained by a single move with constant time complexity.
The research is motivated by task scheduling in a fastener factory. In this factory, lots of tiny steel elements are processed. For each lot, a sequence of operations is defined. Each operation has a predefined set of adequate machines and one of them has to be chosen for processing this operation. Machines have assigned efficiency calendars based on shift plans, planned maintenance tasks and other conditions. The elements are transported between consecutive operations constantly and a minimum transport buffer between them should be maintained. This production organisation corresponds to the CF-FJS definition. We believe that the presented solution will be useful in many domains, e.g. production of granular goods, steel details, glass, fluids and others. The features of scheduling problems considered in this work are relevant in the context of real-world scheduling applications. Leading software packages give the possibility of defining efficiency calendars for resources. Such calendars can be considered as piecewise constant time-varying functions with the interpretation analogous to the speed and efficiency pattern concepts used in this paper. For example, in the SAP™ ERP these calendars are referred to as shift sequences, and in the Preactor™ scheduling system as resource calendars. Support for overlapping in operations is also present. In the SAP APO-PP/DS module, the overlapping can be configured by means of the two parameters: minimum send-ahead quantity and minimum overlap time. In Preactor, it results from splitting batches into smaller lots and transferring them individually across consecutive processes (transfer batching) that is a variant of the well-known lot streaming method. This work introduces a new enhanced model of overlapping in which the material buffer determines the minimum quantity between overlapped operations for all the time of overlapping, not at the start of the next operation, as in the case of the minimum send-ahead quantity parameter. The overlapping model, the complete CF-FJS production environment, and the scheduling algorithm for it can be used for development of new or extending functionality of existing scheduling software.

Related work
Currently, the research on the FJS and similar scheduling problems makes for studying the problems with modifications and extensions that move them closer to the industrial usability. For example, the problems with limited machine availability and breakdowns (Sawik 2012), operations blocking (Gröflin, Pham, and Bürgy 2011), limited resources (Rajkumar et al. 2011), multiple process plans (Doh et al. 2013) and assembly (Gomes, Barbosa-Póvoa, and Novais 2013) are considered. It is quite common to complement the FJS formulation with set-up times (Mousakhani 2013) and also with transfer times (Gröflin, Pham, and Bürgy 2011). Reactive scheduling can be considered to deal with dynamic FJS problems (Gomes, Barbosa-Póvoa, and Novais 2013). Broad range of criteria is used, e.g. makespan, mean and total tardiness (Mousakhani 2013), maximum lateness (Vilcot and Billaut 2011), total flow time, the number of tardy jobs (Doh et al. 2013), earliness, in-process inventory (Gomes, Barbosa-Póvoa, and Novais 2013), total and maximum workload of machines (Rajkumar et al. 2011). In the context of the FJS problem, a feature of overlapping in operations is also considered (Alvarez-Valdez et al. 2005;Fattahi, Jolai, and Arkat 2009;Fattahi and Mehrabad 2009;Farughi et al. 2011). In the mentioned works, the overlapping is controlled by an operation-related parameter which defines the proportion of the operation that has to be processed before its successor can start. This overlapping model may be not powerful enough to deal with complex time relations in continuous processing systems. On the other hand, scheduling of continuous processes has its own solutions that are considered especially in the context of chemical industry (Floudas and Lin 2004;Shaik and Floudas 2007;Shaik et al. 2009). The effect of operation overlapping is also present in lot streaming problems (Lei and Guo 2013), however, processing is not continuous in these problems. It has been rather unusual so far to join advantages of continuous processing models and the (flexible) job shop environment, although it is possible and has been applied e.g. for algorithm benchmarking (Sourd and Rogerie 2005).
Some scheduling problems can be solved more efficiently if a well-suited neighbourhood is used, e.g. based on the critical path and the operations block ideas. Such approach is used for the single-machine scheduling with release dates and due dates as objective (Grabowski, Nowicki, and Zdrzałka 1986), the job shop with makespan minimisation (Nowicki and Smutnicki 1996;Perregaard and Clausen 1998;Pezzella and Merelli 2000) and the single-machine scheduling with the weighted sum of earliness and tardiness minimisation (Wodecki 2009). The algorithm using the block approach is also implemented for the FJS problem (Bożejko, Uchroński, and Wodecki 2010;Li, Pan, and Liang 2010).
FJS scheduling approaches based on tabu search are often improved by additional mechanisms. Grabowski and Wodecki (2005) use fast prediction of solution feasibility that exploits graph representation of a problem, estimation of objective value by means of its lower bound, dynamic length of tabu list and mechanism of perturbation in move selection. Li, Pan, and Liang (2010) propose a hybrid tabu search algorithm (HTSA) in which the basic metaheuristic is extended by a variable neighbourhood search (VNS), a dynamic length tabu list and a left-shift function that decode an encoding solution to an active schedule.
The solution proposed in this paper relates to the above-mentioned concepts and approaches, i.e. the FJS problem, the continuous processing model, as well as the tabu search algorithm with improved optimisation mechanisms. The introduced CF-FJS is generalisation of the standard FJS which allows to solve patently broader classes of problems that are combination of the well-known FJS with continuous processing in which variable machines efficiency, position-dependent processing times and overlapping in operations are present. The paper contributes to the research field of production scheduling by formulating the CF-FJS problem, identifying its properties and proposing a tabu search-based scheduling algorithm. A set of benchmark instances of the CF-FJS are also prepared and the results of scheduling experiments based on them are presented.

Problem formulation
The CF-FJS problem has a two-level formulation. On the lower level, single operations are modelled using the MFM formalism. These operation representations are embedded into the FJS for modelling complete production environment on the higher level ( Figure 1).

Material flow model (MFM)
In the MFM, operations are represented by material flows (mf ) derived by integration of the speed patterns (sp). The material flows are described by piecewise linear time-varying functions, whereas the speed patterns are described by piecewise constant time-varying functions. In the example on Figure 1, a single operation O k,i processed on a machine M p is represented by means of these functions. The speed pattern sp k,i, p is defined for the pair (O k,i , M p ). The speed pattern can be distinct for each pair (operation, machine) on the level of the MFM, but it is expressed in the CF-FJS as the result of multiplication of the operation-related constant nominal speed and the machine-related efficiency pattern (ep). For the pair (O k,i , M p ), the minimum material buffer bf k,i, p is also defined. Providing that the material flow mf k,i−1 of the previous operation O k,i−1 of the same job is known (dashed line on Figure 1), the MFM makes it possible to determine the material flow mf k,i of the operation O k,i . This flow is calculated by integration of sp k,i, p in the limits from an arbitrary chosen start time to the time at which the flow reaches a maximum value assigned to the job, these limits are interpreted as the start and completion time of the operation O k,i . There are two examples of such flows on Figure 1, i.e. mf a k,i and mf b k,i . The flow mf a k,i starts at the time t es called earliest start time. It is the minimum possible start time that ensures the required difference between mf k,i−1 and mf k,i equal to at least bf k,i, p . The time t es is used as the sequence constraint assigned to an operation, i.e. the operation can start at any time t ≥ t es , e.g the flow mf b k,i starts at t s > t es . In general, the consecutive operations modelled by the overlap (O k,i−1 modelled by mf k,i−1 overlaps with O k,i modelled by mf a k,i or mf b k,i ) and processing time of an operation is position-dependent, e.g. t c − t es = t c − t s (Figure 1).
Formally, the MFM is defined as 10-tuple of concepts where • T D , F D , S D , and D D are domains of scalars representing time, flow, speed, and dimensionless (or percentage) values, respectively, • MF S , SP S , and EP S are sets of data structures representing material flows, speed patterns, and efficiency patterns, respectively, • OMF P , CMT P , and EST P are computational procedures of the MFM.
The procedure OMF P computes output material flow mf out that is the result of processing performed by a resource with a given speed pattern sp characterised by start time t s and total amount of processed material f max The procedure CMT P takes the same arguments as OMF P , but it returns completion time t c of the related operation The procedure EST P computes earliest start time t es of an operation on the basis of a speed pattern of the operation sp out , a speed pattern sp in and start time t s,in of a preceding operation, total amount of processed material f max and a minimum material buffer between the operations bf The following two properties of the MFM have a significant impact on features of scheduling problems defined on the basis of it.

MFM Property 1
The completion time of an operation is a non-decreasing function of its start time, i.e.
MFM Property 2 The earliest start time of an operation is a non-decreasing function of the start time of the previous one, A detailed description of the MFM formalism is available as supplemental online material (Appendix A).

CF-FJS problem
Definitions of sets and parameters used for the CF-FJS problem formulation are presented in Table 1. The problem is formulated as follows (1) There is a non-empty set M of machines (processors) M p which has r elements.
(2) For each machine M p ∈ M an efficiency pattern e p ∈ EP S is defined.
(3) There is a non-empty set J of jobs J k which has n elements.
(4) For each job J k ∈ J a non-empty set O k of operations O k,i is given which has js (k) elements.
The solution of the CF-FSJ problem will be represented as a function S : that assigns a machine M ρ(k,i) and a start time t s,(k,i) to each operation O k,i . (9) The solution is feasible if and only if it is possible to represent it by the function S (1) and the following relations and conditions are met (10) The objective is to find the solution S * such that max k∈{1,2,...,n} t c,(k,js(k)) → min, where the values t c,(k,js(k)) are calculated according to the expression (2a) on the basis of S * . This is the objective commonly referred to as makespan and denoted as C max . (11) The set of all CF-FJS problems will be denoted by P CF . The set of all solutions of the problem P ∈ P CF will be denoted by S P .

Comments to the CF-FJS problem formulation
• The index of the machine assigned by a solution to the operation O k,i is denoted as ρ (k, i). The earliest start time, the start time and the completion time of this operation are denoted as t es,(k,i) , t s,(k,i) and t c,(k,i) , respectively. • It has been arbitrarily assumed that f max = 1 for all operations and this value is put into the expressions (2a) and (2c). Hence, the material flow is normalised to the range [0, 1] or [0, 100%]. • The parameter p k,i, p is referred to as nominal processing time, because it is used as the inverse of the nominal speed for the CF-FJS formulation in (2a) and (2c). It is the analogue of the processing time in classic scheduling problems in the sense that the value t c,(k,i) − t s,(k,i) is equal to p k,i, p if the value of efficiency pattern of the related machine is equal to 100 % (i.e. nominal) in the whole range t s,(k,i) , t c,(k,i) . • The constraint (2a) specifies that the completion time t c,(k,i) of each operation O k,i is determined by its start time t s,(k,i) , the efficiency pattern e v of the assigned machine M v and the nominal processing time p k,i,v , with the use of the procedure CMT P . The first operation O k,1 of each job J k ∈ J can start at time 0 (2b), however, the earliest start time t es,(k,i) of any other operation O k,i , i > 1 is restricted by the parameters of the previous operation O k,i−1 of the same job (i.e. its start time t s,(k,i−1) , the nominal processing time p k,i−1,c and the efficiency pattern e c of the assigned machine M c ), as well as the nominal processing time p k,i,v of the operation O k,i itself, the efficiency pattern e v of the machine M v assigned to it and related material buffer b k,i,v . This restriction is defined by means of the procedure EST P (2c). The actual start time t s,(k,i) of any operation O k,i in the solution is lower bounded by t es,(k,i) (2d). The expressions (2b)-(2d) together constitute the sequence constraint that allows overlapping of operations. The condition (2e) represents the resource constraint that permits only one operation to be processed at a time by a single machine.

CF-FJS problem properties 4.1 Solution graph
The solution graph represents a single semi-active (Pinedo 2008) solution of the scheduling problem. The semi-active solution will be denoted byS in the remainder of the work. Let us define a processing order π = (κ, ι), where κ ( p, q) and ι ( p, q) are the functions that return indices k and i, respectively, if the operation O k,i is to be processed by the machine M p on the position q of its processing queue. The number of operations in the processing queue of machine M p is expressed by ps ( p). We assume that each operation is assigned exactly once to some machine.
The actual processing time of each operation p act k,i = t c,(k,i) − t s,(k,i) is split into two components p A k,i and p B k,i (see Figure 2), such that The value p A k,i represents the processing time of O k,i elapsing before O k,i+1 starts and the value p B k,i represents the rest of the processing time of O k,i .
The solution graph G (π ) = (N, A, w) related to the processing order π is defined by the set of nodes N, the set of arcs A and the function w : N −→ T D that assigns a weight to each node, according to the formulas (4).
i=ι ( p,q) , The nodes N A k,i ∈ N 1 and N B k,i ∈ N 2 represent the parts of operations that correspond to the times p A k,i and p B k,i , respectively. The dummy start and final nodes N s , N c ∈ N 3 are also defined, as usually in solution graphs. The arcs A 1 ∪ A 2 represent sequence constraints, connecting the nodes that represent consecutive operations of jobs. The arcs A 3 represent resource constraints and reflect processing queues of machines. Values of the function w are defined for each node in the graph (4d).
Algorithm 1: Construction of complete solution graph. Data: P, π ,Ḡ (π ) = (N, A) begin ξ () ← generateFunctionXi(π,Ḡ (π )); /* ξ() returns k,i,p,q for a given node */ U := get T opological Order(Ḡ (π )); foreach u ∈ U do if u ∈ N 1 then continue; {k, i, p, q} := ξ (u); The weights of nodes are not known in advance when the graph is created, because processing times of operations depend in general on start times of previous operations. For that reason, the incomplete graphḠ (π ) = (N, A) without function w is created first. Then, the Algorithm 1 generates and returns the complete graph G (π ) on the basis of the problem specification andḠ (π ).
In the first part of the Algorithm 1 (the first foreach loop), the nodes from N 1 are visited in topological order and the parameters t s and t c are calculated for each of these nodes. The start time t s [k, i] of the operation O k,i related to the node N A k,i ∈ N 1 is determined as the soonest possible moment which jointly satisfies the sequence constraint (t s [k, i] ≥ t es ) and the resource constraint (t s [k, i] ≥ t r ). The value of t c [k, i] is calculated on the basis of t s [k, i] with the use of the procedure CMT P . In the second part of the Algorithm 1, the previously prepared arrays with the parameters t s and t c are used for calculation of weights of all the nodes from N 1 and N 2 using the relation defined by (3). Values of the weights w (N s ) and w (N c ) are set to zero.

Critical path
The sequence of all operations cpl that belong to the longest path of G (π ) will be referred to as critical path. It is obvious that C max = t c O C cpl . The critical path is the well-known concept in scheduling theory, however, its properties need to be inspected in the context of the CF-FJS problem.
Let us assume that the start time of some operation O C i ∈ CP, previously equal to t s O C i , changes to t s O C i > t s O C i , as the result of some additional constraint. Adjacent operations on the critical path either are processed by the same machine or belong to one job. In the first case, the resource constraint is active (see 2e), hence t s O C i+1 = t c O C i and on the basis of MFM Property 1 we have In the second case, the sequence constraint is active (see 2d), thus t s O C i = t es O C i and on the basis of MFM Property 2 we obtain The consequence of (5) and (6) is that On the basis of mathematical induction we have ∃ i∈{1,2,...,cpl} Finally, regarding (2a) and MFM Property 1, we conclude Thus, the first property of the critical path can be formulated as follows

CF-FJS Property 1
IfS is a semi-active solution of the CF-FJS problem P which has a critical path CPS and a second solution S is created by delaying the start time of an operation The processing order can be modified by moving some operation O k,i from its initial position to a new one, defined by the machine index p of M p ∈ M k,i and the position q of the operation in the machine queue. Such the move will be denoted as (k, i → p, q) and the processing order π changed by this move will be denoted as π (k,i→ p,q) . The notation V k,i (π ) will represent the set of all moves allowed for O k,i and the processing order π .
Let us assume that there is a CF-FSJ problem P with a semi-active solutionS π based on the processing order π , which has a critical path CPS π and makespan equal C max . Let us change processing order by moving a freely selected operation O k,i / ∈ CPS π to a new freely selected position that results in the new processing order π = π (k,i→ p,q) that leads to a new semi-active solutionS π with a new makespan C max . It is impossible to obtain C max < C max in this way. This is because each operation on the critical path has an active constraint related to antecedent operations on this path. These constraints cannot be relaxed without moving any operation from the critical path. Moving other operations may at most activate additional constraints which cannot result in makespan reduction, according to CF-FJS Property 1. Hence, the second property can be formulated.

Block property
It is proved below that the block elimination property (Grabowski, Nowicki, and Zdrzałka 1986;Li, Pan, and Liang 2010;Pezzella and Merelli 2000) is also relevant to the CF-FJS problem. The block in the CF-FSJ problem will be defined as a non-empty subsequence of operations of the critical path  Figure  3). Constructing of the new solution can be divided into two steps, resulting in the solutions S * and S * * , respectively. In the first step, the transposition is executed, but sequence constraints for the operations from B s are omitted, thus f = 0, f = 1, 2, . . . , c + 1. In the second step, the additional constraints are taken into account.
After the first step, it is only assured that t s O s σ (1) = t s O s 1 , but start, completion and processing times of other operations from B s can change. On the basis of the MFM formulation and (2a), the following integrals can be written for the operations from BI s where f = 2, 3, . . . , c − 1, the parameter e p is the efficiency pattern of the machine M p that processes the operations and p σ ( f ) substitutes p k,i, p , as the index σ ( f ) unambiguously identifies an operation in the solution. The integrals can be multiplied by the constant parameters p σ ( f ) and summed as follows The left-hand side of (8) can be simplified to a single integral It results from (9) that the completion time t B is not dependent on the selected permutation σ . Hence, the critical path length remains unchanged or a new longer critical path arises and C max (S * ) ≥ C max S .
In the second step possible additional constraints are activated and no constraints from the critical path of S * can be relaxed. As the result, the start times of some operations from the critical path can be delayed and, according to CF-FJS Property 1, the relation C max (S * * ) ≥ C max (S * ) holds.
The final finding is that C max (S * * ) ≥ C max S , hence, no permutation (and no move) inside a block can decrease the objective function. Only the moves that relocate an operation out of the block can be effective. Let us denote as V k,i π, ← − B s the set of all the moves (k, i → p, q) that relocate the operation O k,i ∈ BI s out of the block B s . The block property for the CF-FJS problem is formulated as follows CF-FJS Property 2

Tabu search-based scheduling algorithm
The scheduling algorithm used in this work is based on the tabu search metaheuristic (Barnes, Laguna, and Glover 1995). This metaheuristic is useful in optimisation problems for which a discrete neighbourhood is defined. The tabu search is surprisingly efficient for solving the JS/FJS problems and, despite relatively simple implementation, it often yields gainful results (Watson et al. 2003). It can be easily improved by additional mechanisms which reduce neighbourhood and make computations faster (Grabowski and Wodecki 2005). The mentioned advantages of the tabu search are utilised in the presented implementation.

Moves, neighbourhood and tabu attribute
In the tabu search algorithm, the same move definition is used as that introduced in the description of the property of critical path (Section 4.2). For defining the neighbourhood, additional definitions are introduced: • M (B s ) denotes the machine M p ∈ M that processes the operations from the block B s .
• V k,i π, ←− B s FL is the set of non-redundant moves that shuffle an operation O k,i ∈ B s just before O s F or just after O s L . This set is empty if bs (s) = 1, has two elements if bs (s) > 2 ∧ O k,i ∈ BI s and has one element otherwise.
• RS (x) denotes random selection of exactly one element from a set or sequence x with uniform distribution.
Three neighbourhood functions are defined The neighbourhood N L3 (10c) comprises all the moves that give the chance of immediate objective improvement, according to CF-FJS Property 2 (Section 4.2) and CF-FJS Property 3 (Section 4.3). This neighbourhood transpired to be quite broad, hence it is denoted as the highest level of search intensification (L3) and the additional levels are introduced by restriction of the set of moves from N L3 using some random choices, such that N L1 (π ) ⊆ N L2 (π ) ⊆ N L3 (π ). In the neighbourhood N L2 (10b) only a single operation from every block is chosen randomly and moved just before and just after the block on the same machine, and to one randomly pointed position on every other available machine. The neighbourhood N L1 (10a) is very similar to N L2 , but additionally restricted, because only a single operation from the entire solution (not from every block) is chosen.
The triple (k, i, p) is used as a tabu attribute. When an operation O k 1 ,i 1 is moved from a machine M p 1 to another one, the element (k 1 , i 1 , p 1 ) is added to the tabu list and the moves (k 2 , i 2 → p 2 , q 2 ), such that (k 1 = k 2 ) ∧ (i 1 = i 2 ) ∧ ( p 1 = p 2 ), become forbidden.

Fast feasibility detection (FFD)
After changing processing order of a feasible solution by a move an unfeasible solution can arise. The solution is unfeasible if and only if its solution graph is cyclic (Pinedo 2008). The unfeasibility can be detected while the solution graph is created with the mean time complexity O(h), where h denotes the number of operations in a scheduling problem. However, it is possible to predict feasibility in constant time with limited accuracy. Here, the method proposed by Grabowski and Wodecki (2005) is adapted to the CF-FJS problem.
Let us assume that an initial feasible solutionS π is to be changed by the move (k, i → p, q). To perform the fast verification of feasibility of the target solutionS π , where π = π (k,i→ p,q) , the following data are needed (1) π , the initial processing order, (2) G (π ), the acyclic solution graph based on the processing order π , (1) H (n) = L(N s , n), the function that returns length of the longest path between the nodes N s and n, (3) T (n) = L(n, N c ), the function that returns length of the longest path between the nodes n and N c , (4) (k, i → p, q), the move that is to be performed.
The data from the points (2), (3) and (4) can be derived with the complexity O(h). It is enough to obtain these data once for checking all moves that can modify the solutionS π .
On Figure 4, the modification in the solution graph is shown that represents the move (k, i → p, q). Three arcs from the graph G (π ) are removed and three new arcs is reinstated by the arc A 1 and the arc ( p B , s A ) is reinstated by the path ( p B , x A , x B , s A ), hence, these reconstructed connections cannot close a cycle. However, the cycle can be created by the arc A 2 together with the hypothetically existing path d 1 or d 2 , as well as by the arc A 3 together with the hypothetically existing path d 3 or d 4 . If any of the paths d 1 , . . . , d 4 exists in the graph G (π ) then the solutionS π is unfeasible.
Length of any directed path in a solution graph has to be non-negative. Hence, if the path d 1 exists the following holds Algorithm 2: Fast feasibility detection (FFD).
ψ () ← generateFunctionPsi(π, G (π )); /* ψ() returns k,i for a given node */ /* checking cycles based on re-circulated operations: ] then return false; /* checking cycles based on the paths d 1 , . . . , d 4 respectively: if H (α (x)) ≥ H δ A (s) + w (α (x)) then return false; return true; /* the target solution must be feasible */ end Thus, (11) is necessary for existing the path d 1 and the cycle closed by this path. Analogous conditions can also be formulated for the paths d 2 , d 3 and d 4 . These conditions are used in the FFD procedure (Algorithm 2). This algorithm rejects all unfeasible moves and it also rejects some feasible moves, because the verification is based on the necessary condition of unfeasibility. The algorithm checks separately the cycles closed by re-circulated operations (re-circulation is not forbidden by the CF-FJS formulation), because the conditions based on the paths d 1 , . . . , d 4 are not applicable for them.

Algorithm implementation
Issues specific for the actual implementation of the algorithm are described below. Length of the tabu list Length of the tabu list tl is delimited dynamically as follows The value fmc (−i) (feasible move counter) represents the number of feasible moves from ith iteration backwards. The parameter tl * denotes previous length of the tabu list. Hence, the new length is a fraction of the mean number of feasible moves from last tl * iterations, with additional lower and upper bounds. The value tl simultaneously defines that the new tabu list length will be used for next tl iterations. When the algorithm starts, the tabu list has the initial length given by the parameter tl INIT . Level switch condition This condition is the base of the SILS procedure. The algorithm starts with the search intensification level L1 (neighbourhood N L1 ) and switches to the higher level when the ability of objective improvement expires for the given neighbourhood. The level switch condition from the level lv to the higher one is derived as the following boolean parameter where n lv is the number of all iterations in the current intensification level lv, n WI lv is the number of last iterations without objective improvement, the parameters R MIN lv , R MAX lv ∈ N define absolute minimum and maximum number of iterations and S lv ∈ (0, 100%) defines relative switching ratio. Fast feasibility detection The FFD procedure (Section 5.2) is used for elimination of unfeasible moves when neighbourhood is inspected. If a move is determined as unfeasible by the FFD it is dropped without further evaluation, however, its attribute is not added to the tabu list. Aspiration criterion The simple aspiration criterion is applied which accepts a forbidden move if it improves the global best result. Stop condition The stop condition is defined as the boolean parameter where t is the algorithm running time. Thus, the algorithm stops when the last level of search intensification expires or the given maximum scheduling running time t MAX is reached.

Simulation experiments
The algorithm parameters have been tuned experimentally. The following values have been used in all simulations: • The parameters related to the tabu list length control: tl INIT = 10, tl R = 10, tl LB = 5, tl UB = 100.

Dedicated benchmarks
A set of ten benchmarks have been prepared to verify algorithms for solving the CF-FJS problem. For each benchmark instance, the number of jobs (from 30 to 150) and the number of machines (from 20 to 120) have been defined arbitrarily. Other parameters have been drawn from given ranges. Detailed benchmarks description and files with generated instances are available as supplemental online material (Appendix B) and also on the web page http://cffjs.kia.prz.edu.pl.

Results
Scheduling algorithm with the primary stop condition (12) was executed 100 times for each benchmark instance. The set of solutions for the instance N is denoted as S N prim and the set of all solutions, that is 10 N=01 S N prim , is denoted as S prim . One scheduling without time limitation (t MAX → ∞) was also executed for each instance. The results of this scheduling for the instance cff_N and for all instances are denoted as S N wtl and S wtl , respectively. Makespan and scheduling time collation are presented in Table 2. For each set S N prim , the minimum (best), maximum, mean and standard deviation values of the results are calculated. The makespan values are well concentrated and maximum coefficient of variation (i.e. stdev mean ) equals 4.21% for cff_04. The coefficient of variation of the scheduling time is more influential and reaches values up to 130 % for cff_01.
Comparison of the best makespan from S N prim and S N wtl presented in column Cmp (Table 2) is calculated according to the relation It shows that the maximum scheduling time (1 h) limits quality of results for benchmark instances from cff_06 to cff_10. In the column BKS, the minimum makespan values are inserted, selected from S N prim or S N wtl for each instance, thus, they should be considered as the first best known solutions of the CF-FJS.
To verify efficiency of the SILS procedure, additional simulations have been performed. Instead of using level switching L1 → L2 → L3, simulations have been run only with L1, L2 or L3 separately, with 20 repetitions for each level. Other conditions have been determined by the primary algorithm configuration. The sets of solutions for the benchmark instance cff_N are denoted by S N L1 , S N L2 , S N L3 and for all instances by S L1 , S L2 , S L3 . For these solutions, makespan statistics and makespan comparisons with reference solutions from S prim are prepared and presented in part (a) of Table 3). The comparisons are based on the relation The scheduling based only on L1 gives definitely poor results. The solutions based on L2 are closer to the reference makespan values. The results obtained with L3 are very good for some benchmark instances, even slightly better than the reference values. However, they are the worst for other instances (cff_09, cff_10). The general finding is that the level switching L1 → L2 → L3 is definitely better than using constant search intensification. The SILS gives propitious results for every cff instances, thus, the SILS improves scalability of the algorithm. This is evident from Figure 5. Comparisons of iteration numbers and simulation times with decomposition into three search intensification phases for solutions from S prim are shown in part (b) of Table 3. The data are expressed as mean absolute value and in percentage. The iteration number is most often the largest for L2, but all levels for almost all benchmark instances are active at least by 10% of iterations. In the time domain, level L3 dominates distinctly. This is because the iteration to time ratio (I/T) decreases largely for consecutive levels.
Simulations have also been performed to verify impact of the FFD procedure. The algorithm modified by deactivation of the FFD has solved each benchmark instance 20 times. The sets of solutions for the instance cff_N and for all instances are denoted S N wffd and S wffd , respectively. The FFD has not been used for selection of feasible moves, but predictions of the FFD have been registered for statistic purposes. The results from S wffd are compared with reference solutions from S prim . The results (Table 4) show that the FFD has classified moves as feasible or unfeasible in proportion about 1:2 for each problem instance (columns F and U). The procedure detects typically from 50 to 60% of actually feasible moves (column F / S). This reduces neighbourhood and shortens the time of a single algorithm iteration. The final effect is profitable, especially for larger instances of the scheduling problem, as the comparison in Table 4 shows, which is calculated according to the relation

FJS benchmarks
The CF-FJS scheduling problem is a generalisation of the standard FJS. This fact has been used to perform an additional test of the implemented algorithm using the classic FJS benchmarks mk_01..mk_10 (Brandimarte 1993). Scheduling has been repeated 100 times for each benchmark. A set of results for the benchmark mk_N is denoted as S N mk . The results are shown in Table 5. The best known values of lower bound (LB) and upper bound (UB) of makespan are referred from the work of Geiger (2012). The comparison (Cmp) is calculated according to the relation  The advantageous impact of the main auxiliary procedures, i.e. the SILS and FFD, has been verified by experiments. These procedures lead to better objective values obtained without meaningful increase of computational time cost. The SILS mechanism also enhances scalability of the algorithm. The scalability is improved by dynamic length of the tabu list as well. The evidence of the good scalability is that all benchmark instances from the cff and Brandimarte sets with very diversified sizes can be solved by the algorithm with fixed parameters and the values of the objective are well concentrated. It suggests no influential problems with blocking in searching cycles or in local optima.
The proposed solution can be used in real-world applications. The published benchmark instances and the presented optimisation results can be helpful in testing new scheduling algorithms for the CF-FJS.
Future work on the presented scheduling problem is intended. In the formulation of the CF-FJS problem, it is assumed that exactly one machine is chosen for each operation. However, because of continuous material flow, it is possible and may be advantageous in practice to distribute processing of a single operation over several machines. To introduce such an extension, material flow splitting and joining procedures have to be added to the CF-FJS. The splitting is ambiguous, because for each machine available for an operation, the decision has to be taken whether the machine should be involved in processing the operation and in what interval of time. It implies that the extended formulation will have greater computational complexity. The splitting and joining procedures will also make it possible to model of operations precedence other than linear in which, for example, a number of parallel processing paths inflow into a single machine. It is also planned to extend the problem formulation with additional parameters, important in practice, such as release times, set-up times and transport delays.