Swarm algorithms for sustainable dynamic flexible job shop rescheduling under machine breakdown in smart manufacturing plants

State-of-the art

In the context of smart manufacturing and in alignment with the “Artificial Intelligence and Localization of Industry in Egypt” strategy, enterprises strive for intelligent and precise production. Job shop scheduling problem (JSSP) is a control technology that can optimize production processes. By leveraging intelligent algorithms, production resources can be utilized efficiently despite operational constraints, resulting in significant cost reductions and a naturally shortened manufacturing cycle.

A digital twin (DT) is widely recognized as a virtual counterpart of a physical asset that replicates its behavior in real-time or near real-time. This virtual representation can encompass diverse entities such as vehicles, buildings, individuals, cities, organizations, or entire systems. Depending on its purpose, a DT may highlight specific dimensions like financial metrics or provide a comprehensive perspective that includes geographical configuration, human capital, asset inventory, and the interactions between various components. In recent years, the implementation of DT technology has accelerated, largely due to the rapid evolution of foundational technologies including big data, the Internet of Things (IoT), artificial intelligence and machine learning (AI-ML), and cloud computing. These technologies are vital for the precise acquisition, transmission, storage, and interpretation of the massive datasets generated by IoT devices. Consequently, DT has seen expansive deployment across various domains, with particularly notable impact in smart manufacturing (Rosen et al., 2015; Xu et al., 2019; Qi & Tao, 2018).

In real-world production systems, various dynamic events such as machine breakdowns (Xiong, Xing & Chen, 2013), uncertain processing times (Chang & Liu, 2017), order insertions (Luo et al., 2020), and operation inspections (Zhu et al., 2023) have been extensively studied by researchers. However, one of the most common dynamic events—order-related machine breakdowns—has not yet been thoroughly investigated, despite its significant impact on production scheduling. In Zhu et al. (2023), a modified memetic algorithm was proposed for manufacturing systems that account for rework and scrap states of products. This approach integrates a hybrid scheduling method incorporating three distinct rescheduling strategies.

Over the past decade, several studies have explored anomaly detection algorithms in JSSP. In Hu et al. (2023), an improved genetic algorithm (GA) with dynamic neighborhood search was introduced to address JSSP, focusing on minimizing the makespan. The authors of Zheng et al. (2024) examined the flexible JSSP (FJSSP) under uncertain processing times and proposed a robust optimization model utilizing a two-individual-based master–apprentice evolutionary algorithm. In Li et al. (2023), an anomaly detection and dynamic scheduling framework based on DT technology was developed for flexible job shops, recognizing that sudden anomalies can cause scheduling deviations. To address this issue, the authors proposed a DT-based anomaly detection and dynamic scheduling method. Leveraging a rolling window mechanism, which extends heuristic algorithms to the dynamic scheduling domain, they introduced a time-window-nested multi-layer coding GA to optimize scheduling outcomes.

The FJSSP, first defined by Brandimarte (1993), involves processing each operation on any machine within a specified subset of the total set of machines. When machine flexibility is high—meaning operations can be performed on multiple machines—finding high-quality or even optimal solutions become easier. As reviewed in Dauzère-Pérès et al. (2024), various versions of the JSSP exist. In the basic JSSP, each job consists of a sequence of operations that have to be executed in a predetermined order, with each operation assigned to a specific machine. In the FJSSP variant, each operation of a job can be executed on a set of available machines. Further variations of the FJSSP include the partial FJSSP and the total FJSSP.

In the Dynamic FJSSP (DFJSSP), Jobs do not enter the workshop simultaneously at the start of the scheduling period; instead, they arrive at varying times throughout the process. Additionally, authors in Dauzère-Pérès et al. (2024) provided comprehensive insights into DFJSSP, covering criteria, constraints, additional problem characteristics, and solution methodologies. The DFJSSP extends the traditional job shop problem by introducing greater scheduling flexibility, but this also increases computational complexity, making it an NP-hard problem (Xie et al., 2019; Zhong et al., 2020).

Sun, Cheng & Liang (2010) proposed a GA with a penalty function for solving the JSSP. In Gen, Tsujimura & Kubota (1994), the objective was to develop a GA-based approach for JSSP, demonstrating that even a relatively simple GA can effectively handle job shop scheduling. The research study in Sun et al. (2019) addressed FJSSP with uncertain processing times, represented by fuzzy numbers, and introduced a hybrid cooperative evolutionary algorithm to minimize the maximum fuzzy completion time. Zhu et al. (2019) applied an FJSSP model with combined processing constraints to the assembly manufacturing industry. In their study, the concepts of ‘combined processing constraint’ and ‘virtual operation’ were introduced to simplify and transform an FJSSP with combined processing constraints into a standard FJSSP. In Stastny et al. (2021), a novel graph-based algorithm was proposed for optimizing scheduling problems. However, none of these studies specifically addressed anomaly operations.

