Sustainable manufacturing requires energy-eficient scheduling, especially in metalworking, where machines like bandsaws consume significant power. Based on a real-world use case from an Austrian steel-cutting company, we extend the Energy-Aware Double-Flexible Job-Shop Scheduling Problem (E-DFJSP)-which already comprises machine and worker flexibility-with machine modes, as well as setup and transport operations. To tackle this problem, we propose a Constraint Programming (CP) model, implemented using the state-of-the-art IBM CP Optimizer (CPO), to minimize job tardiness, energy consumption, and makespan. We evaluate our approach on two datasets representing present and future production scenarios, each with up to 500 jobs. While CPO fails to find feasible solutions for several large instances in the less flexible scenario, it successfully solves all instances in the more flexible one, indicating that higher resource flexibility improves search performance. In terms of solution quality, CPO demonstrates stronger scalability in makespan than in tardiness minimization, with the addition of machines and workers further reducing the optimal makespan and easing problem-solving. Finally, we identified a bug in CPO afecting staticLex (fixed-priority multi-objective minimization) when combined with tolerance-based early stopping; to avoid it, we optimized each goal separately.
With growing global awareness of sustainability and environmental concerns, energy minimization has emerged as a critical objective across various sectors [1]. Metalworking operations, including sawing, grinding, and milling, are known for their significant energy consumption [ 2]. For example, a typical sawing machine requires 8.4 MWh per year, and a large metalworking facility may house 2500 machines, which, combined, would consume around 21 GWh per year, a value in the same order as 4,750 average Austrian households per year. In this work, we consider bandsaws, whose operations are determined by two key parameters—machine mode: feed rate and blade speed . Both parameters influence operation time, energy use, tool wear, and product quality. Selecting optimal parameters is complex, and most industries still use fixed values from lookup tables based on materials and dimensions [3, 4]. This leaves significant optimization potential, as the choice of a machine mode can afect the solution quality: slower modes may cause delays, while faster modes may increase energy cost and tool wear.
To address this trade-of, we formulate and solve a scheduling problem, based on a real-world scenario emerging from the Austrian metal-cutting industry, with the goals of minimizing job tardiness, energy consumption, and overall makespan. We assume that, for each operation, multiple machines may be eligible, and for each machine, various alternative machine modes are available, each having a corresponding duration and consumed energy. In addition, since metal pieces must be manually loaded (unloaded) by workers on (from) the machines, we account for the availability of the workers as well. This is a challenging task since the Job-Shop Scheduling Problem (JSP) is per se an NP-hard problem [5], on top of which we incorporate the choice of the machine, of the machine mode, and of the worker in order to minimize the mentioned objectives. As detailed in Sec. 2, and to the best of the authors’ knowledge, no work has yet undertaken the Energy-Aware Double-Flexible Job-Shop Scheduling Problem (E-DFJSP) [6] when extended with either machine modes, setup operations, or transport operations. Hence, this work is a first step towards closing a gap in the research literature concerning the integrated consideration of time and resource eficiency in a flexible production scheduling context.
The common methods used to tackle scheduling problems are Mixed Integer Programming (MIP), Answer Set Programming (ASP), and Constraint Programming (CP). Recent studies, e.g., [7], have shown that the MIP approach faces scalability issues when applied to scheduling problems. Other works, such as [8, 9], relied on clingo-DL [10], an extension of ASP, to solve large-scale scheduling problems. Yet, despite its efectiveness, ASP is designed for discrete problems, while in many scheduling applications, some variables and goals, such as the energy consumption, are intrinsically real numbers.
Therefore, we propose a novel CP model to solve the E-DFJSP problem. We employ IBM CP Optimizer (CPO) [11] as a solver, since CPO is one of the most popular state-of-the-art CP-based tools for modeling and solving scheduling problems [12, 13, 14, 15, 16, 17]. To evaluate the model, we introduce two datasets that reflect the structure of the E-DFJSP for two diferent use cases within the steel-cutting context of our industrial partner. Each dataset comprises between 50 and 500 jobs. The upper bound is used to assess the scalability of our approach and is more than twice the number of cutting jobs required in the actual use case. In the Present use case dataset , workers are preassigned to machines and jobs. In contrast, the Future use case represents a prospectively planned, more general production scenario where these restrictions are relaxed, giving rise to a general E-DFJSP problem.
As this study introduces a novel problem, there are currently no established state-of-the-art methods available for direct comparison. The model is evaluated by comparing its performance on both datasets within a timeout of 10 minutes under two diferent tolerance levels, 0% and 10%, representing relative deviations from the global minimum that are still considered optimal. Our most significant finding is that a valid schedule is always obtained for dataset . Moreover, in more than half of the runs on , tardiness is optimized, and in some cases, energy is as well. By contrast, although dataset is a special case of with lower flexibility, CPO does not always find a solution for its instances, particularly for the 500-job cases. Nevertheless, in most of the 50-job instances of , at least one goal is optimized. Finally, while makespan is rarely fully optimized in either dataset, its values remain consistently reasonable.
The remainder of the paper is organized as follows. A literature review is presented in Sec. 2, the basics of JSP are given in Sec. 3, the industrial use case is described in Sec. 4, and the CP model is proposed in Sec. 5. Our evaluation is illustrated in Sec. 6: the datasets are described in Sec. 6.1, the experiments’ design is given in Sec. 6.2, and the results are discussed in Sec. 6.3. Finally, Sec. 7 concludes.
Flexible Job Shop Scheduling (FJSP) has been widely studied over the past 50 years [18]. In recent years, multiple works have tackled the Energy-Aware FJSP (e.g., [19, 20]), mostly by relying on inexact methods, and in particular on genetic algorithms (GA), as they proved to be efective in many domains. The following works share the same objectives—the energy consumption and the makespan—and are single-resource, i.e., each operation requires only one resource, such as a machine, a crane, etc. In [21], a genetic algorithm and a CP encoding were proposed for addressing a JSP problem, i.e., not-flexible, but with controllable machine modes. [19] introduced a genetic algorithm to solve the FJSP with multiple machine modes, with the additional goal of minimizing the noise emission caused by milling and drilling machines. [20] proposed a hybrid method for solving an FJSP with transportation constraints, by including machines and cranes flexibility. [ 22] suggested a hybrid method for tackling a FJSP with setup and transport operations, where the means of transport were autonomous vehicles. [23] proposed a metaheuristic algorithm for solving an FJSP with transport time and sequence-dependent setup times, but without an explicit means of transport. Using a cooperative evolutionary algorithm, [24] tackled an FJSP with machines, cranes, and sequence-dependent setup times. Two studies considered the Energy-Aware Multi-Resource FJSP. In [6], the E-DFJSP was solved, as both workers and machines were included, and a hybrid algorithm was employed to minimize makespan, the maximum total labor cost, and multiple green objectives. Similarly, [25] discussed a Multi-Resource FJSP with both machines and workers. Yet, neither of them considered transport or setup operations, or machine modes.
In recent years, some works based on Constraint Programming (CP) have emerged. Notably, the following studies minimize energy’s Time-Of-Use (TOU) rather than the pure energy consumption. The TOU weights the energy consumption by its average cost over a fixed period of time, e.g., an hour. In [26], a model for solving the FJSP with TOU-optimization was proposed. Similarly, [13] studied the FJSP with TOU and preventive maintenance of the machines. Also, in [16], a comprehensive model was introduced, which accounts for real-time pricing, power peak demand, renewable energy sources, and carbon emissions, as well as setup times and machine availability. For readers more deeply interested in energy-aware scheduling, [16] provides an extensive introduction, and [27] a noteworthy review.
The Flexible Job Shop Scheduling Problem (FJSP) [28] is defined by a set of machines (or more generally of resources) = {1, ..., }, and a set of jobs = {1, ..., }. Each job ∈ consists of a sequence of operations [1, ..., ]. The set of operations is defined as = { : 1 ≤ ≤ , 1 ≤ ≤ }. Each operation ∈ has an associated processing time pt and a set of eligible machines EMji ⊆ able to process . It is typically assumed that (i) each machine can process up to one operation at a time; (ii) any job can be processed independently from the others; and (iii) the execution of an operation cannot be interrupted (no preemption). For every operation we denote by its assigned start time; by = + pt its completion time; by (− 1) for > 1 its predecessor operation; and by (+1) for < its successor operation. An assignment of each operation to a machine and a start time that does not violate any of the following constraints is called a schedule: (a) each operation must end before its successor may start, and (b) each operation must be assigned to exactly one of its eligible machines.
To broaden the applicability of the FJSP, many extensions have been proposed. In the Multi-Resource FJSP (MR-FJSP) [9], each operation can require multiple resources of the same or of diferent types, such as a machine and a human operator. Another extension is the so-called FJSP with variable machine speeds1, where the speed at which the machine carries out the operation must be chosen from a set of possible machine modes, leading to a dynamic duration of operations [19]. Usually, machine modes are not directly treated as a continuous decision variable, but are assumed to have a set of valid values given a priori. Also, diferent modes may be associated with diferent costs, quantifying, e.g., the energy consumption of, or the caused wear on the machine. Additional extensions may consider transport times, when operations and (+1) are assigned to two diferent machines, and/or setup times, which may be required before executing an operation. In most cases, the setup time solely depends on the operation and on the machine, i.e., it can be expressed for operation on machine as st and thus can be assumed to be directly expressed by means of the processing time pt .
The real-world industrial use case considered in this work originates from an Austrian steel-cutting facility, where each job comprises one or more cutting operations that segment large raw pieces into smaller ones meeting specific customer requirements. The factory operates several cutting machines, each equipped with a bandsaw. Jobs are assigned to workers, who in turn are assigned to machines.
A high-level description of a job is the following. Each job begins with the worker loading the input piece on the machine, setting the appropriate parameters, and starting the cutting operation. Once the 1Diferent works may refer to it with diferent namings, such as controllable in place of variable, and similarly machining speeds, processing speeds, or simply modes instead of machine speeds. cut is finished, the operator has to unload the cut pieces. These can be either ready for delivery or must be cut again. In the latter case, whenever a diferent machine is required to perform the next cut, the time necessary for transporting the piece between the machines must be considered.
This process repeats daily, with hundreds of jobs, tens of machines, and tens of workers. Coordinating and planning the resources and operations in such a scenario constitutes a complex task to be addressed by a manufacturing company. As outlined in the introduction, the integration of multiple resource types, e.g., machines and workers, with setup and transport times has not yet been addressed within the context of energy-aware FJSP. This combination, however, is typical in various industrial contexts.
The industrial use case we address in this work is precisely characterized by the following assumptions:
1. All resources, machines and workers , are available for the entire scheduling horizon, i.e.,
tool wear, machine maintenance, or workers’ shifts are not considered.
2. All jobs are released before the start of the scheduling horizon.
3. Each job ∈ is composed of a sequence of tasks, where each task is a sequence of three
operations—load, cut, and unload—associated with one and the same cut. Thus, job has form
(load1, cut1, unload1, . . . , load, cut, unload) where is the number of tasks and = 3 * .
4. The cut operations represent the operations and require exactly one machine.
5. The operations, i.e., load and unload, require exactly one machine and exactly one worker.
6. Each job ∈ is preassigned to one, and only one, worker ∈ .
7. Each machine ∈ is preassigned to one, and only one, worker ∈ . The set of machines
assigned to worker is referred to as .
8. For every operation ∈ a non-empty set of eligible machines EMji is given. Each eligible
machine ∈ EMji ⊆ is preassigned to the same worker , to whom job ∈ is assigned.
9. For each processing operation ∈ and for each eligible machine ∈ EM , a non-empty
set of machine modes MDji,m is given, each allowing to accomplish the operation on machine
and implying a specific duration and energy consumption.
10. The times for load and unload depend only on the weight of the material that is cut.
11. The transport time depends only on the weight of the material to be moved, as each machine set
is located closely enough that inter-machine distances can be considered negligible.
12. Any sequence of operations (
Remark 1. Due to Assumptions 6 and 7, the assignment of a unique worker to every job and machine essentially leads to a partitioning of both the jobs and the machines. This has two implications. First, workers are not a flexible resource, and so the described problem is not a Double-Flexible JSP. Yet, the problem is still a Multi-Resource JSP, as setup operations must be assigned to a worker and a machine at a specific time point. Second, and more importantly, the overall scheduling problem can be decomposed into separate subproblems, one per worker. Therefore, given an input instance, one could basically preprocess it, create | | smaller and simpler subproblems, and solve each of them independently to obtain an overall schedule. However, in our evaluations (Sec. 6), to simulate a practical scenario where an a-priori problem analysis and decomposition is not always feasible, we solved each problem instance as-is, without applying any preprocessing. Moreover, to nevertheless obtain a more complete picture, we generate and analyze a second more general dataset, where Assumptions 6 and 7 are dropped and problem decompositions based on a partitioning of jobs and machines are no longer possible.
The proposed model, based on Constraint Programming (CP), encodes and enables solving the EnergyAware Double-Flexible JSP (E-DFJSP) [6], a variant of the JSP that incorporates multi-resource (workers and machines), routing flexibility, and energy minimization. Beyond that, we also consider the following extensions: controllable machine modes, sequence-independent setup operations, and transport operations. Note that the E-DFJSP comprises, in particular, the use case problem described in Sec. 4.
The model is implemented in IBM CPLEX Studio, and is solved by IBM CP Optimizer (CPO) [11]. CPO is probably the most popular CP-based tool for modeling and solving JSP problems [12, 13, 14, 15, 16, 17]. In particular, Da Col and Teppan [14] showed that CPO is the state-of-the-art tool for solving scheduling problems, as up to one thousand jobs could be successfully scheduled. Due to the absence of a standard notation for defining CP models, we employ the Optimization Programming Language (OPL). We summarize in Table 1 OPL’s built-in functions and keywords used in this work.
Description Defines an interval variable , represented as a tuple ⟨, , ⟩.
If optional, it may not be present, i.e., the tuple could be undefined. If dvar then it is a decisional interval variable.
Defines a sequence from a set of interval variables = {1, 2, ...} to be ordered, which typically represents the queue of operations of a resource.
Limits the domain of interval var to [, ] at declaration. The most classic use is 0..Horizon, where Horizon is a suficiently large integer.
Sets the duration of interval var to a fixed duration ∈ N at declaration.
Suitable also for optional interval variables, where, in such a case, each option has a corresponding fixed duration.
Returns the start of interval if present, otherwise an absent value.
Returns the end of interval if present, otherwise an absent value.
Returns the duration of interval variable . Useful to dynamically constrain the duration of , depending on the value of some decision variables.
Represents a constraint on an interval variable and a set of optional intervals = {1, 2, . . . } to ensure that (i) exactly (1 by default) of the intervals in are present if is present, and (ii) both and the present variables in share the same interval ⟨, , ⟩.
Boolean function indicating whether interval variable is present. Useful to dynamically check which optional interval variable ∈ is chosen.
Represents a constraint between interval variables and its successor (), ensuring the successor cannot start until ends.
Represents a no-wait constraint between interval variables and its successor (), ensuring the successor starts as soon as ends.
Ensures that all present variables 1, 2, ... in sequence do not overlap.
Ensures that if the interval variables , ∈ are present, then is the predecessor of in sequence .
Enables a priority ordering for multicriteria optimization.
As previously introduced, we recall that , , , stand for the sets of jobs, operations, machines, and workers, respectively. There are three operation types OT = {load, cut, unload}, where load and unload are setup operations, while cut is a processing operation. We denote the set of setup and processing operations by SO and PO , respectively. The predecessor and the successor of each processing operation are setup operations (cf. Assumption 3 in Sec. 4). The set of resource types RT = {mch, wrk} enables distinguishing between machines (mch) and workers (wrk). The set of resources is defined by the set of all tuples ⟨, mch⟩, ⟨, wrk⟩ where ∈ is a machine and ∈ is a worker. To improve the readability, we define two labels: typeo : → OT , which, given an operation ∈ , outputs the corresponding operation type; and typer : → RT which, given a resource ∈ , outputs its resource type. For any operation ∈ , we define by its set of eligible resources. For each processing operation po ∈ PO and eligible machine = ⟨, mch⟩ ∈ po , a predefined set of eligible machine modes MDpo,r is available.2 We treat machine modes as a finite set of possible feed rate ( ) and blade speed () combinations, i.e., a set of tuples of the form ⟨ , ⟩.3 Each machine mode ∈ MDpo,r is associated with duration pt ,, and processing energy ,,. Since setup and transport times are only weight-dependent (cf. Assumptions 10 and 11), they can be represented as and tt , respectively, where ∈ is a setup operation. Decision variables are highlighted in bold: is the interval variable of every operation ∈ . Two optional interval variables are defined, which enable representing possible alternative ways to execute an operation, e.g., using a diferent resource. In particular, we define po,r ,md for every processing operation ∈ PO , eligible resource ∈ , and available machine mode ∈ MDpo,r . Similarly, we introduce the optional interval variable o,r for all operations ∈ and eligible resources ∈ o . Both ,, and , are synchronized with . We also introduce, for each resource , a sequence decision variable , which contains all the operations for which is eligible. We also define a derived decision variable , which represents the completion time of each job ∈ . Table 2 summarizes the notation and the description of all the defined sets, parameters, and variables.
Set of jobs ∈ = {1, . . . , } Set of operations ∈ = { | 1 ≤ ≤ , 1 ≤ ≤ } = PO ∪ SO Set of processing operations ∈ PO ⊂ = { | ∈ , ≡ 2 (mod 3)} Set of setup operations ∈ SO ⊂ = { | ∈ , ̸≡ 2 (mod 3)} Set of operation types = {load, cut, unload} Set of resource types rt ∈ RT = {mch, wrk} Set of machines ∈ Set of workers ∈ Set of resources ∈ = {⟨, mch⟩ : ∈ } ∪ {⟨, wrk⟩ : ∈ } Set of eligible resources ∈ for operation ∈
Set of modes ∈ MDpo,r for processing operation ∈ on resource ∈ ,, ∈ N+ ,, ∈ R+ ∈ N+ ∈ N+ ∈ N+ Decision Variables po,r,md o,r r Objectives Tard PE
Processing time of operation ∈ PO on resource ∈ with mode ∈ MDpo,r Processing energy of operation ∈ PO on resource ∈ with mode ∈ MDpo,r Setup time of operation ∈ SO Transport time of operation ∈ SO Deadline of job ∈ Type of operation = ∈ : equals load if ≡ 1 (mod 3), cut if ≡ 2 (mod 3), and unload if ≡ 0 (mod 3) Type of resource = ⟨, ⟩ ∈ : equals ∈ .
Interval representing start and end time of operation ∈ Optional interval for operation ∈ PO on resource ∈ with mode ∈ MDpo,r Optional interval for operation ∈ using resource ∈ Sequence of optional intervals for resource : ∀ ∈ [ ∈ ⇐⇒ , ∈ ].
Completion time of each job ∈ , defined as = endOf( ) Tardiness Total Processing Energy
Makespan 2Machine modes can be defined, e.g., based on domain expertise, engineering knowledge, or machine learning models. 3By using a discrete set of tuples to represent all relevant modes, no real-valued decision variables are required in the model. Note that CPO does not support real-valued decision variables.
Constraints (
alternative( , { po,r,md : ∈ , ∈ MDpo,r }) ∀ ∈ PO
Recall from Assumptions 4, 5 that setup operations require both a machine and a worker, while processing
operations only require a machine. Constraint (
alternative( , { o,r : ∈ , = mch}) ∀ ∈ O
Constraint (
presenceOf( ji,r,md )
∑︁
∈MDji,r
∀ ∈ ∀ ∈ : = cut, ∈ { − 1, , + 1}
(
sizeOf( ) ≥ ∀ ∈ presenceOf( ji,r1 ) ∧ presenceOf( j (i+1 ),r2 ) =⇒ sizeOf( ) = st +
∀ ∈ ∀1 ∈ ∀2 ∈ (+1) : < , type = unload, 1 ̸= 2
Constraints (
∀ ∈ ∀ ∈ ∩ (+1) : < , type = mch
prev(, AT ,, AT (+1),)
∀ ∈ ∀ ∈ ∩ (+1) : < , type = wrk, type = unload
(
The objective function is defined by three objectives, each to be minimized, with a fixed order of priority: (i) tardiness (Tard ), (ii) energy (PE ), and (iii) makespan (max ).
minimize staticLex(Tard , PE , max ) Tardiness measures the cumulative lateness of all given jobs , and we measured it in 8-hour shifts, i.e., SHIFT_LEN = 480 []. We compute it as the sum of all non-negative diferences between the shift ⌈ /SHIFT_LEN⌉ where a job is completed and the shift where the job is due, over all jobs ∈ : Tard = ∑︁ max (⌈ /SHIFT_LEN⌉ − , 0)
∈
PE =
The processing energy of a single operation is computed by taking the consumed energy of the chosen
machine mode. Note that, due to Constraint (
presenceOf( po,r,md ) * ,, ∈PO ∈ ∈MDpo,r The makespan is the total duration of the entire schedule: = max = max endOf( )
∈ ∈
The presented model is tested on two similar problems, which resemble the real-world scenario of a
steel-cutting company described in Sec. 4. To preserve the confidentiality of our industry partner’s
data, the datasets were generated using a random sampling procedure based on the real use case. In
particular, we distinguish between the present and the future use case scenarios, where the former
reflects current assumptions while the latter anticipates slight changes planned by the considered
steel-cutting company. More specifically, in the present use case scenario, each machine is assigned to
exactly one worker, while in the future use case scenario, multiple workers are allowed to operate the
same machine. The single-worker-per-machine assumption in the former scenario implies that the
scheduling problem can be decomposed into a set of independent subproblems (cf. Remark 1), while
this is not possible in the latter scenario. As a result, analyzing this more general case is particularly
interesting from both theoretical and practical perspectives. On the one hand, the problem becomes
more complex, as it corresponds to a Double-Flexible JSP; on the other hand, introducing additional
worker flexibility may lead to reductions in makespan and tardiness.
6Constraint (
We generated a dataset for the present use case by means of the following parameters: (i) three diferent numbers of jobs, | | ∈ {50, 200, 500}, corresponding respectively to medium-, large-, and very large-scale instances; (ii) two diferent workers’ flexibility degrees as the number of machines assigned to each worker, ( ) = (| |/| |) ∈ {3, 4}, in accordance with the real use case; (iii) the fixed machines’ flexibility degree , i.e., the number of assigned workers to each machine, ( ) = 1 (cf. Assumption 7);8 (iv) for each setting of ( ), three diferent jobs-to-machines ratios, | |/| |, i.e., "few" (up to 4), "some" (up to 10), and "many" (more than 10), to represent periods of varying system load; and (v) the fixed number of machine modes per cut operation, = 2.
The numbers of machines | | and workers | | then follow from the flexibility degree ( ), the jobs-to-machines ratio | |/| |, and the number of jobs | |. Note that if the number of jobs is fixed but the number of resources increases, both makespan and tardiness are expected to decrease—since fewer jobs are assigned to each resource—while the number of decision variables handled by the solver may increase. Therefore, by varying the jobs-to-machines ratio, we can observe how changes in resource availability influence both throughput and solver performance.
Once all the parameters are set, the remaining data is sampled as follows. The jobs’ due dates are defined in terms of shifts (of 8 hours) and follow a gamma distribution Gamma ( = 2, = 1).9 Each job ∈ is randomly assigned to one of the workers ⋆ ∈ , who in turn is assigned to a set of 3 or 4 machines ⋆ , according to the workers’ flexibility degree ( ). For the processing operation , its set of eligible resources is a random non-empty subset of ⋆ , i.e., = {⟨, mch⟩ : ∈ } 8The machines-workers assignments can be represented as a bipartite graph = (, , ), where (, ) ∈ if worker ∈ is assigned to machine ∈ . Thus, the node-degree () represents the number of assigned machines to worker . Since it is constant for each ∈ , we denote it by ( ) for brevity. The same applies to the machines. 9Each sample is then rounded to the nearest integer ≥ 1. The resulting distribution is similar to a positively skewed bell-shape with expected value E[] = = 2 and variance Var () = 2 = 2. That is, 80 % of the jobs have a due shift ≤ 3. where ⊆ ⋆ . Basically, since || = ( ) for any ∈ , the number of eligible machines per operation follows a discrete uniform distribution {1, . . . , ( )}. Load and unload operations also require a worker, namely ⋆, the one assigned to job . Therefore, the set of eligible resources for the setup operations can be defined as (− 1) = (+1) = ∪ {⟨⋆, wrk⟩}.
The single operations are generated as follows. The number of processing operations per job follows a shifted exponential distribution Exp( = 1) + 1.10 Each processing operation has an associated physical piece to be cut. The dimensions of each input piece (height, width, and depth) before the cut operation are randomly sampled from three normal distributions ( = 100, = 50), (450, 400), (200, 80) [mm].11 Then, out of these three values, two of them are randomly selected, one to be the cut depth and the other one to be the cut channel; these values represent (i) how long the cut will be and (ii) the width of the cut on a single blade-pass. The weight is then computed by multiplying the density constant of the steel, 7.85 [/3], with the volume of the piece, derived by multiplying together height, width, and length, i.e., by assuming that all pieces are cuboids. The weight also enables deriving the setup time and the transport time. The diferent machine modes (processing speeds) are then computed by first obtaining the manufacturers’ suggested values 12 and then by applying diferent random perturbations. The duration of the processing operations depends on the chosen machine mode, and, for a given machine mode, can be computed as the ratio between the cut depth [] and the feed rate [/]. Finally, we estimate the processing energy of each option, and then randomly perturb the prediction. To do so, we assume having a black-box model that estimates the energy of a cut given the machine mode, the cut channel, and the cut depth. We also compute a worst-case upper bound Horizon for the entire schedule.
The procedure presented here is exemplary of how a scheduling problem in the manufacturing sector could look. Note that each combination of the parameters ⟨| |, ( ), | |/| |⟩—which in total are 18 = 3 × 2 × 3—leads to a unique combination ⟨| |, | |, | |⟩. For each of the latter, we generate 3 diferent random instances. Thus, the number of instances for the present dataset is 3 × 18 = 54.
In the future use case scenario, multiple workers can be assigned to each machine. To evaluate the impact of such a generalization, we keep the two datasets as identical as possible while preventing decomposability. We modify the machines-workers assignments so that at least 2 workers are assigned to each machine, i.e., the machines’ flexibility degree ( ) ≥ 2. Starting from one worker per machine, we achieve this by randomly assigning additional workers to each machine while ensuring that the expected number of machines assigned to each worker is realistic, i.e., E[( )] < 10. Apart from that, all settings are equal to the present use case (Sec. 6.1.1), including the use of the same interval variable upper bound Horizon to ensure a fair comparison.
Table 3 details parameters and properties of the generated datasets, where stands for the future (general) dataset and for the present (decomposable). The columns mentioning (· ) are derived by averaging the values from the 3 random instances. Note that dataset has more variables (as there are more choices) and more constraints (as there are more prev constraints) than dataset . For dataset , entries with = 1 are left blank, as with only one worker, the instances for and are identical. Thus, the number of instances for the future dataset is 54 − 3 * 2 = 48.
To present the experiment design, we first need to introduce the notion of a tolerance level.
10A shifted random distribution adds a constant to all values of the original distribution. Since ∀ Exp(
In single-objective minimization, tolerance levels quantify the acceptable deviation from the (unknown) global optimum * . For a given tolerance level |tol | (or, in relative terms, tol % < 1) and a lower bound LB ≤ * , a solution with value is considered optimal if gap = − LB ≤ | tol | (or if gap% = gap/LB ≤ tol %). When this happens, the search stops. In contrast, in the multi-objective case (with fixed priorities), the solver continues optimizing the subsequent goal. CPO provides tolerance levels, as it is able to estimate lower bounds while solving. Combining tolerance levels and staticLex(· ) (cf. Table 1) seems a promising approach, especially for finding initial solutions. By relaxing the priority order of the goals up to a tolerance level, the solver is prevented from stalling in proving the optimality of the current goal. Instead, it can advance to the following goals, which may ofer a more straightforward margin for improvement (while still not worsening any of the previously optimized goals). 6.2.2. Design The model was evaluated using CPO v22.1.2 with default settings, except for tolerance and timeout. Experiments were executed in parallel (up to four concurrently), each bound to a CPU (taskset -c cpu, cpu ∈ {0, 1, 2, 3}) on Ubuntu 24.04.2 LTS (x86_64) with an AMD EPYC 9354 (32 cores, 3.25 GHz) and 62 GB RAM. CPO runs were executed in parallel mode (workers=4). We employed a single timeout, = 10 minutes, and two diferent tolerance levels, ⟨|tol |, tol %⟩ ∈ {⟨0, 0%⟩, ⟨5, 10%⟩}, where |tol | is the absolute tolerance and tol % is the relative tolerance.13 For every instance and for each tolerance, we launched CPO three times, each with a diferent random seed. The tolerance levels are motivated as follows: with ⟨0, 0%⟩ we aim at the global optimum, while with a tolerance ⟨5, 10%⟩ we investigate the impact of such a tolerance level on solution quality (in theory, it should find solutions having higher tardiness but lower energy and makespan). A small constant |tol | is needed when the lower bound can be zero, as it is for the tardiness, because, in such a case, the gap% is undefined, and thus any value for tol % would have no efect. Thus, we set |tol | = 5 to avoid the solver getting stuck in minimizing tardiness without minimizing the other goals as well.
We collect the following data: the number of variables Vars and of constraints Const (cf. Table 3), the solving time in [] and memory in [MB ], the values of the goals (Tardiness [#shifts], Energy [kWh], max [min]), the number of optimized goals #OG , and the Boolean flags Solved and Optimal . 6.2.3. A Bug in CPO Unfortunately, we found bugs and unexpected results in CPO when combining tolerance levels with staticLex. Initially, IBM indicated that, although negative gaps could appear, optimality reports would remain reliable. Later, however, we found cases where CPO declared optimality despite some goals being well beyond their acceptable values ( ≫ * + ). Therefore, we used tolerance levels, but did not employ the staticLex function. Instead, we optimized one objective at a time by externally updating the goal function and its bounds. IBM has indicated that this bug will be resolved in the next CPO version.14
Tables 4 and 5 summarize the results for the two datasets, the present and future use cases, for a total timeout of 10 minutes. The resource usage is not reported in the tables, as the timeout is basically always reached, while the memory usage is consistently reasonable (the peak virtual memory size of 2113 [MB ] was recorded with = 500, = 40 with dataset ). Each table cell per ⟨, , ⟩ combination reports an average (or a percentage) over 9 runs (3 instances, each run 3 times). The objectives’ averages are based only on the solved runs. [%] ([%]) denotes the percentage of runs for which a solution (the optimal solution, up to the given tolerance) is found. Note that a 13If both absolute and relative tolerances are defined, a solution is considered acceptable if gap ≤ | tol| ∨ gap% ≤ tol%. 14For details, check the discussion thread on the IBM community: https://community.ibm.com/community/user/question/ consistency-of-cpo-lower-bounds-combined-with-staticlex-and-tolerances. solution is optimal if all the objectives have been optimized. # ∈ [0.0, 3.0] indicates the average number of optimized goals. Thus, #OG = 3.0 means Optimal [%] = 100%, but #OG = 0.0 does not imply Solved [%] = 0%. Also, being an average, #OG = 1.0 does not imply that in all runs the first goal (i.e., tardiness) has been optimized.
First, and surprisingly, we can see that CPO consistently finds a schedule only for the general dataset , but not for the present dataset , although the latter is decomposable and involves fewer variables, constraints, and choices. A plausible reason could be the following. Although the choice space in is smaller—since workers are fixed and each operation has fewer eligible machines—the job-machineworker eligibility graph is sparse and disconnected. This can make finding a valid time interval for operation on resource more dificult. By contrast, the additional worker-machine assignments in make its eligibility graph connected and denser. Therefore, the chances of finding a resource for operation available at interval are higher. So, CPO can find an initial solution for more easily. Despite that, has a larger search space, and the global optimum with no tolerance is never reached.
Second, we observe that the problem becomes more complex not only as the number of jobs increases, but also as the number of resources decreases. In fact, as and increase (i.e., as the / and / ratios decrease), #OG grows, and the solutions achieve higher quality (e.g., lower tardiness). The simple reason for this is that a reduction in the number of available resources limits the opportunities to distribute jobs across them. As a result, the remaining resources experience long queues of operations, and identifying the optimal solution requires determining the most eficient execution order for the jobs on each resource—a combinatorial task whose complexity grows factorially. Thus, the instances sharing equal ratios of / and / , such as {⟨50, 15, 5⟩, ⟨200, 60, 20⟩, ⟨500, 150, 50⟩} also reflect similar optimal values for tardiness and makespan (cf. the entries in the tables having #OG ≥ 1). However, since the solver often reaches the timeout, this statement can be experimentally observed only in a few cases. Clearly, a larger yields a larger search space, which can negatively impact solution quality.
In general, CPO appears to be more efective at minimizing makespan than tardiness. Although makespan optimization—the third objective—often cannot even start before the timeout (cf. the global avg (#OG ) ≤ 1.2 in and ), the resulting makespan values still appear reasonable. In contrast, despite being the primary objective, tardiness values can become quite large.15 Thus, CPO shows limited ability in minimizing tardiness and may lack efective heuristics for it (e.g., Earliest-Deadline First).
Tolerance levels prevent the solver from spending excessive time optimizing a single goal while neglecting others. Their impact on solution quality appears once the optimization runs long enough for at least one goal to be optimized. Unfortunately, in dataset , in most cases, CPO cannot even optimize the first goal, while, in , only the first is optimized on average (cf. column # in the tables). Thus, the efects of the tolerances are limited in our experiments, and in fact, the average values of the objectives have a low deviation from each other. This is especially true for energy consumption since (i) its optimization rarely begins due to timeouts (energy is the second objective), and (ii) the model considers only the processing energy, but disregards idle and makespan-related energy costs.
Based on a real-world industrial use case in the steel industry, we introduced a novel and relevant extension of the Energy-Aware Double-Flexible Job-Shop Scheduling Problem (E-DFJSP). While E-DFJSP already includes energy costs and both machines’ and workers’ flexibility, we incorporated alternative machine modes (with varying energy consumption and processing time), as well as setup and transport operations—aspects often overlooked in traditional scheduling models. To address this problem, we proposed and implemented a Constraint Programming model using IBM CP Optimizer (CPO). We optimized tardiness, energy, and makespan (in this order) using defined optimality tolerance levels.
Conducting extensive experiments on two datasets from a steel-cutting company reflecting diferent factory policies in terms of worker responsibilities, we found that: (i) finding the optimal solution is unfeasible in most cases, (ii) CPO is consistently better in minimizing makespan rather than tardiness, 15All instances should have an optimal tardiness close to 0 since (i) avg(Tard) < 3 in all combinations of ⟨, , ⟩ having # ≥ 1, and (ii) instances sharing equal / and / ratios also share similar optimal values for Tard and max . (iii) CPO can find solutions for harder instances (with many choices available) but failing for simpler instances (with few choices), (iv) increasing the number of resources yields lower tardiness and makespan and eases solving, and (v) CPO is not a memory-intensive solver. Finding (iv) is supported by the fact that the resource-rich instances are the ones with the highest number of optimized goals (one or two).
Future research could extend this study in various meaningful ways. First, it appears promising to devise ways of assisting CPO in tardiness optimization by supplying a valid initial solution (e.g., from a greedy algorithm), or by designing (or learning [29]) a custom heuristic. Second, the presented model could be integrated with machine learning techniques, such as decision-focused learning [30], to include the uncertainty of parameters such as energy consumption or induced tool wear, which must be predicted based on the collected data in the factory. Third, inspired by [16], we aim to estimate the total energy consumption, i.e., to extend our approach by accounting for idle and overall factory energy.
GPT-4 assisted only with language editing; all content was verified by the authors.
This work was supported by FFG, contract FO999910235. This research was funded in part by the Austrian Science Fund (FWF) 10.55776/COE12. We thank Giulia Francescutto, Martin Hackhofer, and Giray Havur for their valuable contributions throughout the development of this work. [11] P. Laborie, J. Rogerie, P. Shaw, P. Vilím, IBM ILOG CP Optimizer for scheduling: 20+ years of scheduling with constraints at IBM/ILOG, Constraints 23 (2018) 210–250. [12] J. M. Novas, Production scheduling and lot streaming at flexible job-shops environments using constraint programming, Computers & Industrial Engineering 136 (2019) 252–264. [13] M.-J. Park, A. Ham, Energy-aware flexible job shop scheduling under time-of-use pricing, International Journal of Production Economics 248 (2022) 108507. [14] G. Da Col, E. C. Teppan, Industrial-size job shop scheduling with constraint programming,
Operations Research Perspectives 9 (2022) 100249. [15] P. Yunusoglu, S. Topaloglu Yildiz, Solving the flexible job shop scheduling and lot streaming problem with setup and transport resource constraints, International Journal of Systems Science: Operations & Logistics 10 (2023) 2221072. [16] H. Terbrack, T. Claus, The generalized energy-aware flexible job shop scheduling model: A constraint programming approach, Computers & Industrial Engineering 204 (2025) 111065. [17] G. A. Kasapidis, D. C. Paraskevopoulos, I. Mourtos, P. P. Repoussis, A unified solution framework for flexible job shop scheduling problems with multiple resource constraints, European Journal of Operational Research 320 (2025) 479–495. [18] I. A. Chaudhry, A. A. Khan, A research survey: review of flexible job shop scheduling techniques,
International Transactions in Operational Research 23 (2016) 551–591. [19] L. Yin, X. Li, L. Gao, C. Lu, Z. Zhang, A novel mathematical model and multi-objective method for the low-carbon flexible job shop scheduling problem, Sustainable Computing: Informatics and Systems 13 (2017) 15–30. [20] Z. Liu, S. Guo, L. Wang, Integrated green scheduling optimization of flexible job shop and crane transportation considering comprehensive energy consumption, Journal of Cleaner Production 211 (2019) 765–786. [21] M. A. Salido, J. Escamilla, A. Giret, F. Barber, A genetic algorithm for energy-eficiency in jobshop scheduling, The International Journal of Advanced Manufacturing Technology 85 (2016) 1303–1314. [22] M. Dai, D. Tang, A. Giret, M. A. Salido, Multi-objective optimization for energy-eficient flexible job shop scheduling problem with transportation constraints, Robotics and Computer-Integrated Manufacturing 59 (2019) 143–157. [23] J.-q. Li, J.-w. Deng, C.-y. Li, Y.-y. Han, J. Tian, B. Zhang, C.-g. Wang, An improved jaya algorithm for solving the flexible job shop scheduling problem with transportation and setup times, KnowledgeBased Systems 200 (2020) 106032. [24] X. Chen, J. Li, Z. Wang, J. Li, K. Gao, A genetic programming based cooperative evolutionary algorithm for flexible job shop with crane transportation and setup times, Applied Soft Computing 169 (2025) 112614. doi:10.1016/j.asoc.2024.112614. [25] L. Meng, C. Zhang, B. Zhang, Y. Ren, Mathematical modeling and optimization of energy-conscious lfexible job shop scheduling problem with worker flexibility, IEEE Access 7 (2019) 68043–68059. [26] J.-Y. Moon, J. Park, Smart production scheduling with time-dependent and machine-dependent electricity cost by considering distributed energy resources and energy storage, International Journal of Production Research 52 (2014) 3922–3939. [27] J. M. Fernandes, S. M. Homayouni, D. B. Fontes, Energy-eficient scheduling in job shop manufacturing systems: a literature review, Sustainability 14 (2022) 6264. [28] P. Brucker, R. Schlie, Job-shop scheduling with multi-purpose machines, Computing 45 (1990) 369–375. [29] A. Novikov, N. V u˜, M. Eisenberger, E. Dupont, P.-S. Huang, A. Z. Wagner, S. Shirobokov, B. Kozlovskii, F. J. Ruiz, A. Mehrabian, et al., AlphaEvolve: A coding agent for scientific and algorithmic discovery, arXiv preprint arXiv:2506.13131 (2025). [30] J. Mandi, E. Demirović, P. J. Stuckey, T. Guns, Smart predict-and-optimize for hard combinatorial optimization problems, in: Proceedings of the AAAI conference on artificial intelligence, volume 34, 2020, pp. 1603–1610.