Comparative Analysis of Exact, Heuristic and Metaheuristic Algorithms for Flexible Assembly Scheduling

Real-world manufacturing scenarios usually lead to difficult assembly scheduling problems. Besides strict precedence constraints between jobs or operations, such problems incorporate constraints related to maintenance activities on working stations (machines) and specific setup times when different operations are executed on the same machine. This paper analyzes the performance of several approaches, based on mathematical programming and on (meta)heuristics, to solve flexible assembly scheduling problems characterized by an arbitrary tree-like structure of the operation network. In this context, a specific encoding of candidate solutions and some specific perturbation operators are proposed. The encoding and the operators allow the distribution of sub(batches) of operations on several machines which leads, for some assembly scheduling problems, to a significant decrease of the makespan.


I. INTRODUCTION
S CHEDULING represents a class of optimization problems with significant practical impact.The most studied problem is the Job Shop Scheduling problem (JSSP) [1] aiming to find an assignment of a set of inter-related jobs on a set of working resources (machines) such that some performance measures are optimized.
Assembly production scheduling is a class of scheduling problems (as identified in [2]), where a product is obtained by assembling several components (also referred to as subassemblies, subproducts or make-parts) which are a result of either some production operations or other assembling steps.Hence, the final product is the result of a particular set of operations, which are inter-related according to a hierarchical structure.Numerous factors, such as the number of operations, the number of products, the number of machines, the complexity of product structure, and the number of constraints, can increase the scheduling problem's complexity.Therefore, ongoing research in the field of scheduling is always necessary.
As is mentioned in [3] flexible assembly job-shop scheduling is less studied than job-shop scheduling.Previous work on Assembly Production Scheduling includes effective heuristics, This work was supported by project POC/163/1/3/ "Advanced computational statistics for planning and monitoring production environments" (2022)(2023) genetic algorithms [4], or machine learning-based solutions.In [5], the authors propose a heuristic, based on the concept of the critical path, for solving the problem of large assembly production having as objective the minimization of the makespan.Another heuristic that targets the problem of assembly scheduling by taking into account the splitting of the operations in several (sub)batches was introduced in [6].The load is distributed among the available machines using the proposed heuristic, followed by actual scheduling based on the critical path approach.In [7], the authors also include a batch splitting procedure; however, it is followed by a genetic algorithm to perform the scheduling.
The aim of this paper is to analyze several assembly scheduling strategies that are flexible enough to accommodate specific characteristics of the production process, e.g. the maintenance activities.The main contributions of the paper include: • specific encoding of candidate solutions and specific perturbation operators which ensure the feasibility of generated schedules and allow the distribution of sub(batches) of operations on several machines, leading to a significant decrease of the makespan; • design and implementation of a highly configurable generator of assembly scheduling test problems; • a comparative analysis of the performance of an exact solver, a heuristic based on the critical path concept, and two metaheuristic algorithms.
The rest of the paper is organized as follows.Section II proposes a motivating manufacturing scenario, while the particularities and the formal description of the scheduling problem are presented in Section III.A short review of recent works addressing similar problems is presented in Section IV.Sections V and VI provide details on the heuristic based on the critical path and present the proposed encoding, the algorithm for generating feasible initial schedules, the decoding and evaluation procedures as well as the proposed search operators used by the metaheuristic algorithms.The data generator structure, the experimental setup and results for some test problems are presented in Section VII, while Section VIII concludes the paper.