In the DFJSSP, various constraints must be considered. In many cases, jobs are allowed to wait for only a limited time, as seen in semiconductor manufacturing, where excessive waiting can lead to product contamination, scrapping, or rework (Mönch et al., 2011). Additionally, a minimum waiting time between two operations may be required, for example, to account for transportation delays between machines or to model processing times of operations that either do not require resources or rely on non-bottleneck machines (Tamssaouet et al., 2022). Instead of explicitly representing unavailability periods in the disjunctive graph, these periods can be incorporated by adjusting operation start times to prevent overlaps between processing and unavailability periods. This approach, as demonstrated in Tamssaouet et al. (2022), effectively handles scheduling problems with fixed unavailability periods. In that study, operations were considered resumable under two scenarios; they could resume processing after being interrupted by an unavailability period.

The multiple resource-constrained JSSP is widely recognized as a typical NP-hard problem. To address this challenge, researchers frequently employ metaheuristic algorithms, including GA algorithms (Tan et al., 2021), Grey Wolf Optimization (GWO) algorithms (Zhu et al., 2022), Particle Swarm Optimization (PSO) (Fontes, Homayouni & Gonçalves, 2023), and differential evolution algorithms (Wang, Gao & Pedrycz, 2022). Liu et al. (2023) conducted an extensive study on the application of evolutionary algorithms to the fuzzy FJSSP with uncertain processing times. Their research focused on optimizing key performance metrics, such as maximum completion time, total machine load, and maximum machine load. To further enhance efficiency, they proposed a non-dominated sorting teaching-learning-based optimization algorithm aimed at minimizing both energy consumption and makespan.

Research gap and motivations

In conclusion, while previous research has largely concentrated on minimizing machine energy consumption and makespan through multiobjective evolutionary algorithms, it has often neglected the inverse proportional relationship between time and energy. This oversight leads to a less realistic portrayal of actual production environments, where optimizing one objective often comes at the expense of the other, making it impractical to achieve simultaneous optimal minimization. Moreover, anomalous operations have frequently been ignored, limiting the applicability of these approaches in dynamic manufacturing contexts. A significant gap also remains in the literature regarding the use of GWO and PSO within DT-based DFJSSP, highlighting an important area for future exploration.

In this article, we propose a novel DFJSSP model that considers operation sequencing and timing while simultaneously addressing machine failure and redistribution scenarios. The key innovative contributions are as follows:

• A mathematical model for DFJSSP has been formulated in a DT system.

• GWO and PSO algorithms have been applied to minimize the maximum completion time (makespan).

• The dynamic rescheduling problem under machine breakdowns has been investigated, focusing on minimizing order completion time (makespan).

• Two breakdown handling scenarios have been proposed to ensure production continuity.

• Energy consumption has been analyzed and compared across three states: healthy state, failure state handled by Scenario 1, and failure state handled by Scenario 2, and then decide which scenario is better in terms of both makespan and rational use of energy.

• In the context of a DT system, sustainability is primarily reflected through continuous system monitoring, which enables early detection of machine failures and facilitates dynamic rescheduling. This ensures the stability and resilience of the production process, thereby reducing downtime, improving resource utilization, and minimizing waste—key factors contributing to a sustainable manufacturing environment.

The rest of this article is organized as follows. ‘Related Work’ summarizes the relevant literature in recent years. A description and the mathematical models of the system studied are presented in ‘Industrial Manufacturing Plant Under Healthy and Failure States’. In ‘Sustainable Dynamic Job Shop Rescheduling Problem Using GWO and PSO Optimization Algorithms’, the two proposed DFJJSP scenarios are presented in detail via the proposed GWO and PSO algorithms. The simulation results and analysis are provided in ‘Simulations and Analysis’. Finally, summary, limitations of the work, and prospects of the study are given in ‘Conclusions’.

System framework architecture

This manuscript is an extension of the work presented in reference Tarek et al. (2025). The proposed system framework is designed to be compatible with small- to medium-sized manufacturing plants. The case study focuses on a poultry manufacturing plant comprising three production lines. Each line includes seven machines that manage the production process—from receiving raw material containers to delivering the final product in sewed packages. Further details are available in Tarek et al. (2025). The architecture of the proposed framework, including the rescheduling optimization component, is illustrated in Fig. 1. It consists of three main modules: the input data module, the digital twin module, and the optimization module. The input data module initializes the system using machine data (historical and real time sensor data), objectives, constraints, available resources, and a comprehensive list of jobs and operations needed to fulfill product requirements. The digital twin module integrates machine availability, machine state (healthy or in breakdown), and the simulation module. Then, send all data to the optimization module. The initial schedule is optimized using the GWO and then send the resulting schedule back to DT.

The next phase is starting the execution of the production process; if a machine fails, DT module sends a failure report and then the system triggers rescheduling based on one of two predefined scenarios (Scenario 1 or Scenario 2). Table 2 provides a summary of the processing times for all operations across the corresponding machine set. Processing time is measured in time units, where each unit corresponds to 5 min. This case study considers ten jobs, each comprising seven operations, with each operation executable on the corresponding machine within any of the three production lines.

Simulation environment with failure state

The simulation environment in case of failure in the three production lines poultry factory, as defined in Tarek et al. (2025), is illustrated in Fig. 2. This figure demonstrates the core concept of rescheduling job shop operations when certain machines are turned off. When a machine fails, its operations are redistributed among alternative healthy machines to maintain workflow continuity.

• Line 1: Machine M1 is in a failure state, and its operations are reassigned to M8 and M15.

• Line 2: Machine M10 experiences a failure, with its operations redistributed between M3 and M17.

• Line 3: Machine M19 is in a failure state, and its operations are reassigned to M5 and M12.

Operations assigned to failed machines (marked in red in Fig. 2) are referred to as disrupted operations. These operations are followed by subsequent operations, which are called following operations and may require different rescheduling strategies. The specific redistribution scenarios for disrupted and following operations are detailed in the next section.

DFJSSP problem formulation

To effectively address the DFJSSP, the following key assumptions, objectives, and constraints are considered:

Scheduling and rescheduling strategy

Emergencies such as machine breakdowns and rush orders significantly impact the production activities of manufacturing enterprises. The dynamic scheduling strategy employs an event-based rescheduling approach, focusing on assessing the state of all operations at the time of failure. It then modifies these states to ensure production continuity by determining job positions, identifying unprocessed tasks, and calculating the earliest available time for machines. This article specifically examines one type of dynamic event: machine breakdowns, which can occur at any point during the production process. When a machine breaks down, the operation being processed on the faulty machine is scrapped.

The extended makespan time varies depending on the severity of the fault, as production lines differ in terms of machine capacity and power. The same operation can be processed on alternative machines, but with varying processing times, as illustrated in Table 2. Normal machines that remain operational are rescheduled either immediately or after the completion of their current processes. To address disruptions in DFJSSP with automated guided production lines, a GWO and PSO model is developed to minimize the makespan.

The dynamic scheduling of the production flow, based on operation inspection, is illustrated in Fig. 3. The flowchart outlines a process starting with data acquisition, followed by GWO and PSO optimization. Afterward, a model or rule execution step is performed. The next decision point checks whether the production process is finalized. If yes, the process ends. If not, another decision checks if a DT failure report has been received. If no report is received, the process continues with the initial schedule. But if a failure report is received, a scenario selection step is performed which leads to two possible scenarios:

Initial scheduling

In this step, the scheduling of the operations is distributed according to the proposed GWO optimization, as shown in Fig. 3. Here, the machine availability will be recorded to be used in the after-failure scenarios. The steps involved in this algorithm can be summarized as follows:

Scenario 1: dynamic flexible rescheduling with optimized makespan

This scenario focuses on addressing machine failure during the execution of the optimized schedule generated by the optimization algorithm. This dynamic event is triggered when a machine failure situation is detected at a certain time, as reported by the DT monitoring module, which provides also a list of failed machines. The steps of the machine failure handling involved in this scenario are illustrated in this section. The algorithm in this scenario works as follows:

• 1.

  Classifying operations:

• At the time of failure, Adding each operation to one of the following categories:

  • •

    Finished operations (operations completed before the failure time).

  • •

    Executing operations (ongoing operations at the failure time).

  • •

    Disrupted operations (ongoing operations on failed machines at failure time).

• 2.

  Filtering machine options:

  • •

    This step removes failed machines from the alternative machine set for each operation. And adjust the corresponding processing time.

• 3.

  Filter remaining operations:

  • •

    This step removes both finished operations and executing operations from the total operations.

• 4.

  Redistribute remaining operations using both GWO and PSO:

  • •

    Sending the remaining operations as input dataset for the GWO and the PSO algorithm considering the start time is the machine failure time. And check the availability of machines to see if one of the executive operations is still running.

• 5.

  New schedule and makespan:

  • •

    The new schedule and its makespan are calculated and stored.

• 6.

  Visualize the updated schedule:

  • •

    Generate a Gantt chart to visualize the updated schedule, highlighting the changes caused by the machine failure and the redistribution process.

This information is fed back to DT module to update and start monitoring the execution of the updated schedule. The pseudocode for GWO and PSO algorithms are presented in Figs. 4 and 5, respectively.

Figure 6 provides an example illustrating how disrupted operations can be rescheduled using Scenario 1 approach. In this scenario, machine M10 is assumed to fail, requiring the redistribution of operations op(1-3), op(3-3), op(4-3), op(6-3), and op(8-3) to alternative machines. According to Fig. 2, M3 and M17 serve as alternatives for M10. Before the machine failure, the optimizers generated the scheduling using all machines (M1–M21). Once M10 experiences a breakdown, the optimizer identifies and manages the disrupted operations after filtering out the faulty machine. The remaining operations are then optimally rescheduled among the functional machines.