II. A REAL-WORLD SCENARIO
A real-world problem that triggered our study is the production of flexible metal tubes for car exhaust systems.The final product is composed of subproducts that are result of production (SP ) or assembly (As) operations.The manufacture process of the product is described using the bill of materials (BOM), that contains all information used to produce an item: the raw materials (RM ), the (sub)products, the quantity needed to by for each manufactured product (BOM for milltube production -Figures 1).
A mill tube is formed from two component tubes (referred as IT and OT in Figure 1) that are covered with a metal mesh.Interlock rings are used as a fastening system.The production process can be shortly described as follows: (1) the inner tube (subproduct IT ) and the outer tube (subproduct OT ) are produced from a metal sheet (RM ) that has to be rolled, welded and cut on a specific machine (operations O 6 and O 7 ); (2) the resulting tubes are transformed in bellows (subproduct E) through a stuffing process (O 5 ); (3) meantime: (i) the metal mesh (product F ), that covers the tube built in the hydroforming process (O 4 ), is produced from metal wire (O 10 , O 9 , and O 8 ); (ii) the interlocks (subproduct C) are produced also from metal wire (O 3 ).
The assembling process, that has as result the product B, is executed on assembling workstations (O 2 ) and it consists of: (i) the bellows are wrapped with the metallic mesh; (ii) the interlocks and garnish are added; (iii) the final product is pressed; (iv) some identification information is written on the product.Then a quality assurance control ( O 1 ) is done and the product, A, is packed.
Beside the information related to BOM other production information, like the machine characteristics on which the operations are executed, must be provided.Table I contains the characteristics (setup-time, unit processing time) of the set of machines ({M 1 , M 2 , . . ., M 19 }) that are used in mill tube production.

III. PROBLEM DESCRIPTION
The result of an assembly manufacturing process is a product that consists of many components, each of the components being either manufactured or obtained by assembling several other (sub)components (also called make-parts).The operations involved in this process are either of manufacturing type or assembling type.
The main difference between these two types of operations is that a manufacturing operation usually requires only one previously produced component (and potentially several raw materials), while an assembling operation requires several other (sub)components which should be produced by the time the assembling operation starts.In the tree-like structure of an assembly (see Figures 1 and 2) the manufacturing operations correspond to nodes having only one child, while the assembly operations correspond to nodes having at least two children.The Assembly Scheduling Problem (ASP) aims to schedule all types of operations on a set of machines in such a way that all make-parts are finalized before they are required for an assembly operation.The main particularity of this problem with respect to the standard Job Shop Scheduling Problem is that the precedence relation between operations corresponding to one assembly product (i.e. one job) is not a total order relation.
This allows the extension of one assembly product scheduling to several products by just considering a dummy assembly operation that would virtually group all products.
Therefore, in the following, we will consider the operations corresponding to all products (jobs) being grouped in one set of operations on which there is a partial order precedence relation.

A. Characteristics of the assembly scheduling problem
The class of assembly scheduling problems addressed in this paper is characterized by: • all required raw materials are available, thus at the beginning of the scheduling time horizon all operations that do not have predecessors can start;  • at a given moment, a machine can process only one operation and once started, an operation cannot be interrupted (non-preemptive); • the operations can be grouped in batches and (producing a batch of components or products) started, it cannot be interrupted; • once established, the size of a batch is not modified; • for a given operation only one batch of executions can be scheduled on a machine (re-entrance is not allowed); • there is no cost for transferring components between machines; • no setup is required if the operations (corresponding to different batches of same type of (sub)components or products) are scheduled in sequence on the same machine; • the setup times are sequence-independent and nonanticipatory (the machine is available and the operation is ready to be started); • the maintenance activities are considered as machineassigned operations with fixed starting time and duration.

B. Formal description 1) Notations and input data:
• Set of n operations: {O j |j = 1, n}; • Set of m machines: {M i |i = 1, m}; • t ji = time to execute on machine M i one unit of the (sub)component which is a result of operation O j ; • s ji = setup time for executing the operation O j on machine M i ; • Q j = total number of executions of operation O j derived from the quantities specified in the BOM structure; • F = matrix of eligibility, an n × m matrix specifying which machines are eligible for each operation, i.e.
• R = array of n entries which can be used to identify the subset of maintenance operations, i.e.
in which case R j denotes the maintenance starting time (SM i ) on the machine M i which satisfies the condition More specifically, the elements of R are defined as: The maintenance starting times are fixed and known before the scheduling process is started.
• π(j) = {k|O k is a child of O j in the operation network} describes the direct predecessor relation, i.e. π(j) is the set of indices of operations which directly precedes O j , thus they should be finalized before the starting moment of O j (one operation can have several direct predecessors); • σ(j) = k where k ∈ π(j) (one operation can have only one direct successor) and σ(j) = −1 if O j is a final operation (its result is a final product); • Deadline for the final operations: D j ∈ [0, T ] for any j ∈ {1, . . ., n} such that σ(j) = −1.

2) Decision variables:
For j = 1, n and i = 1, m: • Assignment matrix: • Batch splitting matrix: where b ji ∈ N denotes the number of consecutive executions of operation O j on machine M i leading to the production of a batch of b ji (sub)components that are specific to operation O j ; • S ji ∈ [0, T ): starting time of O j on M i (T is the time horizon for the assembly production);

C. Constraints
• (C1) All operations are assigned on eligible machines: • (C2) The assignment and batch splitting matrices are consistent (an operation assigned to a machine should be Authorized licensed use limited to the terms of the applicable license agreement with IEEE.Restrictions apply. executed at least once and the number of executions of an operation on a machine is nonzero only if the operation is assigned to that machine): The completion time of any operation O j is smaller than the starting time of its succeeding operation O σ(j) : The time intervals corresponding to operations executed on the same machine are disjoint: ∀i ∈ {1, . . ., m} such that A j1i = A j2i = 1 • (C5) Completion time of a batch of operations: The sum of all batch sizes corresponding to an operation equals the total quantity which should be produced by that operation: • (C7) All final operations are finalized before the corresponding deadlines: such that σ(j) = −1, A ji = 1.• (C8) The starting time for maintenance operations is fixed: such that

D. Objective function
The goal of the scheduling is to minimize the makespan, C max , defined as: where E = {j|σ(j) = −1} is the set of final operations.Thus, the optimization problem is: IV. RELATED WORK The authors of [8] addressed the problem of flexible assembly job-shop scheduling with lot streaming.The analyzed production structure is a two-stage one, characterized by the presence of an assembly stage at the end of a flexible job shop.The jobs in the first stage are processed in large batches which might lead to waiting time.The proposed approach is to split the batch into sub-batches, thus the initial scheduling problem is split into two sub-problems: batch splitting and batch scheduling.The proposed solution is based on an Artificial Bee Colony (ABC) algorithm using a population of candidates encoded based on four one-dimensional arrays: (i) an array containing the number of (sub)batches corresponding to each job; (ii) an array containing the size of each (sub)batch; (iii) an array encoding the sequence of all (sub)batches of operations; (iv) an array specifying the machine on which each (sub)batch of operations is assigned.The size of each candidate solution depends on the number of (sub)batches.
The idea of using sub-batches of unequal sizes is exploited also in our study but in the more general context when the production process involves several assembly stages.
An assembly scheduling problem involving several assembly stages which induce additional precedence constraints between jobs is approached in [3] where a genetic algorithm (GA) is used to solve it.Each element of the population evolved by the GA consists of two parts: (i) a one-dimensional array used to encode the machine assignment; (ii) a twodimensional array for encoding the sequence of operations based on the concept of level in the operations' network.A schedule is constructed through a decoding process in which the operations are allocated to the first time slot where they fit, in the order given by the structure of the two-dimensional array.
With respect to the structure of the operations' network, the approach proposed in [3] is consistent with the particularities of the problem addressed in this paper, but it does not allow batch size control and to distribute sub-batches of operations to different machines.
In [9] a lot streaming technique, that splits jobs into subjobs, is applied on an assembly job shop scheduling problem (AJSP).The authors split the problem into two sub-problems (i) determine a sub-lot split; (ii) solve AJSP problem.In order to solve the sub-lot split, a genetic algorithm is used that uses a matrix, that stores on each line the number of lots for each operation and the quantity for each lot.In order to resolve the assembly problem four simple dispatching rules are used.The lots are scheduled by shortest/longest processing time, earliest due date, minimal slack time (difference between the due date and the total processing time of the operation) such that the constraints derived from the BOM are satisfied.In [10] the authors extend the work for [9] and use genetic algorithm and particle swarm optimization metaheuristics to solve also the second problem, by incorporating into the solutions the information related to the order of operation on each machine.
The approaches proposed in [9], [10]  ones discussed in this paper by the fact that the operations can be execute on a sub-set of machines not on all available machines.