For instance, as illustrated in Fig. 6, machine M10 fails at time 20. The disrupted operation op(1-3) is reassigned to M17 by the optimizer, while op(3-3) is executed by M3 after the completion of op(2-3). Similarly, op(4-3) is moved to M17, op(6-3) to M3, and op(8-3) also to M3. Following the failure, the optimization algorithm—whether using GWO or PSO—redistributes operations from the functioning machines to suitable alternatives, ensuring minimal disruption and maintaining scheduling efficiency.

Scenario 2: dynamic flexible rescheduling with extended makespan

Scenario 2 focuses on addressing machine failures during the execution of the optimized schedule generated by the optimization module. During the machine failure handling, the dynamic event is triggered when a machine failure situation is detected at a certain time, as reported by the DT monitoring module, which provides also a list of failed machines. The algorithm in this scenario works as follows:

• 1.

  Classifying operations:

• At the failure time, adding each operation to one of the following categories:

  • •

    Finished operations (operations completed before the failure time).

  • •

    Executing operations (ongoing operations at failure time).

  • •

    Disrupted operations (ongoing operations on failed machines at failure time).

• 2.

  Filtering machine options:

  • •

    This step removes failed machines from the alternative machine set for each operation.

• 3.

  Identifying following operations:

  • •

    This step identifies all operations that follow disrupted operations in the same job. For example, if operation number 4 is marked as disrupted operation, so operations number 5, 6 and 7 are all marked as following operations within the same job.

• 4.

  Redistribute disrupted operations:

  • •

    At this point, the algorithm reassigns disrupted operations to alternative machines while respecting precedence constraints and machine availability time according to Eq. (11).

  (11) $$\sum _{k=1}^{m}x{o}_{jidk}=1\mathrm{\forall }{o}_{jid}\in \left\{DO\right\},\mathrm{\forall }k\in \left\{A{M}_i\right\}\mathrm{a}\mathrm{n}\mathrm{d}k\notin \left\{FM\right\}.$$

• 5.

  Reassign following operations:

  • •

    After redistributing all disrupted machines to the alternative machines, the following operations are reassigned to their initial assigned machines but after extending the start time of the operation to the maximum of either the machine’s availability time or the completion time of the precedence operation within the same job. This expressed in Eq. (12).

  (12) $$ST{O}_{j\left(i\right)kfl}=Max\left(ET{O}_{j\left(i-1\right)},C{T}_k\right)$$where $ST{O}_{j\left(i\right)kfl}$ is the start time of operation $O_{j\left(i\right)}$, which is originally assigned to machine $k$ and follows a disrupted operation. $ET{O}_{j\left(i-1\right)}$ is the end time of the preceding operation within the same job, and $C{T}_k$ is the availability time of machine $k$.

• 6.

  New schedule and makespan:

  • •

    The new schedule and its makespan are calculated and stored.

• 7.

  Visualize the updated schedule:

  • •

    Generate a Gantt chart to visualize the updated schedule, highlighting the changes caused by the machine failure and the redistribution process.

  • •

    This information is fed back to DT module to update and start monitoring the execution of the updated schedule

Scenario 2 does not involve the use of optimization techniques. Instead, it relies on a shifting mechanism to reassign the disrupted operation to one of the available alternative machines. Subsequently, all the following operations are shifted accordingly to maintain the precedence constraints. As a result, Scenario 2 does not require the application of GWO or PSO. The pseudocode, illustrating the implementation of Scenario 2 and the shift methodology, is presented in Fig. 7.

First, as a case study, we explain here the operation of shifting algorithm after machine M10 fails. First, the disrupted operations, that were executed by the failed machine (op(1-3), op(2-3), and op(9-3)), are rescheduled on the related alternative machines M3 and M17. To decide which machine to select, the algorithm tests the two alternative machines. The machine with the earliest end time is chosen. Figure 8 shows the rescheduling process for these three disrupted operations. The new start time of the disrupted operation op(1-3) is selected as the maximum value between the end time of the previous operation, failure time, and machine availability time as in Eq. (13).

(13) $$NST{O}_{j\left(i\right)kd}=Max\left(ET{O}_{j\left(i-1\right)},T_F,C{T}_k\right)$$where $NST{O}_{j\left(i\right)kd}$ is the new start time of the disrupted operation $O_{j\left(i\right)}$ on machine $k$, selected from the alternative machine set. $T_F$ is the machine failure time.

For a given processing time $P_{j\mathrm{i}k}$ for the rescheduled operation, the new end time $NET{O}_{j\left(i\right)kd}$ is found by Eq. (14).

(14) $$NET{O}_{j\left(i\right)kd}=NST{O}_{j\left(i\right)kd}+P_{jik}$$where $NET{O}_{j\left(i\right)kd}$ is the new end time of the disrupted operation $O_{j\left(i\right)}$, and $P_{jik}$ is the processing time of that operation on machine $k$.

According to the last step, the best executive selected machine is the machine with the earliest end time following Eq. (15).