V. HEURISTIC BASED ON THE CRITICAL PATH
In [5], the authors introduced the Lead Time Evaluation and Scheduling Algorithm (LETSA) that uses a critical path heuristic in order to construct a scheduling.Based on the operation networks, the LETSA algorithm creates a list of feasible operations, F, i.e. operations for which their successors have been already scheduled.In the beginning, F contains the operations generating the final product(s).
The scheduling process consists of several steps (see Algorithm 1) starting with the identification of critical paths that originate in all operations of F. For an operation O j , a critical path is a sequence It should be mentioned that if a machine satisfying all conditions specified in Step S3 of Algorithm 1 is not found, then the tentative execution interval is shifted toward the left until the first availability interval is reached.In this way, a machine is always identified.
The problem addressed in [5] is slightly different from that addressed in this paper because the operations are executed in a work-centers that contain one or more identical machines.In our approach, the machines are not necessarily identical, so the following adaptations were done: (i) in order to calculate the critical path in Step S1 of Algorithm 1, the maximal execution times over all eligible machines are used; (ii) the list of potential machines analyzed at Step S3 of Algorithm 1 is limited to eligible machines characterized by the smallest execution times for the corresponding operation.This has been done with the aim of increasing the chance to generate schedules with smaller makespan.

VI. METAHEURISTIC APPROACHES
For the metaheuristic algorithms used in the experimental analysis, the encoding and decoding procedures, as well as the search operators are described in the following.

A. Encoding and search space
According to [8], a flexible assembly scheduling with batch splitting involves several decisions: (i) in which sequence are executed the operations on each machine; (ii) on which machine is executed each sub-batch corresponding to each operation; (iii) which is the size of each sub-batch for each operation.
In order to incorporate the information required by these decisions we propose the following encoding for a candidate solution: with o (l) ∈ {1, . . ., n}, such that for any 1 ≤ l, r ≤ n, if o (l) ∈ π(o (r) ) then l < r; • the batch-splitting matrix B ji defined as in Eq. ( 4).The order of operations given by list L corresponds to a topological order of the nodes in the operation network.L provides the order in which the operations are dispatched to machines, during the decoding step, but not necessarily the order in which they are executed in the production stage.More specifically, if O o(l) and O o(r) belong to the same branch in the operation tree-like network, then O o(l) will be executed before O o(r) , but if they belong to different branches then O o(l) will be dispatched before O o(r) , but not necessarily executed before O o(r) .It should be noted that the maintenance operations are not explicitly included in the encoding, as their starting times and durations are fixed.They are taken into consideration only during the evaluation step.
An operation list, L, corresponding to the operation network described in Figure 2 is illustrated in Figure 3 where the arrows highlight the direct predecessor relations between operations.As follows from this figure, such an operation list corresponds to a topological order of the operation network.This ordering is not unique.In fact, for an oriented tree T with n nodes the total number of topological orderings is n!/ v∈T µ(T v ) where v denotes a node, T v denotes the (sub)tree rooted in the node v and µ(T v ) denotes the number of nodes in the (sub)tree rooted in v.For the tree corresponding to the operation network from Figure 2 the number of distinct topological orderings is 10!/(10 O10 O7 O9 O6 O8 O3 O5 O4 O2 O1 Fig. 3.An operation list corresponding to the tree-like BOM described in Figure 1 which illustrates the topological order of the operations. Taking into account both the operation list and the batch size matrix, B (see Table II), the proposed encoding allows solving batch splitting and batch sequencing problems simultaneously and corresponds to a structure of size n + n • m.This size is larger than that corresponding to traditional encoding based on two one-dimensional arrays of n elements (operation sequence array and machine assignment array).However this traditional encoding does not allow to distribute batches of operations on parallel machines.

B. Generation of initial candidates
The metaheuristics start from one or several initial candidates, which are further modified with the aim of improving its/their quality.The generation of initial candidates should take into account the encoding rules and the structural constraints which should be satisfied by a feasible candidate, i.e. precedence constraints induced by the operation network and constraints related to the number of components to be produced (induced by the corresponding bill of materials).The construction of the list L, corresponding to the topological order, starts from the root node, O 1 , and the frontier, F, consisting of its directly preceding operations, π(O 1 ), and select, at each step, a random element from the current frontier to be added in the front of list L. As soon as an operation is included in L, it is removed from F which is instead extended with all operations which directly precede the operation included in L. In this way, one of the possible topological orderings of the nodes in the operation network is generated.The matrix B can be initialized using random decisions concerning both the selection of machines from the eligible list and the choice of the batch size.The random function used in Algorithm 2 generates an integer value in {0, 1, . . ., q}.A minimum batch, min Qj size of 10% of operation quantity is used in order to restrict small batch sizes.

C. Decoding and evaluation
From a candidate solution, represented by the onedimensional array L and the two-dimensional array B, a schedule is obtained through decoding.The decoding process, described in Algorithm 3 allows also the computation of the makespan value, and it is activated any time a candidate solution has to be evaluated.The operations are scheduled based on the order specified in the operations list (L).If a part of the quantity (B ji ) of operation O j is planned to be scheduled on machine M i , the decoding procedure identifies the time interval in which it can be executed on that machine.The operation is scheduled as close as possible to the completion time of all of its preceding operations (π(j)).This means that for each machine the completion time of the last scheduled operation is dynamically updated and further used to establish the starting time of next operation to be scheduled on that machine.Thus the order defined by L is preserved on each machine.
It should be mentioned that the value of the makespan is influenced by the following decisions: • split the batch of operations scheduled in a time interval which overlaps with a maintenance interval in such a way that the maximum possible amount operation products is executed before the maintenance activity and the remaining ones immediately after the maintenance (opt_maintenance flag is activated in Algorithm 3) ; • no setup is required when two consecutive batches involving the same operation/product are scheduled (opt_setup flag is activated in Algorithm 3).

D. Search operators
Both trajectory and population-based metaheuristics require operators which generate new candidate solutions from existing ones.The metaheuristic algorithms involved in the analysis we conducted involve two main types of operators which generate new candidate solutions: • Mutation-like.This operator generates a new candidate solution in the neighborhood of an existing one by applying a perturbation strategy.
The way of action of these operators is shortly presented in the following, the guiding idea being to preserve the feasibility.
1) Mutation : Let us consider a candidate solution encoded by (L, B).A new candidate is generated in the neighbourhood of (L, B) by following the steps: • randomly select o (q) ∈ L; • search for the largest l ∈ {1, . . ., n} such that o (l) ∈ π(o (q) ) and for the smallest r ∈ {1, . . ., n} such that o (q) ∈ π(o (r) ); if operation o (q) does not have predecessors then l = 1 and if o (q) does not have a successor then r = n; • randomly select an insertion position p ∈ {l, l + 1, . . ., r} and insert the element o (q) on position p in L; • if there are several eligible machines for operation o (q) , then randomly select two of them and move the batch (totally or partially) from the source to the destination machine; the decision to perturb B is taken with a given probability.It is easy to observe that all operations in the sublist of L delimited by l and r (L l..r ) do not contain operations that are in a precedence relation with o (q) , meaning that the perturbed candidate solution is still feasible.
It should be also mentioned that if the list of eligible machines for operation o (q) and the lists of machines corresponding to the operations in the sublist L l..r are disjoint, then any insertion of o (q) in another position of the sublist will have no impact on the makespan of the schedule obtained by decoding the candidate solution.On the other hand, if o (q) return C max is one of the final assembly operations, then l = r and the perturbation will be ineffective.
Let us consider the L-part encoding corresponding to the example illustrated in Figure 3: L = [10, 7, 9, 6, 8, 3, 5, 4, 2, 1].If the selected element is o (5) = 8 then l = 4 and r = 8, thus there are four alternative insertion positions for the value 8.However, as the machines M 16 and M 17 are not used by the other operations, all of these perturbations will be without impact on the makespan.
2) Crossover : The crossover-like perturbation aims to generate a new feasible candidate solution by using information from two existing ones, usually called parents.The feasibility is preserved if the idea of precedence operation crossover is used: some elements are taken from one parent, while from the other parent is used to order in which the remaining elements are placed.Let us consider L = [o (1) , . . ., o (n) ] and ] and the corresponding batch size matrices B and B ′ .The steps followed to construct a new feasible candidate, (L new , B new ), are: tween l and r; • scan the elements of L ′ and for each element o ′ (l) which is not yet in L new append it to a prefix list L P , if o ′ (l) is the predecessor (not necessarily direct) of at least one element of L new ; a suffix list L S if there is no element in L new such that o ′ (l) is its predecessor.• the new candidate solution is obtained by joining L P , L new and L S ; • the rows of B new corresponding to the operations taken in the first step from L will be identical to the corresponding rows from B, while the other rows are taken from B ′ .
Let us consider, in the case of mill tube example, two candidate solutions: L = [6, 10, 7, 5, 9, 4, 3, 8, 2, 1] and L ′ = [10, 7, 9, 6, 8, 3, 5, 4, 2, 1] In the case when l = 4 and r = 9, applying the crossover operator leads to L new = [10, 7, 6, 5, 9, 4, 3, 8, 2, 1] which could be also generated from L by mutation (insertion of the first element on the third position).However, the crossover-like perturbation allows the generation of new candidates which would not be generated through one-step mutation.For instance, for the same L and L ′ from the above example, if l = 2 and r = 5 one obtains L new = [6, 10, 7, 5, 9, 8, 3, 4, 2, 1] which could not be obtained by mutation neither from L nor from L ′ .Ensuring the feasibility of the crossover result requires checking the precedence constraints, thus this operator induces a computational cost larger than that of mutation.