(15) $$BM{O}_{j\left(i\right)d}=Min\left[NET{O}_{j\left(i\right)dk}\right]\mathrm{\forall }k\in \left\{A{M}_i\right\}\mathrm{a}\mathrm{n}\mathrm{d}k\notin \left\{FM\right\}$$where $BM{O}_{j\left(i\right)d}$ is the selected machine to process the disrupted operation $O_{j\left(i\right)}$. $\left[NET{O}_{j\left(i\right)dk}\right]$ is the list of new end times for this operation calculated for each alternative machine. $A{M}_i$ is the set of alternative machines for operation $i$, and $FM$ is the set of failed machines.

Then, the machine availability of the selected machine is updated accordingly.

Second, an explanation of the following operations is configured in Fig. 9 to clarify the rescheduling process of the following operation. Table 4 shows the disrupted operations in M10 and their following operations according to Fig. 2. In this case, the new start and end times are calculated from Eqs. (13) to (15). For the same machine, the machine’s availability is then adjusted according to the new end time (Eq. (14)). As a result, we examine the reassign of the following operations of the disrupted operation op(1-3) which are op(1-4), op(1-5), op(1-6) and op(1-7). As shown in Fig. 9, all the following operations are assigned to the same machine that was assigned to before, but there is an extension in the start time of the following operation and the start time can be calculated as in Eq. (12). We will explain a numerical example for op(1-4). The machine M11 is available at the time of 64 after op(8-4) whereas its preceding operation of op(1-3) ends at time of 68. Therefore, operation op(1-4) has been rescheduled at the time of 68. According to Eq. (12), the operation op(1-4) starts at a time of 68. Operation op(1-5) starts as soon as operation op(1-4) ends at the time of 72. For operation op(1-6), the condition of machine availability is the dominant. So, this operation starts after operation op(8-6) ends at the time of 75. Operation op(1-7) will start instantaneously after operation op(1-6) ends, at time 77.

Energy consumption calculation

To validate the algorithm for calculating energy consumption, we utilized a dataset from IEEE (2020), which contains measurements from a Brazilian poultry feed factory. This dataset includes readings of active power, reactive power, apparent power, current, and voltage for milling machines, pelletizers, and other factory equipment. The algorithm uses the optimization algorithm results as input to compute the total energy consumption of all machines in the optimal solution. For this evaluation, data was specifically considered for three milling machines, three pelletizers, and three exhaust fans (coolers). Energy consumption was calculated for all production lines, assuming that other machines of the same type (e.g., mixing, liquid addition, scaling, and sewing machines) consume the same amount of energy. Additionally, standby energy consumption for idle machines was disregarded.

For a given dataset of nine machines across three production lines, the total energy consumption of the factory is calculated through the following steps:

• •

  Calculate the average power $P_{avk}$ for each machine over one working day. The average power is derived from the machine’s measured power as in Eq. (16). (16) $$P_t=V{I}_t\cos \phi$$

• where $P_t$ is the power at time t, $V$ is the voltage on the machine, $I_t$ is the current withdrawn at time t, and $\cos \phi$ is the power factor.

• •

  Determine the current schedule and count the running time of each machine $R{T}_k$.

• •

  Compute individual machine energy consumption $E{C}_k$ by multiplying each machine’s average power by its running time according to Eq. (17). (17) $$E{C}_k=P_{avk}\times R{T}_k.$$

• •

  Calculate total energy consumption $TEC$ by summing up the energy consumption of all machines. (18) $$TEC=\sum E{C}_{k}wherek\in \left(1,4,5,8,11,12,15,18,19\right).$$

Generalizability of the proposed GWO and PSO algorithms

Before applying the proposed GWO and PSO algorithms to the poultry factory dataset, their validity and effectiveness have been first evaluated using a well-established benchmark. Specifically, the Brandimarte dataset (BRdata), originally introduced in Brandimarte (1993), is employed. This benchmark comprises ten standard test problems, labeled MK01 through MK10, representing a diverse range of FJSSP scenarios. These instances vary in complexity, with the number of jobs ranging from 10 to 20, machines from four to 15, and operations per job ranging from five to 15. The performance of the proposed algorithms is evaluated over 30 independent computational runs. The numerical results of the proposed GWO and PSO approaches are listed in Table 6 with a comparison to the outcomes from prior studies (Zhou et al., 2024) and (Naimi, Nouiri & Cardin, 2021; Sun et al., 2023; Li & Zhou, 2025) that utilized alternative optimization techniques to assess the competitiveness and generalizability.

The experimental results highlight the effectiveness of both PSO and GWO algorithms in solving the Brandimarte benchmark set MK01–MK10 (in Table 6). Across the ten test cases, both approaches deliver competitive makespans that align closely with, and in some instances match, the best-known results reported in recent literature. For example, in MK01 and MK03, both PSO and GWO achieve makespans near or equal to the global optima, demonstrating their reliability on standard instances. In more complex problems such as MK06, MK09, and MK10, the algorithms maintain strong performance, producing makespans within a narrow margin of the best reference values in Li & Zhou (2025). While PSO often requires slightly more execution time, it consistently delivers quality results across problem sizes. The GWO, on the other hand, shows a tendency for faster convergence in some cases. Overall, both algorithms can handle a wide range of flexible job shop configurations, validating the proposed algorithm’s adaptability and robustness in addressing real-world scheduling challenges.