A. Data generator
Despite the increasing interest in ASP, there are no benchmarks for the general assembly scheduling problem.Some of the works addressing the flexible assembly scheduling problem [8], [11] use benchmarks that have been originally proposed for flexible job-shop scheduling problems, e.g.Kacem benchmark [12] and Fattahi benchmark [13].Recently, Talens et al. [14] proposed two extensive sets of instances for the 2-stage assembly scheduling problem, one corresponding to the case of one assembly machine and the other one corresponding to the case of several assembly machines.
Since the problems included in these benchmarks do not capture all characteristics of flexible assembly scheduling, we designed a problem generator that allows the generation of a large variety of assembly scheduling problems characterized by different operation networks and different sets of eligible machines.
The problem generator has a simple architecture, as illustrated in Figure 4.The generator uses: • a pool of products that represent the entities included in the bill of materials corresponding to a client order.Currently, the generator uses a list of 200 of fictitious entities (which can be interpreted as products, components or make-parts), characterized by randomly generated names; • a pool of machines that can be used to execute the operations.Currently, the generator uses a list of 20 available machines.
The characteristics of a problem instance are specified in a configuration file that contains the values of the parameters describing the BOM structure.
In order to provide a high level of flexibility to the generated BOMs, the configurator module can be loaded with a multitude of parameters such as the number of levels in BOM, meaning the number of operations needed to be completed to create the final product, a maximum number of children for each node, meaning that a certain product is the result of assembling one or more simpler parts.One can specify the size of the product pool that is considered for this generator and the time horizon for scheduling.Also, the quantity of the final products can be provided.Another important characteristic that is supported is related to the maintenance applied to the machines involved in the product fabrication.The generator supports the setting of maintenance time intervals, the Overall Equipment Effectivness (OEE) for the machines and also one can specify the setup time for the machines if there is a need to change its purpose to support the processing of another product.The values can be generated using either an uniform distribution over the range of feasible values (the default case) or a truncated normal distribution.
The generator produces a JSON file containing the description of a tree-like structure corresponding to a BOM with a specified depth and a variable number of children, each node in the tree representing a specific product and including the generated set of eligible machines.The root node corresponds to the final product, while the children correspond to components that eventually will compose the final product.

B. Test problems
The experimental analysis is based on several problems instances/sets that have been generated such that various characteristics of the problem are emphasized: • A real-world case study: the mill tube problem incorporating three orders of sizes 800, 320, and 160, each order requiring the production of the specified number of tubes according to the BOM described in Figure 1.