Generating the healthy scheduling plan

Generating the healthy scheduling plan is the foundational step in job-shop scheduling, as it represents the optimal sequence and machine assignments for all operations under normal operating conditions, i.e., without any disturbances such as machine failures. In this stage, metaheuristic optimization algorithms including both GWO and PSO are employed to explore the solution space and determine a schedule that minimizes the makespan while satisfying all precedence and resource constraints. The healthy schedule not only ensures that operations are allocated to machines in a manner that avoids conflicts and idle times but also forms the baseline against which any rescheduling strategies are evaluated in the event of disruptions. It reflects the best-case scenario in terms of efficiency and serves as a reference for assessing the impact of failure scenarios on production performance.

For GWO, the healthy schedule is generated as shown in Fig. 10 with minimum makespan = 76, achieved at the 44^th iteration. While For PSO, the healthy schedule is generated as shown in Fig. 11 with minimum makespan = 76, achieved at the 47^th iteration. From Figs. 10 and 11, it can be noticed that both algorithms achieved the same minimum makespan. The difference is in the distribution of operations on the machines.

Optimizing the completion time

In this section, we present a comprehensive numerical analysis to evaluate the performance of our proposed algorithm across several examples. For each case study, the analysis begins with the evaluation of the healthy schedule, which is generated using either GWO or PSO. Since both algorithms yield identical makespan values in the healthy state, the distinction lies solely in the distribution of operations across the machines. Subsequently, we examine the results under Scenario 1 using both GWO and PSO. While the outcomes are generally consistent, minor variations may occur due to algorithmic differences. Lastly, we assess Scenario 2, which does not involve any optimization algorithm but instead relies solely on a shifting mechanism to reschedule operations.

Three case studies are explored to demonstrate the impact of key parameters—namely, the failure time and the identity of the failed machines—on scheduling performance. These case studies were carefully selected to highlight the influence of these primary factors. As expected, failures occurring later in the schedule lead to smaller increases in makespan, since a larger portion of operations have already been completed, leaving fewer to be rescheduled. Additionally, the criticality of the failed machine significantly affects the results: failures in major machines, such as milling or pelletizing units, have a more substantial impact on the scheduling outcome compared to failures in less critical equipment like sewing machines, packing units, or coolers.

In the first case study, the failure occurs at time unit 20, affecting two critical machines: M1 and M10. In the second case study, although the failure time remains the same at 20, the failed machines are different—M8 and M18—which alters the rescheduling dynamics and potentially reduces the impact on the overall schedule depending on the roles of these machines. The third case study maintains the same failed machines as the second one (M8 and M18), but shifts the failure time to 30. This adjustment allows more operations to be completed before the disruption, leading to a less pronounced effect on the makespan.

These variations across the case studies were purposefully designed to demonstrate the sensitivity of the schedule to both the timing and the location of machine failures. The next section provides a focused analysis of energy consumption using these same three case studies, allowing for a comparative evaluation not only of scheduling efficiency but also of operational sustainability.

A) Case study (1)

In this case study, the failure occurs at time 20, affecting machines M1 and M10. Prior to the anomaly, the optimal makespan is 76, achieved at the 10th iteration. Following the failure event, both the GWO and PSO algorithms optimally redistribute operations among the remaining healthy machines. Under Scenario 1, the optimal makespan after the failure is 80 when using GWO and 83 when using PSO. The convergence curves are presented in Fig. 12. It is notable that the fitness curves after the anomaly are nearly horizontal, as the optimization process is initialized using the pre-anomaly optimal schedule, allowing for faster convergence.

Figures 13, 14, and 15 illustrate the healthy operation case, the GWO-optimized schedule under Scenario 1, and the PSO-optimized schedule under Scenario 1, respectively. Job operations are allocated across machines based on the results of the optimization algorithm presented in Fig. 10. A dynamic event (machine failure) is detected at the failure time $T_F=20$, triggering the rescheduling process.

Machines M1 and M10 are identified as having anomalous operations. In this scenario, all the completed operations remain unchanged, while the operations ongoing at $T_F=20$ are treated in two distinct ways. For the healthy machines, the operations in progress at $T_F=20$ are termed executing operations and these operations remain intact, and they are still assigned to their initial machines in order not to experience a delay in the makespan completion time. For the failed machines at $T_F=20$, the operations in progress are termed disrupted operations. Furthermore, operations scheduled after $T_F=20$ are all categorized as remaining operations along with the disrupted operations. In this case, remaining operations are redistributed in accordance with the adopted evolutionary optimization algorithm. At the failure time $T_F=20$, all remaining operations are redistributed using the proposed GWO approach, based on Eqs. (5)–(8) in ‘Initial Scheduling’, and the proposed PSO approach, based on Eqs. (9) and (10). It is important to note that the time required to rerun the optimization algorithms is not included in the makespan calculation.