C. Methods and control parameters
The methods involved in the comparative analysis are: • An exact solver (CPLEX) used to solve the problem described in section III-B.The solver is executed using 32 threads and CPLEX control parameters have been used with their default values.It should be mentioned that besides the problem described in section III-B which corresponds to the case when batch splitting is applied, a simplified version that does not require the B matrix as decision variables is also analyzed (referred to as standard in Tables III and IV).• An implementation of the LETSA heuristic as it is described in section V.The standard variant does not use batch splitting while the variant with batch splitting (BS) applies a load-balancing strategy in order to distribute the operations per eligible machines.It should be mentioned that LETSA heuristic starts the construction of the schedule from the final operation, while the other heuristics start from the leaf operations in the operation network.Since the maintenance intervals influence the solution quality, the solution generated by LETSA is shifted such that the leaf operations are scheduled closer to the start time.LETSA does not require control parameters.• A Tabu Search (TS) algorithm based on the mutationlike perturbation described in Section VI-D1.It should be mentioned that when a new candidate (neighborhood element) is constructed, the batch-size matrix (B) is perturbed with a probability equal to 0.15.The neighborhood size is set to 100 and the tabu-list size to 25.If the current candidate solution is not improved in the last 50 iterations then it is replaced with an element selected from the current neighborhood.The implementation uses 32 parallel search processes.• A Genetic Algorithm (GA) which evolves a population of 100 elements by applying the same perturbation as in TS (with the same mutation probability for the batchsize matrix), the crossover operator described in Section VI-D2 and proportional selection.The crossover operator does not use control parameters.It should be mentioned that the TS and GA implementations are adapted starting from the JSSP implementation available at 1 .
All experiments have been run on a machine with 64 vCPUs and 256 GB RAM.The execution timeout was set to 1 hour for CPLEX and 3 minutes for LETSA, TS and GA.For TS and GA the reported makespan is the average value of 30 independent runs.

D. Results and discussion
The results obtained for the mill tube study case are presented in Table III which contains the makespan values (in hours) corresponding to various methods.Since the BOM structure is rather simple and most of the operations use distinct machines the optimal solution is obtained by CPLEX, TS and GA without batch splitting (BS).On the other hand, since the number of products and make-parts corresponding to all orders is rather large, the batch-splitting strategy improves the makespan by around 40% in the case of CPLEX, TS and GA, and around 20% in the case of LETSA.
The control of the maintenance intervals and setup times corresponding to successive execution of batches of identical operations can further improve the makespan but not significantly.The Gantt charts (Figure 5) illustrate the fact that the benefit of BS is influenced by the number of machines on which the batch of operations can be distributed.
The positive impact of batch splitting is illustrated also in the case of the operation networks with deep structure (see Table IV), particularly in the case of TS.The poorer behavior of GA can be explained by the fact that the crossover operator is more time expensive than mutation and, because of the imposed limit of time, the exploration of the search space is limited.It should be noted that in this case, CPLEX could not provide a solution in the allocated amount of time (one hour).To analyze the scalability of the investigated methods we used the set of BOM structures with variable number of operations in the context when a set of 10 machines are available and an operation can be executed on at most 5 machines with different or similar characteristics.
From Figure 6 it can be observed that the exact solver was able to find solutions for problems having up to 183 operations in a time interval of one hour.TS and GA heuristics outperform LETSA heuristic, and TS is slightly better than GA.

VIII. CONCLUSIONS AND FURTHER WORK
The particularities of the addressed assembly scheduling problems required the incorporation of some specific decision variables and constraints.Most mathematical programming models used in flexible job-shop scheduling include binary variables which encode the order between any two operations scheduled on the same machine that leads to n 2 • m binary variables (in the case of n operations and m machines).The proposed mathematical programming model avoids the The proposed problem description and the candidate solution encoding allow specifying the distribution of (sub)batches of identical operations over several machines which led to a significant reduction in the makespan, particularly in the case of large orders.
The strategy that takes into account the maintenance time intervals and removes the unnecessary setup activities proved also to be beneficial but to a lesser extent.
As the operator inspired by the precedence preserving orderbased crossover proved to be computationally intensive, we will further investigate other operators which preserve the feasibility of candidate solutions.Since the critical path heuristic Authorized licensed use limited to the terms of the applicable license agreement with IEEE.Restrictions apply.
incorporated in LETSA generates relatively good solutions in a fraction of the time required by the metaheuristic algorithms, a further step would be to consider the sub-optimal solution produced by LETSA among the initial candidate solutions for the metaheuristic algorithms.We also plan to conduct a systematic scalability analysis based on sets of test problems including various typologies of operation networks and interactions between operations with respect to the lists of eligible machines, as reflected in the corresponding conjunctive graphs of the scheduling problem.

Fig. 1 .Fig. 2 .
Fig.1.Bill of materials networks for mill tube scenario.Each node contains information regarding the obtained (sub)product: name (A, B, C, . . . ) quantity (Q:number), type (corresponding to a production process -SP or to an assembly process -As)

t
lq * is maximal.The notation t j * refers to the execution time of operation O j on the slowest machine (if the machines would have different execution times).

Fig. 4 .
Fig. 4. Architecture of the assembly scheduling problems generator

Fig. 5 .
Fig. 5. Gantt charts for the Tube mill problem generated using Tabu Search

Fig. 6 .
Fig. 6.Scalability results for standard variants of CPLEX, LETSA, TS, and GA for the 15 BOM structures 624PROCEEDINGS OF THE FEDCSIS.WARSAW, POLAND, 2023 OCTAVIAN MAGHIAR ET AL.: COMPARATIVE ANALYSIS OF EXACT, HEURISTIC AND METAHEURISTIC ALGORITHMS FOR FLEXIBLE ASSEMBLY 619 Algorithm 1 LETSA Algorithm Input: n, m, F 1..n×1..m , O 1..n , t 1..n×1..m , s 1..n×1..m Output: A 1..n×1..m , S 1..n , C 1..n F ← {O j |σ(j) = −1} while F ̸ = ∅ do (S1): select O j ∈ F s.t.O j belongs to a critical path (S2): set the tentative completion time for O j : C j * ← S σ(j)k , where k satisfies A σ(j)k = 1 (S3): find M i such that F ji = 1, M i is available in [C j * − t ji , C j * ) and maximizes C j * − t ji (S4): update the assignment matrix and the completion and starting times: A ji ← 1; C ji ← C j * ; S ji ← C ji − t ji Initialization of a feasible candidate Input: n, m, F 1..n×1..m , Q 1..n Output: L 1..n , B 1..n×1..m • Crossover-like.A new feasible candidate solution is constructed by combining information from two existing candidate solutions.620PROCEEDINGSOF THE FEDCSIS.WARSAW, POLAND, 2023Authorized licensed use limited to the terms of the applicable license agreement with IEEE.Restrictions apply.Algorithm 2 Algorithm 3 Decoding and evaluation of a solution Input: L 1..n , B 1..n×1..m , R 1..n ,D Output: S 1..n , C 1..n , C max // start time, completion time S 1..n ← D; C 1..n ← 0 M F T [1..m] ← 0 // current makespan per machine for h ← 1..n do j ← L h // schedule operation O j for i ∈ {1, . . ., m} such that B ji > 0 do if opt_setup = T rue and O j is identical with the last operation scheduled on • A deep BOM structure: it is characterized by branches of up to 50 nodes in the operation network and a branching factor of 2 (for an operation there are at most two operations that directly precede it).The problem instance used in experiments contains 437 nodes.•A set of BOM structures with a variable number of operations: it contains 15 problem instances corresponding to operation networks with a specified depth of 3 and a branching factor ranging between 2 and 16.The number of operations varies between 7 and 273.The quantity corresponding to each component (make-part) in the BOM is set to 10 (in this way each component on to the third level has a quantity equal to 1000).This set is characterized by rather wide structures and it was used to analyze the influence of the number of operations on the performance of exact, heuristic, and metaheuristic methods.

TABLE III MAKESPAN
VALUES (IN HOURS) FOR THE TUBE MILL PROBLEM.VARIANTS OF THE ALGORITHMS: STANDARD, BS (WITH BATCH SPLITTING), MSC (WITH CONTROL ON THE MAINTENANCE INTERVALS MAGHIAR ET AL.: COMPARATIVE ANALYSIS OF EXACT, HEURISTIC AND METAHEURISTIC ALGORITHMS FOR FLEXIBLE ASSEMBLY 623 1 https://job-shop-schedule-problem.readthedocs.io/en/stable/index.html OCTAVIAN Authorized licensed use limited to the terms of the applicable license agreement with IEEE.Restrictions apply.

TABLE IV MAKESPAN
VALUES (IN DAYS) FOR THE PROBLEM INSTANCE WITH DEEP STRUCTURE.VARIANTS OF THE ALGORITHMS: STANDARD, BS (WITH BATCH SPLITTING), MSC (WITH CONTROL ON THE MAINTENANCE INTERVALS AND SETUP TIMES)