Figure 16 shows the Gantt chart when applying Scenario 2. The makespan in this case is 87, the disrupted operations are op(1-3) and op(2-3). Op(1-3) is reassigned to M3 and op(2-3) is reassigned to M17. Consequently ops(1-4:7) and ops(2-4:7) are extended to be processed on the same assigned machine as the healthy case but shifted in time until the previous operation is done or the machine is available.

As a numerical case study for Scenario 1, Job 2 (illustrated in blue in Fig. 11) originally follows a sequence of seven operations processed on seven different machines: M8, M9, M10, M18, M12, M13, and M14. This operation sequence is determined in the healthy state based on the predefined machine selection and scheduling plan. Specifically, op(2-1) begins execution on M8 and is immediately followed by op(2-2) on M9, and then op(2-3) on M10, reflecting a continuous and optimized workflow.

Upon the occurrence of a machine failure, ops(2-1) and (2-2) are left unchanged—(2-1) is already completed, and (2-2) is in execution—thus, both are preserved in the new schedule as finished and executing operations, respectively. However, op(2-3), which was originally scheduled on the now-failed machine M10, is reassigned to an alternative machine, M17. The remaining operations of Job 2 are subsequently redistributed while maintaining their original order, adapting to the updated resource availability.

This rescheduling process successfully preserves the consistency of the job’s execution and minimizes delays in the overall completion time. It demonstrates the robustness and adaptability of the scheduling strategy under disruption, ensuring continuity and efficiency even in the presence of machine failures.

B) Case study (2)

In this case study, the failure time equals 20 and the failed machines are M8 and M18. The optimal makespan, prior to the anomaly, is 76 at the 46^th iteration. However, once the anomaly event occurred, the GWO and the PSO algorithms optimally redistribute the operations among all healthy machines. After the failure and when running Scenario 1, the optimal makespan is 85 while with the PSO is also 86. The convergence curves are shown in Fig. 17.

Figures 18, 19, and 20 illustrate the healthy operation case, the GWO-optimized schedule under Scenario 1, and the PSO-optimized schedule under Scenario 1, respectively, each depicting the system’s behaviour under anomaly conditions. While job operations are allocated among the machines based on the results of the optimization algorithm shown in Fig. 10, a dynamic event has been detected at the failure time of $T_F=20$. Machines M8 and M18 are identified as having anomalous operations. In this scenario, all the completed operations remain unchanged, while the operations ongoing at $T_F=20$ are treated in two distinct ways. For the healthy machines, the operations in progress at $T_F=20$ are termed executing operations and these operations remain intact, and they are still assigned to their initial machines in order not to experience a delay in the makespan completion time. For the failed machines at $T_F=20$, the operations in progress are termed disrupted operations. Furthermore, operations scheduled after $T_F=20$ are all categorized as remaining operations along with the disrupted operations. In this case, remaining operations are redistributed in accordance with the adopted evolutionary optimization algorithm.

At the failure time $T_F=20$, all remaining operations are redistributed using the proposed GWO approach, as defined by Eqs. (5)–(8), and the proposed PSO approach, as defined by Eqs. (9) and (10), all in ‘Initial Scheduling’.

Figure 21 presents the Gantt chart corresponding to Scenario 2. In this case, the makespan reaches 81. The disruption involves two operations: op(7-4) and op(9-4). Due to the failure of their originally assigned machines, op(7-4) is reassigned to machine M4, while op(9-4) is reassigned to machine M11. As a result of these reassignments, the subsequent operations—ops(7-5) through (7-7) and ops(9-5) through (9-7)—maintain their original machine assignments as defined in the healthy schedule. However, these operations are shifted in time, ensuring they start only after their preceding operations are completed and their respective machines become available. This time-shifting strategy preserves operational precedence and resource feasibility, ensuring the continuity of job execution with minimal additional delays.

C) Case study (3)

In this case study, the failure occurs at time 30, affecting machines M8 and M18. Prior to the anomaly, the optimal makespan is 76, achieved at the 32nd iteration. Following the failure event, both the GWO and PSO algorithms optimally redistribute the remaining operations among the healthy machines. Under Scenario 1, the optimal makespan after the failure is 82 when using GWO, and 83 when using PSO. The corresponding convergence curves are presented in Fig. 22.

Figures 23, 24, and 25 illustrate the healthy operation case, the GWO-optimized schedule under Scenario 1, and the PSO-optimized schedule under Scenario 1, respectively, all under anomaly conditions. While job operations are allocated among the machines based on the results of the optimization algorithm shown in Fig. 10, a dynamic event has been detected at the failure time of $T_F=30$. Machines M8 and M18 are identified as having anomalous operations.

Figure 26 shows the Gantt chart when applying Scenario 2. The makespan in this case is 88, the disrupted operations are op(4-4) ,op(5-4) and op(9-4). Op(4-4) is reassigned to M11 and op(5-4) is reassigned to M11, while op(9-4) is reassigned to M4. Consequently ops(4-5:7), ops(5-5:7) and ops(9-5:7) are extended to be processed on the same assigned machine as the healthy case but shifted in time until the previous operation is done or the machine is available.

Table 7 presents the start and completion times for all jobs in the healthy state and after the failure of machines M1 and M10 (case study 1), using both Scenario 1 and Scenario 2. For Scenario 1, results are shown for both GWO and PSO implementations. It is observed that most jobs begin at the same time across the healthy state, Scenario 1, and Scenario 2. However, the key distinction lies in the jobs’ completion times. While some jobs experience only minor delays, others are significantly affected, with completion time extensions reaching up to 48 time units.

Table 8 provides a summary of the results from the three case studies, including the healthy state, Scenario 1 using GWO, Scenario 1 using PSO, and Scenario 2.

In Fig. 27, a pairwise comparison is presented, illustrating the extended makespan resulting from simulating failures in each of the alternative machines (one at a time) for three specific operations: Operation 1 (milling) depicted in Fig. 27A, Operation 3 (adding liquid) as shown in Fig. 27B, and Operation 5 (cooling) compared in Fig. 27C. The comparison is done in both Scenario 1 and Scenario 2. For instance, the milling operation can be completed by machine M1 in 18 time units, while machines M8 and M15 can handle the same operation in 6 and 4 time units, respectively. This implies that if a fault occurs in a high-power rating machine like M15, which is assigned to four or five operations, the makespan extension could be significant.

Redistributing these operations to lower-power rating machines would result in considerably longer processing times. But this is not the only factor to be weighed as there is also the impact of the failure time and how busy the alternatives are. When M1 is experiencing failure at time 10, the workload will be distributed upon both M8 and M15. But due to its long processing time (18 units of time), it was not loaded with many operations in the initial schedule. This led to only 12% makespan extension using Scenario 1 and 29% using Scenario 2.

When studying the add liquid operation, M3 can handle the operation in 8 time units, while machines M10 and M17 can handle the same operation in 6 and 4 time units, respectively. If M10 fails at time 10, its scheduled operations will be distributed between M3 and M17 leading to 10% makespan extension when rescheduling with Scenario 1 and 15% with Scenario 2.

Energy consumption before and after failure

In this subsection, the estimated energy consumption is recorded for three simulated scenarios for both GWO and PSO optimization algorithms such as: (1) healthy operation with GWO scheduling, (2) faulted operation handled using Scenario 1, and (3) faulted operation handled using Scenario 2. Table 9 presents the estimated energy consumption for these three operational states. As observed, energy consumption in the healthy state is the lowest. When comparing the two fault-handling scenarios, Scenario 2 exhibits lower energy consumption. This is because Scenario 2 applies GWO and PSO optimization only once, followed by a machine break-down shifting technique. In contrast, Scenario 1 applies the GWO and PSO both before and after the anomaly event, redistributing operations to minimize the maximum makespan without explicitly considering energy consumption.

Table 9 is provided to the decision makers in the manufacturing plant through a user dashboard, enabling them to evaluate the trade-off between time and energy consumption. Then, they select a balanced scheduling strategy based on additional factors such as product delivery deadlines, worker shift schedules, and the available budget.

The provided results illustrate the performance of different rescheduling strategies under three case studies, focusing on makespan and energy consumption. In the healthy state across all three cases, the system consistently achieves the shortest makespan of 76-time units. This is expected, as a healthy state reflects normal operations without any disruptions. Additionally, energy consumption in this state is relatively low, establishing a baseline for evaluating the other scenarios.

When a machine breakdown occurs, Scenario 1 employs optimization techniques (GWO and PSO) to reschedule the operations. These methods inevitably lead to an increase in makespan due to the constraints imposed by the disrupted machine. In most instances, GWO produces a slightly shorter makespan than PSO, suggesting that it is more effective in minimizing total schedule time. However, this benefit comes with a cost: GWO tends to consume significantly more energy compared to PSO. For instance, in Case Study 1, GWO results in a makespan of 80 but with an energy consumption of 691.04 kWh, whereas PSO yields a makespan of 83 with only 563.23 kWh. This trend is especially prominent in Case Study 3, where GWO consumes 814.35 kWh, while PSO consumes just 523.93 kWh, highlighting PSO’s superior energy efficiency despite slightly longer processing times.

Scenario 2 represents a simpler or more conservative rescheduling strategy. Although it consistently results in the highest makespans across all case studies, its energy consumption remains very close to that of the healthy state. This indicates that Scenario 2 likely involves minimal changes to the original schedule, thereby preserving energy efficiency but at the expense of longer completion times.

In summary, GWO is more aggressive in minimizing makespan but consumes more energy, while PSO strikes a better balance by controlling energy use at the cost of a marginally higher makespan. Scenario 2, on the other hand, maintains energy efficiency by limiting the extent of rescheduling, though this results in suboptimal makespan performance. The choice of rescheduling strategy, therefore, depends on whether the priority is to save time, reduce energy consumption, or maintain a balance between the two.