A Structural Decomposition-Based Optimization Approach for the Integrated Scheduling of Blending Processes in Raw Material Yards

Abstract

The blending process in raw material yards is essential for maintaining precise material proportions in downstream production, directly influencing product quality and energy efficiency in industries such as steel and coal processing. However, stringent operational constraints, including silo capacity limits, discharge rates, equipment movement delays, and a strict no-empty-silo requirement, result in a strongly coupled, high-dimensional combinatorial scheduling problem. In this paper, we develop a mixed-integer nonlinear programming (MINLP) model to capture the complex dynamics of silo weight and equipment operations. The primary scientific contribution of this work lies in the theoretical discovery of a structural decoupling property within the complex MINLP. We analytically prove that by fixing the replenishment sequence, the intractable global problem can be rigorously decomposed into two subproblems: a linear programming (LP) problem for silo-filling cart scheduling and a shortest-path problem solvable via dynamic programming (DP) for reclaimer scheduling. Leveraging this decomposition, a two-stage metaheuristic algorithm is proposed, combining greedy initialization with multi-round simulated annealing enhanced by local search. Experimental validation using real industrial data demonstrates that the proposed method consistently outperforms the greedy algorithm. Crucially, while the commercial solver Gurobi struggles to converge within a practical 1800 s time limit, our approach yields comparable solution quality in mere seconds. Furthermore, robustness analysis under a 20% demand surge confirms the algorithm’s adaptive capability, maintaining the silo weight stability through re-optimization. This research provides a robust, computationally efficient solution for the blending process in raw material yards.

1. Introduction

The blending process in raw material yards is a critical operation widely adopted in industries such as steelmaking and coal preparation, where operational performance directly determines the accuracy of downstream mixing ratios, product quality, and energy consumption [1]. As illustrated in Figure 1, this process requires the coordinated operation of several key devices to enable continuous material flow and precise blending.

A typical system begins with a primary stockyard where different raw materials (RMs) are stored in distinct stockpiles. Rail-mounted reclaimers traverse the stockyard to extract materials. Their scheduling involves determining which reclaimer (at position $p(k,i)$) retrieves material from which stockpile at each time interval k. The reclaimed material is then deposited onto a shared belt conveyor system. This conveyed material is received by a silo-filling cart, also on rails, whose position at interval k is denoted as $q\left(k\right)$. The cart’s role is to distribute the material to a series of blending silos (Silo 1, 2, …, l). Each silo is replenished at a filling rate $v_{+}\left(j\right)$. The final blending stage occurs as each silo discharges its material at a predetermined, constant rate $v_{-}\left(j\right)$ onto a common “blending yard” conveyor. The synchronized discharge from all silos as the conveyor moves forward achieves the homogenous mixture required for downstream production. Thus, the entire process forms an integrated chain (the red arrows representing the direction of material flow): stockpiles → reclaimers → primary conveyor → silo-filling cart → silos → blending conveyor, where optimizing the scheduling of the reclaimers and the cart is essential for maintaining continuous flow, meeting blend specifications, and adhering to strict operational constraints such as preventing silo emptiness.

From an engineering and optimization viewpoint, the blending process poses several tightly coupled challenges. First, the problem inherently involves mixed-variable decision-making, combining discrete choices (e.g., silo replenishment sequence and equipment assignment) with continuous temporal dynamics (e.g., the evolution of silo weight under concurrent discharge and filling rates). This hybrid nature results in a complex mixed-integer nonlinear programming (MINLP) formulation. Second, stringent operational constraints—notably the critical “no-empty-silo” requirement, silo capacity bounds, and sequence-dependent equipment travel times—create a highly constrained feasible region, rendering conventional relaxation techniques prone to infeasibility. Third, the necessity for rolling-horizon planning in the face of real-world parameter uncertainty and demand variability imposes a severe computational requirement: the algorithm must generate high-quality, feasible solutions within seconds to support practical online rescheduling.

Prior research on the integrated scheduling of blending yards has evolved along four main methodological lines, each presenting distinct trade-offs when addressing the triple challenge of real-time computation, strict feasibility guarantees, and high solution quality.

Exact approaches typically formulate equipment scheduling as mixed-integer linear/ nonlinear programs (MILP/MINLP) and obtain optima via branch-and-bound or commercial solvers. Such methods can guarantee optimality for small-scale instances, but as the number of tasks, equipment, and temporal resolution grow, the MILP formulation experiences explosive growth in size, leading to rapidly increasing solution times and limiting practical applicability [2].

To improve scalability for large-scale optimization problems, decomposition and relaxation techniques enhance solving efficiency by decoupling the problem structure, using methods such as master-subproblem splits [3,4], relaxation of non-crossing constraints [5], or Lagrangian relaxation [6,7]. While some approaches focused on partitioning models based on process flow [3] or relaxing non-crossing constraints to generate lower bounds [5], some international studies have moved toward more sophisticated architectures. For instance, reference [8] introduced a hybrid decomposition-based evolutionary and gradient-based algorithm, combining global exploration with rapid local refinement via sequential quadratic programming. Similarly, reference [9] proposed a distributed decomposition method utilizing right-hand side allocation to decouple global couplings into independent, parallelizable subproblems, thereby enhancing efficiency for large-scale mixed-integer programming. Although these approaches partly mitigate the scalability issue, they frequently require the generation and incorporation of sophisticated cutting constraints to avoid infeasibility or excessive relaxation. Moreover, subproblems, despite their reduced size, still involve nontrivial combinatorial optimization and typically rely on algorithms such as dynamic programming or shortest-path methods; algorithmic convergence and solution quality are often sensitive to parameters (e.g., dual multipliers and penalty factors), imposing substantial tuning effort in practice. Coordinating subproblems under tightly coupled engineering constraints (e.g., the no-empty-silo requirement) therefore remains a significant challenge.

Given the limitations of exact and decomposition methods in meeting both real-time and strict feasibility requirements, heuristics and metaheuristics—including greedy rules [10], genetic algorithms [11,12], Tabu Search [13], simulated annealing [14] and variable-neighborhood search [15]—are computationally efficient and thus attractive for online use. Recently, the field has transitioned from pure heuristics to hybrid and matheuristic frameworks. A notable example is the T-ALNS algorithm [16], which integrates Tabu Search within an adaptive large neighborhood search framework and utilizes an “elite pool” of solutions to construct restricted, solvable MILP models. Furthermore, ref. [17] combined genetic algorithms with simulated annealing (GA-SA) to improve global convergence by probabilistically escaping local optima in complex yard environments. However, their success depends critically on the embedded evaluation and feasibility-checking modules. Under the strict, non-relaxable operational constraints of the blending yard (e.g., silo capacity bounds and the no-empty-silo rule), these methods frequently generate infeasible candidate schedules. Consequently, they must either incorporate ad hoc, computationally expensive repair mechanisms or sacrifice solution quality by overly conservative sampling, severely limiting their effectiveness in tightly constrained search spaces.

Addressing the inherent constraints and performance trade-offs of classical approaches, recent advances in intelligent scheduling strategies have emerged in closely related domains. For mixed-integer programming (MIP) problems, unsupervised learning techniques, such as autoencoder-based methods, can learn from historical optimal solutions to generate valid cutting planes. This significantly tightens the MIP formulation and reduces solver time while maintaining solution quality [18]. For dynamic control and operational decision-making under uncertainty, reinforcement learning (RL) has demonstrated considerable efficacy. Adaptive RL frameworks, for instance, enhance the robustness and stability of industrial control systems through strategies like model weighting [19]. In parallel, the advent of large language models (LLMs) has introduced novel capabilities in strategic scheduling and planning. Their reasoning and heuristic-generation abilities have been leveraged to improve solutions for large-scale, constrained combinatorial optimization problems in areas such as production scheduling and logistics [20]. While these intelligent methods offer promising adaptability and data-driven learning, they face key challenges: an inherent lack of interpretability, limited generalization to diverse or unseen scenarios, and an inability to provide deterministic, verifiable performance guarantees.

In summary, for the online scheduling of blending yards with non-relaxable hard constraints, a significant methodological gap persists. Exact methods are too slow for real-time decision-making, decomposition/relaxation methods forfeit the deterministic feasibility required by rules like “no-empty-silo” in pursuit of speed, and pure heuristics lack the mechanism for rigorous constraint satisfaction, leading to unreliable or infeasible schedules. This gap specifically hinders the development of algorithms that are both reliable enough for stringent operational rules and fast enough for online, rolling-horizon scheduling of the integrated blending process. It underscores the need for a novel approach that can strictly preserve all hard constraints (like exact methods), enable deterministic and efficient evaluation of candidate solutions (unlike iterative decomposition schemes), and effectively explore the high-dimensional combinatorial sequence space (like metaheuristics).

To bridge this gap, this paper introduces a key structural insight and a resulting two-stage algorithmic framework. We prove that when the replenishment sequence is fixed, the originally coupled MINLP decomposes exactly into two tractable subproblems: (1) a linear programming (LP) model for the silo-filling cart, and (2) a shortest-path problem for the reclaimers solvable by dynamic programming (DP). Crucially, this decomposition preserves all hard constraints without any relaxation or iterative parameter tuning. It thus provides a deterministic, polynomial-time evaluator for any given sequence, which perfectly complements and empowers a metaheuristic search (e.g., simulated annealing) over the sequence space. This synergy allows our method to pursue high-quality solutions while guaranteeing feasibility and meeting the stringent sub-second to second-scale computation times required for online operational scheduling.

We summarize our main contributions as follows:

•

A novel MINLP formulation that accurately captures the integrated scheduling of the silo-filling cart and reclaimers, incorporating critical practical constraints such as equipment travel delays and the strict no-empty-silo requirement. This model provides a comprehensive foundation for optimizing blending processes under real-world industrial conditions.

•

A structural decomposition framework that reveals a key insight: when the replenishment sequence is fixed, the original MINLP decouples exactly into two tractable subproblems—a LP model for cart scheduling and a shortest-path problem for reclaimer routing solvable via DP. This decomposition preserves hard constraints without reliance on iterative relaxation or parameter tuning, enabling efficient and exact evaluations.

•

An efficient two-stage metaheuristic algorithm that leverages the above decomposition. It combines greedy initialization with simulated annealing enhanced by local search, where each candidate sequence is evaluated exactly using embedded LP and DP subroutines.

•

Comprehensive experimental validation using industrial data, including comparisons against a greedy baseline and the commercial solver Gurobi under a 24 h horizon. The results demonstrate the superiority of our method in both performance metrics and computational efficiency.

The remainder of this paper is organized as follows. Section 2 establishes the MINLP model for the integrated scheduling problem. Section 3 details the proposed two-stage algorithmic framework. Section 4 presents comprehensive numerical experiments and industrial case studies for validation. Finally, Section 5 concludes this paper and suggests future research directions.

2. Mathematical Modeling

The integrated scheduling problem requires coordinating two tightly linked decisions: (1) the timing and assignment of the silo-filling cart to replenish multiple silos, and (2) the routing and task assignment of the reclaimers to feed material to the cart. These decisions are coupled because the material type reclaimed must match the silo being filled. The system is governed by stringent hard constraints, most notably the requirement that no silo runs empty, alongside physical limits on silo capacity and equipment movement times. The following mathematical model formalizes these decisions, dynamics, and constraints.

2.1. Mathematical Model and Constraints for the Silo-Filling Cart Operation

The objective of cart scheduling is to determine the start and end times for a sequence of replenishment tasks, maximizing material input while ensuring the weight in each silo remains within safe upper and lower bounds at all times.

Introducing 0–1 variables, let $x(k,j)$ indicate whether the jth silo is replenished during the kth task, taking a value of 0 or 1. Let $t_s\left(k\right)$ and $t_e\left(k\right)$ denote the start and end times of the kth replenishment task, respectively. Given that the initial weight of the jth silo is $W(0,j)$, then, the weight of raw material in the jth silo at the start time of the kth replenishment task is:

$$\begin{array}{c}\hfill W_{ts}(k,j)=W_{te}(k-1,j)-v_{-}\left(j\right)(t_s\left(k\right)-t_e(k-1)).\end{array}$$

(1)

The weight of raw material in the jth silo at the end time of the kth replenishment task is:

$$\begin{array}{c}\hfill W_{te}(k,j)=W_{ts}(k,j)-v_{-}\left(j\right)(t_e\left(k\right)-t_s\left(k\right))+v_{+}\left(j\right)(t_e\left(k\right)-t_s\left(k\right))·x(k,j),\end{array}$$

(2)

where $v_{-}\left(j\right)$ and $v_{+}\left(j\right)$ represent the discharge rate of the silo and the replenishment rate of the jth silo, respectively. Substituting Equation (2) into Equation (1) yields:

$$\begin{array}{c}\hfill W_{te}(k,j)=W_{te}(k-1,j)-v_{-}\left(j\right)(t_e\left(k\right)-t_e(k-1))+v_{+}\left(j\right)(t_e\left(k\right)-t_s\left(k\right))·x(k,j).\end{array}$$

(3)

Equation (3) is a recurrence relation. Summing the terms in (3) yields the weight of the raw material in the jth silo at the end of the kth replenishment task:

$$\begin{array}{c}\hfill W_{te}(k,j)=W_{te}(0,j)-v_{-}\left(j\right)(t_e\left(k\right)-t_e\left(0\right))+v_{+}\left(j\right)\sum _{i=0}^k(t_e\left(i\right)-t_s\left(i\right))·x(i,j).\end{array}$$

(4)

Similarly, the weight of the raw material in the jth silo at the start of the kth replenishment task can be expressed as:

$$\begin{array}{c}\hfill W_{ts}(k,j)=W_{ts}(k-1,j)-v_{-}\left(j\right)(t_s\left(k\right)-t_s(k-1))\\ \hfill +v_{+}\left(j\right)(t_e(k-1)-t_s(k-1))·x(k-1,j).\end{array}$$

(5)

Summing these terms yields the weight of the raw material in the jth silo:

$$\begin{array}{c}\hfill W_{ts}(k,j)=W_{ts}(0,j)-v_{-}\left(j\right)(t_s\left(k\right)-t_s\left(0\right))+v_{+}\left(j\right)\sum _{i=1}^k(t_e(i-1)-t_s(i-1))·x(i-1,j),\end{array}$$

(6)

where $W_{te}(0,j)=W_{ts}(0,j)=W(0,j)$ represents the initial raw material weight in the jth silo.

The operational scheduling of the blending process in a raw material yard is subject to the following constraints:

(1)

The material weight in any silo must remain within the specified bounds both at the start time $t_s\left(k\right)$ and end time $t_e\left(k\right)$ of each replenishment task.

(2)

A sequence-dependent setup time $\Delta T$ is enforced between consecutive tasks to accommodate equipment repositioning and material transport.

(3)

Each replenishment task can only supply raw material to one silo.

That is:

$$\begin{array}{c}\hfill \left\{\begin{array}{c}{W}_L\left(j\right)\le W_{ts}(k,j),W_{te}(k,j)\le W_U\left(j\right)\hfill \\ t_s\left(k\right)-t_e(k-1)\ge \Delta T\hfill \\ t_e\left(n\right)\ge T_{horizon}\hfill \\ {\displaystyle \sum _{j=1}^{l}x(k,j)=1}\hfill \\ k=1,2\dots ,n\hfill \\ j=1,2\dots ,l\hfill \end{array}.\right.\end{array}$$

(7)

Here, $W_U\left(j\right)$ and $W_L\left(j\right)$ denote the upper and lower weight bounds for the jth silo, while l and n denote the total number of silos and tasks, respectively. Notably, a temporal span constraint $t_e\left(n\right)\ge T_{horizon}$ is enforced, where $T_{horizon}$ represents the mandatory scheduling horizon (e.g., 24 h). This constraint is instrumental in ensuring that the generated schedule fulfills long-term production requirements.

2.2. Mathematical Model and Constraints for the Reclaimer Operation

This subsection models the scheduling of the reclaimers. Once the replenishment sequence for the silos is determined (from Section 2.1), the reclaimers must be assigned to retrieve the corresponding materials from the stockyard. The core decisions are which reclaimer performs each task and the resulting travel path, with the objectives of minimizing total travel distance (and thus energy consumption) while respecting physical constraints such as the non-crossing of equipment on a shared rail.

Let $\theta (k,i)$ be a binary variable indicating whether the kth reclaiming task is performed by the ith reclaimer. Let $s\left(k\right)$ denote the coordinate of the target stockpile within the stockpile lane for the kth task. The material type of the target stockpile must match the type required by the corresponding silo; that is, $s\left(k\right)$ is determined by the material type associated with $x(k,j)$. Let $p(k,i)$ represent the actual position of the ith reclaimer when the kth task starts. Then, the travel distance $d\left(k\right)$ required for the reclaimer to complete the kth task can be expressed as:

$$\begin{array}{c}\hfill d_1\left(k\right)=\sum _{i=1}^m\theta (k,i)\left|\right|s\left(k\right)-p(k-1,i)\left|\right|,\end{array}$$

(8)

where m denotes the number of reclaimers operating on the same stockpile lane. Upon completion of the kth task, the position of the ith reclaimer can be updated as follows:

$$\begin{array}{c}\hfill p(k,i)=s\left(k\right)\theta (k,i)+p(k-1,i)(1-\theta (k,i\left)\right).\end{array}$$

(9)

Therefore, the total travel distance required by the reclaimers to complete n tasks is given by

$$\begin{array}{c}\hfill D_1\left(n\right)=\sum _{k=1}^n{d}_1\left(k\right)=\sum _{k=1}^n\sum _{i=1}^m\theta (k,i)\left|\right|s\left(k\right)-p(k-1,i)\left|\right|.\end{array}$$

(10)

The constraints are as follows:

(1)

Each reclaiming task must be executed by exactly one reclaimer, i.e.,

$$\begin{array}{c}\hfill \sum _{i=1}^m\theta (k,i)=1,k=1,2\dots ,n,\end{array}$$

(11)

where $\theta (k,i)\in \{0,1\}$.

(2)

The reclaimers are mounted on the same rail and cannot swap positions. Assuming reclaimers are indexed in the fixed order of their initial positions along the rail, the following non-crossing constraint must hold:

$$\begin{array}{c}\hfill p(k,0)\le p(k,1)\le \dots \le p(k,m)k=1,2\dots ,n.\end{array}$$

(12)

2.3. Multiple Optimization Objectives in the Blending Process

The optimization of the blending process mainly involves three objectives.

(1)

Maximize the total amount of raw material replenished, i.e., the sum of material replenished into all silos over a given number of tasks:

$$\begin{array}{c}\hfill \max J=max\sum _{k=1}^n\sum _{j=1}^l{v}_{+}\left(j\right)x(k,j)(t_e\left(k\right)-t_s\left(k\right)).\end{array}$$

(13)

(2)

Minimize the total travel distance of the reclaimers during the scheduling horizon, i.e.,

$$\begin{array}{c}\hfill min{D}_1=min\sum _{k=1}^n\sum _{i=1}^m\theta (k,i)\left|\right|s\left(k\right)-p(k-1,i)\left|\right|.\end{array}$$

(14)

(3)

Minimize the total travel distance of the silo-filling cart during the scheduling horizon, i.e.,

$$\begin{array}{c}\hfill min{D}_2=min\sum _{k=1}^n\left|\right|q\left(k\right)-q(k-1)\left|\right|.\end{array}$$

(15)

Here, $q\left(k\right)$ denotes the position of the silo-filling cart when executing the kth replenishment task. The cart must be located directly above the silo being replenished. Specifically, if in the kth task the cart replenishes silo j, its position is given by $q\left(k\right)=2·r·(j-1)$, where r represents the radius of each silo, and the center of the first silo is taken as the origin. Thus, $q\left(k\right)$ can be expressed as

$$\begin{array}{c}\hfill q\left(k\right)=\sum _{j=1}^{l}2·r·(j-1)·x(k,j).\end{array}$$

(16)

2.4. Integrated Multi-Objective Optimization Model

Based on the above modeling procedure, the integrated scheduling model for the stockyard blending process can be summarized as Equation (17).

The optimization objectives include maximizing replenishment efficiency, minimizing the travel distance of the reclaimers during their tasks and minimizing the travel distance of the silo-filling cart during its operations. The decision variables consist of binary variables $x(k,j)$ and $\theta (k,j)$, as well as continuous variables $t_s\left(k\right)$ and $t_e\left(k\right)$. A strong coupling exists between silo replenishment and stockpile reclaiming. Specifically, in each replenishment task, the raw material type of the target stockpile reclaimed by the reclaimer must match the type stored in the corresponding silo. As a result, the replenishment sequence of silos directly determines the reclaiming sequence of stockpiles.

$$\begin{array}{c}{\displaystyle maxJ=max\sum _{k=1}^n\sum _{j=1}^l{v}_{+}\left(j\right)x(k,j)(t_e\left(k\right)-t_s\left(k\right))}\hfill \\ {\displaystyle min{D}_1=min\sum _{k=1}^n\sum _{i=1}^m\theta (k,i)\left|\right|s\left(k\right)-p(k-1,i)\left|\right|}\hfill \\ {\displaystyle min{D}_2=min\sum _{k=1}^n\left|\right|q\left(k\right)-q(k-1)\left|\right|}\hfill \\ \mathrm{s}.t.\hfill \\ {\displaystyle W_{te}(k,j)=W_{te}(0,j)-v_{-}\left(j\right)(t_e\left(k\right)-t_e\left(0\right))+v_{+}\left(j\right)\sum _{i=0}^k(t_e\left(i\right)-t_s\left(i\right))·x(i,j)}\hfill \\ W_{ts}(k,j)=W_{ts}(0,j)-v_{-}\left(j\right)(t_s\left(k\right)-t_s\left(0\right))\hfill \\ {\displaystyle +v_{+}\left(j\right)\sum _{i=1}^k(t_e(i-1)-t_s(i-1))·x(i-1,j)}\hfill \\ W_L\left(j\right)\le W_{ts}(k,j),W_{te}(k,j)\le W_U\left(j\right)\hfill \\ t_s\left(k\right)-t_e(k-1)\ge \Delta T\hfill \\ t_e\left(n\right)\ge T_{horizon}\hfill \\ {\displaystyle \sum _{j=1}^{l}x(k,j)=1}\hfill \\ p(k,i)=s\left(k\right)\theta (k,i)+p(k-1,i)(1-\theta (k,i\left)\right)\hfill \\ {\displaystyle \sum _{i=1}^m\theta (k,i)=1,k=1,2\dots ,n}\hfill \\ p(k,0)\le p(k,1)\le \dots \le p(k,m)k=1,2\dots ,n\hfill \\ {\displaystyle q\left(k\right)=\sum _{j=1}^{l}2r(j-1)x(k,j)}\hfill \\ i=1,2\dots m\hfill \\ k=1,2\dots ,n\hfill \\ j=1,2\dots ,l\hfill \end{array}$$

(17)

3. Solution of the Optimization Problem

As established in the preceding analysis, the equipment scheduling problem for stockyard blending processes constitutes a large-scale, mixed-integer optimization problem characterized by multiple variables, multiple objectives, and strongly nonlinear couplings. While metaheuristic-based solution algorithms often entail substantial computational expense, and struggle to efficiently handle hard constraints like the “no-empty-silo” requirement, frequently generating infeasible solutions and drastically reducing search efficiency, they are often impractical for online dynamic scheduling. Conversely, greedy algorithms, though computationally efficient, typically produce overly conservative solutions to satisfy such constraints, thereby sacrificing solution quality.

To bridge this gap, we conduct a deeper analysis of the blending process model. A key insight emerges: if the replenishment sequence $x(k,j)$ is fixed, that is, if the assignment of the silo-filling cart over a given horizon is predetermined, then the cart’s operating path is fully determined. Under such conditions, the scheduling of the silo-filling cart reduces to computing the start and end times of each replenishment task. Moreover, because reclaimer scheduling is coupled exclusively with the replenishment sequence, fixing this sequence allows the original optimization problem (17) to be decoupled into two tractable subproblems:

(1)

Cart Scheduling Problem: A purely continuous-time problem to decide how long to fill each silo in the predetermined sequence, maximizing throughput while respecting weight constraints.

(2)

Reclaimer Routing Problem: A discrete assignment problem to decide which reclaimer should serve each task in the fixed sequence, minimizing total travel distance.

This decomposition is exact and does not require relaxing any hard constraints. The remainder of this section details the formulations of these two subproblems (Section 3.1 and Section 3.2) and then explains how this powerful decomposability is leveraged within a higher-level metaheuristic search to optimize the replenishment sequence itself (Section 3.5).

3.1. Solution to the Silo-Filling Cart Scheduling Problem

With a fixed replenishment sequence, all binary variables $x(k,j)$ become known parameters. The weight dynamics and constraints become linear functions of the only remaining decision variables: $t_s\left(k\right)$ and $t_e\left(k\right)$. Therefore, the subproblem simplifies to a linear program, which can be solved to global optimality very efficiently. The scheduling problem for the silo-filling cart can be reformulated as:

$$\begin{array}{c}{\displaystyle maxJ=max\sum _{k=1}^n\sum _{j=1}^l{v}_{+}\left(j\right)x(k,j)(t_e\left(k\right)-t_s\left(k\right))}\hfill \\ s.t.\hfill \\ {\displaystyle W_{te}(k,j)=W_{te}(0,j)-v_{-}\left(j\right)(t_e\left(k\right)-t_e\left(0\right))+v_{+}\left(j\right)\sum _{i=0}^k(t_e\left(i\right)-t_s\left(i\right))·x(i,j)}\hfill \\ W_{ts}(k,j)=W_{ts}(0,j)-v_{-}\left(j\right)(t_s\left(k\right)-t_s\left(0\right))\hfill \\ {\displaystyle +v_{+}\left(j\right)\sum _{i=1}^k(t_e(i-1)-t_s(i-1))·x(i-1,j)}\hfill \\ W_L\left(j\right)\le W_{ts}(k,j),W_{te}(k,j)\le W_U\left(j\right)\hfill \\ t_s\left(k\right)-t_e(k-1)\ge \Delta T\hfill \\ t_e\left(n\right)\ge T_{horizon}\hfill \\ k=1,2\dots ,n\hfill \\ j=1,2\dots ,l\hfill \end{array}.$$

(18)

An examination of the expressions for $W_{ts}(k,j)$ and $W_{te}(k,j)$ indicates that, given a known replenishment sequence $x(k,j)$ and the initial condition $W_{te}(0,j)=W_{ts}(0,j)=W(0,j)$, both $W_{ts}(k,j)$ and $W_{te}(k,j)$ can be written as linear functions of the decision variables $t_s\left(k\right)$ and $t_e\left(k\right)$. Moreover, the objective function and all remaining constraints are also linear. Therefore, with $x(k,j)$ fixed, the scheduling problem for the silo-filling cart reduces to a linear programming model, in which the decision variables are the continuous start time $t_s\left(k\right)$ and end time $t_e\left(k\right)$ of each replenishment task. This LP belongs to the class of P problems, meaning it is solvable in polynomial time. In this paper, the resulting LP is solved using an interior-point method, which has a polynomial-time complexity of $\mathcal{O}\left(\sqrt{n}log(1/ϵ)\right)$, where n denotes the number of variables and $ϵ$ denotes the solution accuracy [21,22]. This guarantees that a globally optimal solution of the LP problem can be obtained efficiently.

3.2. Solution to the Reclaimer Scheduling Problem

With the replenishment sequence fixed, the target stockpile location $s\left(k\right)$ for each task is known. The reclaimer scheduling problem then reduces to optimally assigning a sequence of known locations to multiple reclaimers on a rail, minimizing their total travel distance. This is analogous to a shortest-path problem in a state-space graph: each “state” represents a possible configuration of reclaimer positions after completing a certain number of tasks. The decision at each step is to choose which reclaimer moves to the next target location. The non-crossing constraint ensures the state space remains bounded. This structure allows the problem to be solved optimally and efficiently using dynamic programming, as opposed to a heuristic assignment rule.

When the sequence $x(k,j)$ is known, the optimization problem for reclaimer scheduling can be formulated as follows:

$$\begin{array}{c}{\displaystyle min{D}_1=min\sum _{k=1}^n\sum _{\mathrm{i}=1}^m\theta (k,i)\left|\right|s\left(k\right)-p(k-1,i)\left|\right|}\hfill \\ \mathrm{s}.t.\hfill \\ {\displaystyle \sum _{i=1}^m\theta (k,i)=1,k=1,2\dots ,n}\hfill \\ p(k,i)=s\left(k\right)\theta (k,i)+p(k-1,i)(1-\theta (k,i\left)\right)\hfill \\ p(k,0)\le p(k,1)\le \dots \le p(k,m)k=1,2\dots ,n\hfill \end{array},$$

(19)

where $s\left(k\right)$ denotes the coordinate of the target stockpile for the kth reclaiming task. The material type of the target stockpile must correspond to the type required by the associated silo; that is, the location $s\left(k\right)$, which is defined by the target material type, is determined by $x(k,j)$. Consequently, when $x(k,j)$ is known, $s\left(k\right)$ can be correspondingly determined.

A schematic diagram of the actual scraper reclaimers operating within a stockpile lane is shown in Figure 2, in which RM represents raw material. Without loss of generality, the number of reclaimers is set to two for this analysis.

When the sequence $s\left(k\right)$ is known and considering the number of reclaimers $m=2$ as an example, the decision-making process for reclaimer scheduling can be represented by a graph model, as illustrated in Figure 3. Here, $(p_1,p_2)$ represents the initial positions of the left (first) and right (second) reclaimer, respectively. At each decision step, either the first or the second reclaimer can be selected to execute the task. The variable $s\left(k\right)$ denotes the location of the target raw material. The distance between the location of the target material type and the reclaimer’s current position serves as the cost for the corresponding path. Taking the first task $(k=1)$ as an example: if the first reclaimer is selected, its position is updated to $s\left(1\right)$ after the task, and the travel distance for the first reclaimer is $\left|\right|s\left(1\right)-p_1\left|\right|$, while the position of the second reclaimer remains unchanged. Similarly, if the second reclaimer is selected for the first task, its position is updated to $s\left(1\right)$, with a travel distance of $\left|\right|s\left(1\right)-p_2\left|\right|$, and the position of the first reclaimer remains the same.

As observable from Figure 3, the nth task corresponds to $2^n$ nodes, indicating that the number of nodes grows exponentially with the number of tasks, making it difficult to quickly determine the optimal path. To obtain the optimal solution for the reclaimer scheduling problem efficiently, this study leverages the specific characteristics of the scheduling problem to delete and merge nodes, constructing a simplified path planning problem that is then solved optimally using a dynamic programming algorithm.

Assuming the number of stockpiles is c, and the multiple reclaimers are at distinct positions, then for the kth task, one and only one reclaimer must be positioned at $s\left(k\right)$, while the other reclaimers can be in at most $(c-1)(c-2)\dots (c-m+1)$ possible locations. Consequently, for m reclaimers, the maximum number of nodes corresponding to the kth task is $m(c-1)(c-2)\dots (c-m+1)$. When $m=2$, the maximum number of nodes for the kth task becomes $2(c-1)$. Therefore, for a prediction horizon of n tasks, the total number of nodes in the entire network is at most $2(c-1)n$. Solving this shortest-path problem using dynamic programming has a time complexity of $\mathcal{O}\left(2\right(c-1\left)n\right)$ [23], enabling rapid computation even for large values of n. The detailed dynamic programming algorithm is included in Appendix A.

3.3. Solution to the Silo-Filling Cart Travel Distance Optimization Problem

This subproblem presents a unique characteristic resulting from our structural decomposition. Unlike the timing (LP) and assignment (DP) subproblems, which require active optimization, the total travel distance of the silo-filling cart becomes a deterministic byproduct once the replenishment sequence is fixed. The cart’s path is dictated entirely by the order of silos it visits; there are no decisions left to optimize regarding its movement. Therefore, the cost $D_2$ can be calculated directly from the sequence with negligible computational overhead, requiring no iterative solution procedure.

The optimization problem concerning the travel distance of the silo-filling cart is rewritten as follows:

$$\begin{array}{c}{\displaystyle min{D}_2=min\sum _{k=1}^n\left|\right|q\left(k\right)-q(k-1)\left|\right|}\hfill \\ \mathrm{s}.t.\hfill \\ {\displaystyle q\left(k\right)=\sum _{j=1}^{l}2r(j-1)x(k,j)}\hfill \end{array}.$$

(20)

A fixed replenishment sequence $x(k,j)$ also determines the sequence of cart positions $q\left(k\right)$, thereby rendering the cart’s total travel distance a directly calculable constant that requires no additional solution effort.

3.4. Integration of Optimization Objectives

Optimization problem (17) encompasses three objectives:

Objective 1: Maximize the total replenishment amount under the same number of tasks:

$$\begin{array}{c}\hfill \max J=max\sum _{k=1}^n\sum _{j=1}^l{v}_{+}\left(j\right)x(k,j)(t_e\left(k\right)-t_s\left(k\right)).\end{array}$$

Objective 2: Minimize the total travel distance of the reclaimers during the scheduling process:

$$\begin{array}{c}\hfill min{D}_1=min\sum _{k=1}^n\sum _{i=1}^m\theta (k,i)\left|\right|s\left(k\right)-p(k-1,i)\left|\right|.\end{array}$$

Objective 3: Minimize the total travel distance of the silo-filling cart during the scheduling process:

$$\begin{array}{c}\hfill min{D}_2=min\sum _{k=1}^n\left|\right|q\left(k\right)-q(k-1)\left|\right|.\end{array}$$

This paper employs the weighted-sum method to integrate these three objectives into a single composite objective function. We first estimate the empirical bound for each objective: $J_{max}$, $D_{1max}$ and $D_{2max}$. Each objective is then normalized to a comparable, dimensionless scale (approximately [0,1]) using these bounds:

$$\begin{array}{c}\hfill \widehat{J}={\displaystyle \frac{J}{J_{max}}}{\widehat{D}}_1={\displaystyle \frac{D_1}{D_{1,max}}},{\widehat{D}}_2={\displaystyle \frac{D_2}{D_{2,max}}}.\end{array}$$

The composite function is defined as:

$$\begin{array}{c}\hfill Q=-{\omega }_1{\widehat{D}}_1-{\omega }_2{\widehat{D}}_2+{\omega }_3\widehat{J},\end{array}$$

(21)

where ${\omega }_1$, ${\omega }_2$, and ${\omega }_3$ are positive constants representing the weights assigned to their respective objectives.

3.5. Pre-Determination of the Replenishment Sequence

The preceding analysis indicates that for any given replenishment sequence, the solution to the linear programming problem (18), namely, the optimal start time $t_s\left(k\right)$, end time $t_e\left(k\right)$, and the corresponding maximum replenishment amount, can be obtained rapidly using an interior-point method. Simultaneously, the optimal scheduling strategy $\theta (k,i)$ for the reclaimers under the current sequence can be efficiently determined via dynamic programming.

Building on this, this paper proposes a two-stage metaheuristic algorithm for determining the replenishment sequence. The algorithm comprises a first stage that constructs an initial sequence using a “most-urgent-silo-first” greedy rule, calculated from the current material weight and discharge rate of each silo. In the second stage, an enhanced search strategy combining simulated annealing (SA) and local search is applied: the initial sequence is perturbed through neighborhood operators (swap, insertion, reversal, replacement) to generate candidate sequences, each of which is evaluated exactly and checked for feasibility using the embedded linear programming and dynamic programming sub-models. The fitness value of each feasible sequence is computed according to Equation (21). The Metropolis acceptance criterion guides the search process, allowing controlled exploration of the solution space. Through multiple independent runs, the SA algorithm iteratively improves solution quality, converging toward a near-optimal replenishment sequence and associated scheduling policy. The schematic diagram of the decision-making flow is shown in Figure 4. The process integrates the high-level combinatorial search for a replenishment sequence with the exact, decomposed evaluation of each candidate sequence via the LP and DP sub-solvers. The overall procedure is summarized below, and the corresponding pseudocode is shown in Algorithm 1.

Phase 1: Greedy Initialization

Step 1.1: Calculate the remaining discharge time for each silo:

$$\tau \left(j\right)={\displaystyle \frac{W(0,j)}{v_{-}\left(j\right)}}.$$

Step 1.2: Generate an initial replenishment sequence using the “most-urgent-silo-first” strategy: In each step, select the silo j with the smallest $\tau \left(j\right)$ and assign a replenishment task to it; update its remaining weight and remaining time. Repeat this process until the entire planning horizon is covered.

Phase 2: SA Optimization

Step 2.1: Candidate Solution Generation via Sequence Perturbation

(1)

Candidate sequences are generated by applying the neighborhood operators swap, insertion, reversal, and replacement to the current sequence.

(2)

Generate candidate sequences by repeatedly and randomly selecting from these perturbation operators.

Algorithm 1 Two-stage metaheuristic for integrated scheduling

Require:  Initial silo weights $W(0,j)$ for each silo j, discharge rates $v_{-}\left(j\right)$, replenishment rates $v_{+}\left(j\right)$, planning horizon parameters, SA parameters ($T_0$, $\alpha$, $T_{min}$) Ensure:  Optimized replenishment sequence $x(k,j)$, scheduling variables Phase 1: Greedy Initialization 1: for each silo j do 2:     $\tau \left(j\right)=W(0,j)/v_{-}\left(j\right)$                     ▹ Step 1.1 3: end for 4: Initialize empty sequence S 5: while planning horizon not covered do 6:     $j^{*}=arg{min}_j\tau \left(j\right)$                      ▹ Step 1.2 7:     Assign replenishment task to $j^{*}$ in S 8:     Update $W(k,j^{*})$ and $\tau \left(j^{*}\right)$ 9: end while 10: $\mathrm{current\_sequence}=S$ Phase 2: SA Optimization 11: $T=T_0$ 12: $\mathrm{best\_sequence}=\mathrm{current\_sequence}$ 13: while $T>T_{min}$ and iterations $<\mathrm{max\_iter}$ do            ▹ Step 2.4 Step 2.1: Candidate Generation via Perturbation 14:     $\mathrm{candidate\_sequence}=\mathrm{perturb}\left(\mathrm{current\_sequence}\right)$ Step 2.2: Precise Evaluation of Candidate 15:     Solve LP model (Equation (18)) for $\mathrm{candidate\_sequence}$ to obtain J 16:     if LP infeasible then 17:         continue                   ▹ Skip invalid sequence 18:     end if 19:     Solve DP model (Equation (19)) for $\mathrm{candidate\_sequence}$ to obtain $D_1$ 20:     Calculate $D_2$ using Equation (20) 21:     $\mathrm{fitness}=-{\omega }_1{\widehat{D}}_1-{\omega }_2{\widehat{D}}_2+{\omega }_3\widehat{J}$               ▹ Equation (21) Step 2.3: SA Acceptance Criterion 22:     $\Delta f=\mathrm{fitness}\left(\mathrm{candidate\_sequence}\right)-\mathrm{fitness}\left(\mathrm{current\_sequence}\right)$ 23:     if $\Delta f>0$ then 24:         $\mathrm{current\_sequence}=\mathrm{candidate\_sequence}$ 25:         if $\mathrm{fitness}\left(\mathrm{candidate\_sequence}\right)>\mathrm{fitness}\left(\mathrm{best\_sequence}\right)$ then 26:            $\mathrm{best\_sequence}=\mathrm{candidate\_sequence}$ 27:         end if 28:     else 29:         $r=\mathrm{random}(0,1)$ 30:         if $r<exp(\Delta f/T)$ then 31:            $\mathrm{current\_sequence}=\mathrm{cadididate\_sequence}$ 32:         end if 33:     end if 34:     $T=\alpha ·T$                   ▹ Cool down temperature 35: end while 36: return  $\mathrm{best\_sequence}$

Step 2.2: Precise Evaluation of Candidate Sequences

(1)

Silo-filling cart scheduling (LP subproblem): With the replenishment sequence $x(k,j)$ fixed, solve the linear programming problem (18) rapidly using an interior-point method to obtain the maximum replenishment amount, $maxJ$. If no feasible solution is found, the candidate sequence is considered invalid.

(2)

Reclaimer scheduling (DP subproblem): With the sequence $x(k,j)$ fixed, solve the optimal reclaimer assignment problem (19) using dynamic programming to determine the minimum total travel distance (and energy consumption), $min{D}_1$.

(3)

Silo-filling cart travel distance: Given the fixed sequence $x(k,j)$, the total travel distance of the silo-filling cart becomes a predetermined constant, which can be calculated directly using Equation (20).

(4)

Calculate the fitness value for the current candidate sequence according to Equation (21).

Step 2.3: Simulated Annealing Acceptance Criterion

(1)

If the candidate solution is superior to the current solution, accept it.

(2)

If it is inferior, accept it with a probability of $P=exp(-\Delta E/T)$, where T denotes the current temperature, and $\Delta E$ represents the change in objective function.

(3)

Update the temperature according to the cooling schedule: $T=\alpha T$, where $\alpha$ is the cooling rate $(0<\alpha <1)$.

Step 2.4: Termination Condition

The algorithm terminates when either the maximum number of iterations is reached or the temperature drops below a predefined threshold. Upon termination, the best-found replenishment sequence and its corresponding scheduling strategy are output.

It should be emphasized that the selection of SA enhanced with local search (LS) operators is a deliberate design choice, tailored to the specific challenges of our problem. First, the search space comprises high-dimensional discrete sequences where the objective function, computed via the exact LP/DP evaluator, is deterministic but can be highly non-convex relative to sequence changes. SA is particularly well suited for such landscapes due to its probabilistic acceptance mechanism, which facilitates escape from local optima during the high-temperature phase and converges to a refined solution during cooling. This provides a necessary global exploration capability. Second, the embedded LP/DP evaluator is fast but not cost-free; thus, an algorithm that can efficiently leverage each evaluation is preferred. SA’s Markov chain structure systematically explores the neighborhood of a current solution, making effective use of each LP/DP call. Complementary to this, the LS operators (swap, insertion, reversal, replacement) enable intensified exploitation of promising regions identified by SA, leading to faster convergence and higher solution quality. This hybrid SA + LS strategy offers a favorable balance between exploration and exploitation. Compared to alternative metaheuristics, this combination is also pragmatically advantageous: it avoids the population management overhead and complex feasible-crossover design required by genetic algorithms for sequence problems, and it presents a simpler parameter tuning process (e.g., cooling schedule) compared to the memory and neighborhood management critical in Tabu Search, ensuring robustness and ease of implementation for online scheduling.

3.6. Receding Horizon Planning

To address the inherent challenges created by model inaccuracies and external disturbances in dynamic scheduling, this paper adopts a receding horizon planning (RHP) framework for the real-time optimization of the silo-filling cart and reclaimers. During the actual blending process in the raw material yard, the system experiences frequent, multi-source variability: fluctuations in the reclaimers’ pickup rates (which directly affect the replenishment rate of the silo-filling cart), time-varying silo discharge and downstream demand, and uncertainty in model parameters such as travel times. RHP provides a natural mechanism to incorporate newly observed information, adapt to changing pickup/discharge flows, and recover from disturbances while keeping each decision tractable.

The framework of RHP is shown in Figure 5; at each decision instant, an integrated schedule covering the next n task cycles is generated using the most recent system state and forecast data. Only the actions corresponding to the first task cycle are implemented; the horizon then shifts forward, and the optimization is repeated with updated information. This mechanism offers two principal advantages: (1) it enables continual integration of real-time state and disturbance updates, thus enhancing adaptability and robustness against uncertainties; and (2) by executing only the immediate decision before recomputing the plan, this method reduces the propagation of prediction errors and improves persistent constraint satisfaction.

A critical implication of this framework is that the underlying scheduling solver must be capable of producing high-quality feasible solutions within a strictly bounded computation time at each decision instant; otherwise, repeated online re-optimization under an RHP scheme would be infeasible.

4. Numerical Experiments Based on Industrial Data

4.1. Experimental Data and Settings

To validate the effectiveness and practicality of the proposed algorithm, real operational data from a raw material yard in a steel enterprise is employed. The experimental scenario involves 11 types of raw materials, corresponding to 11 silos and 11 stockpiles. The maximum capacity of each silo (unit: tons) is: $W_{max}=[736,736,736,736,736,736,736,736,520,520,520]$. The initial weight of the silo is set to 85% of its maximum capacity. This initial value must be sufficiently large to ensure the existence of a feasible solution throughout the scheduling process. If it is too low, it may result in an unavoidable empty silo situation, regardless of the scheduling strategy employed, due to insufficient time for replenishment. The replenishment rate for each silo (unit: tons/hour) is: $v_{+}=[2000,2000,2000,2000,2000,2000,2000,2000,1100,1100,1100]$, and the discharge rate for each silo (unit: tons/hour) is: $v_{-}=[100,150,100,150,150,50,50,100,50,50,50]$. Discharge and replenishment rates ($v_{-}\left(j\right)$ and $v_{+}\left(j\right)$), and the maximum capacity of each silo ($W_{max}$), are based on real equipment specifications from the collaborating enterprise. All algorithms are executed on a workstation equipped with an Intel i9-14900K CPU (3.2 GHz) and 64 GB of RAM.

4.2. Comparison Method

The proposed structural decomposition-based hybrid algorithm is compared against the greedy algorithm and the commercial solver Gurobi. The greedy benchmark strategy is implemented in two stages:

(1)

Silo-filling cart scheduling policy. A “most-urgent-silo-first” rule is used to schedule the filling cart. For each silo, the remaining discharge time is computed from the silo current weight and the silo discharge rate. Silos are prioritized in ascending order of remaining time, with the most urgent silo selected as the next replenishment target. To prevent empty-silo situations and maintain blending ratios, replenishment begins when the remaining discharge time falls below 0.5 h and ends when the silo weight reaches 85% of capacity.

(2)

Reclaimer scheduling policy. A nearest-reclaimer dispatch rule is used for reclaimers. Given the replenishment plan from the filling cart policy, stockpiles containing the required material types are identified, and the reclaimer with the minimum travel distance to each target is selected to perform the reclaiming task.

To enable an efficient solution with commercial solvers such as Gurobi, we transform the original MINLP problem into a MILP formulation, following the methodology outlined in reference [24]. This conversion primarily involves the linearization of nonlinear terms, including product terms and absolute value expressions, to ensure compatibility with standard MILP solvers.

For nonlinear terms involving binary-continuous variable products, such as $x(k,j)·(t_e\left(k\right)-t_s\left(k\right))$, we introduced the following linear constraints:

$$\left\{\begin{array}{c}\begin{array}{c}z(k,j)=x(k,j)·(t_e\left(k\right)-t_s\left(k\right)),\hfill \\ z(k,j)<=M\ast x(k,j),\hfill \end{array}\hfill \\ z(k,j)<=t_e\left(k\right)-t_s\left(k\right),\hfill \\ z(k,j)>=t_e\left(k\right)-t_s\left(k\right)-M\ast \left(1-x(k,j)\right),\hfill \\ z(k,j)>=0\hfill \end{array},\right.$$

where M is a constant, and $t_e\left(k\right)-t_s\left(k\right)\le M$.

For absolute value terms such as

$$min{D}_1=min\sum _{k=1}^n\sum _{i=1}^m\theta (k,i)\left|\right|s\left(k\right)-p(k-1,i)\left|\right|,$$

the absolute value term can be linearized as follows:

$$\left\{\begin{array}{c}{d}_1(k,i)\ge 0\hfill \\ d_1(k,i)\ge s\left(k\right)-p(k-1,j)\hfill \\ d_1(k,i)\ge p(k-1,j)-s\left(k\right)\hfill \end{array}.\right.$$

Thus, the second performance metric function can be rewritten as

$$min{D}_1=min\sum _{k=1}^n\sum _{i=1}^m\theta (k,i)d_1(k,i),$$

in which the product term can be further linearized.

After the linearization, the mathematical programming approach was solved using Gurobi 13.0.0 with an academic license. A hard time limit of 1800 s (30 min) was set for the solver. The run was terminated upon reaching this limit, and the best incumbent solution found at termination is reported for comparison.

To demonstrate the effectiveness of the proposed approach and to isolate the impact of each algorithmic component, comparisons are performed as follows:

(1)

Silo-filling cart scheduling: Under identical replenishment sequences, we compare the greedy filling cart policy with the LP-based filling cart policy. The evaluation metric is the total replenishment amount over the planning horizon (higher is better).

(2)

Reclaimer scheduling: Under identical replenishment sequences, we compare the greedy nearest-reclaimer rule with the DP-based shortest-path reclaimer scheduler. The evaluation metric is the total travel distance of all reclaimers (lower is better).

(3)

Integrated performance: The total replenishment amount, total reclaimer travel distance, and total travel distance of the silo-filling cart are compared under two replenishment sequences—one generated by the greedy algorithm and the other optimized by the simulated annealing procedure.

(4)

Performance comparison between the proposed algorithm and Gurobi.

4.3. Comparative Results

4.3.1. Comparison of Silo-Filling Cart Scheduling

Figure 6 compares the material weight trajectories in each silo over a 24 h horizon under two scheduling policies for the silo-filling cart: a greedy policy and a LP-based policy. Both policies were evaluated using the same replenishment sequence to ensure a fair comparison. The stockyard configuration includes 11 silos, with silos 1–8 having a maximum capacity of 736 t each and silos 9–11 a capacity of 520 t each. In the figure, the solid red line represents the weight trajectories under the LP-based policy, and the blue dashed line corresponds to those under the greedy policy. The dotted line indicates the upper and lower weight bounds for each silo. To maintain operational safety, the upper bound $W_U$ is set to 85% of the silo capacity: $W_U=0.85W_{max}$, while the lower bound $W_L$ is determined based on the discharge rate to ensure a minimum remaining discharge time of 0.2 h (12 min): $W_L=0.2\ast v_{-}$.

As illustrated in Figure 6, the greedy and LP-based scheduling policies coincide at the end of each replenishment operation: both terminate replenishment once the target silo reaches the capacity limit of 85%, thereby maximizing the material input per service. However, the greedy policy initiates replenishment significantly earlier than the LP-based approach. This conservative behavior stems from the need to avoid late replenishment when multiple silos exhibit short remaining discharge times simultaneously; as a result, the greedy strategy achieves a lower material delivery per replenishment cycle compared to the LP-based method.

Figure 7 compares the cumulative replenishment amount under the two strategies, with the vertical axis representing the cumulative replenished material and the horizontal axis indicating the number of replenishment tasks. The task count of 42 is derived by first applying the greedy algorithm to generate a feasible schedule for a 24 h planning horizon and recording the actual number of tasks produced in its solution. This ensures a fair and practical baseline for comparison. The solid and dashed curves correspond to the LP-based strategy and the greedy algorithm, respectively. Under the same replenishment sequence and an equal number of tasks, the proposed LP-based method achieves a substantially greater total replenishment amount. For 42 replenishment tasks, the maximum cumulative amount under the LP-based strategy reaches 22,388 t, compared to 18,882 t for the greedy algorithm—an absolute increase of 3506 t, representing an improvement of approximately 18.6%.

4.3.2. Comparison of Reclaimer Scheduling

The distance between adjacent stockpiles is normalized to a unit length of one. The two reclaimers are initially positioned at opposite ends of the stockpile array: reclaimer 1 at $p_1\left(0\right)=1$ and reclaimer 2 at $p_2\left(0\right)=11$. A non-crossing constraint is enforced throughout the scheduling horizon, ensuring $p_1\left(k\right)<p_2\left(k\right)$ for all tasks k.

Figure 8 and Figure 9 present a comparative analysis of the reclaimer scheduling performance between the greedy algorithm and our proposed dynamic programming (DP)-based approach, under the critical condition of using identical replenishment sequences. This controlled comparison isolates the effectiveness of the scheduling algorithms themselves, independent of sequence generation differences.

Figure 8 illustrates the per task travel distance of the reclaimers, with the blue solid line representing the DP policy and the red dashed line indicating the greedy policy. As clearly illustrated in Figure 8, while the greedy algorithm achieves a shorter travel distance for the reclaimer at the 11th task (a difference of five units: seven for DP vs. two for greedy), this short-term advantage is quickly offset. By the 15th task, the situation reverses, with DP exhibiting a shorter path (a difference of five units: one for DP vs. six for greedy). Crucially, following the 15th task, the DP algorithm continues to demonstrate superior performance, consistently generating shorter travel paths for the remainder of the schedule. This trend underscores the fundamental strength of DP in achieving global optimization, where initial, strategically accepted sacrifices pave the way for long-term, cumulative gains, while the greedy algorithm makes locally optimal choices at each step by always selecting the reclaimer with the shortest running path for the next step each time. This phenomenon is particularly evident in the cumulative distance comparison shown in Figure 9, where the DP-based method maintains a lower total distance despite occasional local “setbacks”.

After completing all 42 replenishment tasks, the superior performance of the DP approach is unequivocal: the total travel distance under the DP policy reaches 76 units, compared to 82 units under the greedy policy. This represents a reduction of six units, translating to approximately 7.3% lower travel-related energy consumption.

4.3.3. Integrated Comparison of Experimental Results

Based on the replenishment sequence generated by the greedy algorithm, the proposed multi-run simulated annealing algorithm is applied to further refine the sequence. The SA algorithm is configured with an initial temperature ($T_0$) of 200, determined by ensuring that the initial acceptance probability for worse solutions is approximately 0.8, calculated from the average objective function change ($\Delta E_{avg}$) observed in preliminary random sampling using the formula $T_0=-\Delta E_{avg}/In\left(0.8\right)$. The cooling schedule follows an exponential decay with a rate of $\alpha =0.99$. This value was selected after testing a spectrum of rates; a rate close to one results in impractically slow convergence, while a lower rate may cause premature convergence to local optima. The Markov chain length at each temperature is set to 200 iterations to allow the search to approach a quasi-equilibrium state at each temperature step. Excessively short chains degrade solution quality, while excessively long ones incur unnecessary computational cost. The algorithm terminates when the temperature falls below a final temperature $T_{min}=0.01$, or after a maximum number of iterations, ensuring a balance between solution precision and computational efficiency.

The fitness of each candidate sequence is evaluated using Equation (21). To enhance the likelihood of obtaining a high-quality solution, the SA algorithm is executed independently 10 times in parallel, and the sequence with the best fitness value is selected as the final improved sequence. The weights ${\omega }_1$, ${\omega }_2$, ${\omega }_3$ in the objective function are prioritization parameters that reflect operational preferences. In this study, to prioritize blending efficiency (maximizing throughput), the weights are set as ${\omega }_1={\omega }_2=0.1$, ${\omega }_3=0.8$. This configuration assigns greater importance to maximizing the total replenishment amount ($\widehat{J}$) while still incorporating the costs associated with equipment travel ($D_1$, $D_2$) into the optimization. The weighted-sum method provides a flexible scalarization framework for the multi-objective problem, and in a practical deployment, these weights can be further calibrated based on specific economic costs or managerial priorities. Figure 10 shows the fitness values obtained from the 10 parallel runs of the simulated annealing algorithm.

As shown in Figure 10, the highest fitness value of 0.646 was achieved in the eighth run. The convergence process of the fitness values for this run is depicted in Figure 11, where the horizontal and vertical axes represent the iteration count and the fitness value (Equation (21)), respectively.

The computation time for the multiple parallel SA runs is shown in Figure 12, with a maximum runtime under 6 s, comfortably meeting the real-time scheduling requirements of the blending process.

Figure 13 compares the cumulative replenishment amount achieved by the two-stage SA algorithm, the standalone linear programming (LP) method using the greedy-generated sequence, and the greedy algorithm. The green dash-dotted line with triangles represents the two-stage SA algorithm with its optimized replenishment sequence, the blue solid line with circles corresponds to the LP method operating on the initial greedy sequence, and the red dashed line with squares denotes the greedy algorithm. The results clearly demonstrate the superiority of the two-stage SA algorithm, which attains the highest replenishment amount. After 42 replenishment tasks, the cumulative amount under the two-stage SA algorithm reaches 23,080 t, outperforming the LP method (22,388 t) with the same initial sequence by approximately 3.1% and the greedy algorithm (18,882 t) by about 22.2%. These findings confirm that the two-stage framework, which combines sequence optimization through SA with exact scheduling through LP/DP, can effectively enhance the total replenishment performance.

Figure 14 compares the total travel distance of the reclaimers under the SA-optimized strategy (blue solid line) and the greedy strategy (red dashed line). After 42 replenishment tasks, the SA strategy achieves a total travel distance of 74 units, compared to 82 units under the greedy strategy, corresponding to a 9.8% reduction.

Figure 15 compares the cumulative travel distance of the silo-filling cart for schedules generated by the SA-optimized and the greedy strategies under the throughput-prioritizing weight configuration (${\omega }_1={\omega }_2=0.1$, ${\omega }_3=0.8$). The plot illustrates that the SA-optimized schedule results in a consistently lower cumulative distance curve throughout the entire sequence of 42 tasks compared to the greedy strategy. The final total travel distance is 111 units for the SA-optimized schedule, which is 25% lower than the 148 units required by the greedy schedule.

4.3.4. Performance of Gurobi

The evolutionary trajectory of the overall performance metric Q (Equation (21)) throughout the solution process is represented in Figure 16. The Gurobi solver was executed with a hard time limit of 1800 s.

As shown in Figure 16, the convergence trajectory of Gurobi begins at approximately $Q=0.5$, which results from our implementation of a warm-start strategy using the greedy algorithm solution to accelerate the convergence process. The solver plateaued at $Q\approx 0.638$ after approximately 1200 s and continued running until the 1800-s time limit, with no significant further improvement. The final reported solution, obtained at termination, had an optimality gap of approximately 10%.

4.3.5. Summary of Comparative Results

Table 1. Comparison of experimental results under different strategies.

Method	Q	J	${\mathit{D}}_1$	${\mathit{D}}_2$	Computing Time
Greedy	0.489	18,882 t	82	148	<0.001 s
LPDP	0.604	22,388 t	76	148	<0.006 s
SA	0.646	23,080 t	74	111	<6 s
Gurobi	0.638	21,928 t	62	96	≈1200 s (10% gap)

compares the experimental results of four strategies over 42 tasks: the greedy strategy, the LPDP strategy (which applies linear and dynamic programming to the sequence generated by the greedy algorithm), the SA strategy (which optimizes the replenishment sequence using simulated annealing) and the commercial solver Gurobi. As defined in Equation (17), the evaluation metrics include the total replenishment amount J, the total reclaimer travel distance $D_1$, and the total travel distance of the silo-filling cart $D_2$.

Based on the results in Table 1, significant performance improvements are achieved by applying the linear programming and dynamic programming (LPDP) strategy to the replenishment sequence generated by the greedy algorithm. Without altering the sequence itself, and within an extremely short computation time (<0.006 s), the total replenishment amount increases by approximately 18.6%, while the travel distance of the reclaimers is reduced by about 7.3%. These results validate the effectiveness of the proposed decomposition-based scheduling framework.

Further enhancement is obtained by optimizing the replenishment sequence using the SA algorithm. This approach improves the total replenishment amount by about 22.2% relative to the greedy baseline, while also reducing the travel distances of both the reclaimers and the silo-filling cart. Although the computation time increases to less than 6 s, it remains compatible with the real-time requirements of rolling-horizon online optimization. The SA strategy thus achieves an excellent balance between solution quality and computational efficiency, demonstrating its suitability for industrial online scheduling with stringent performance demands.

A detailed quantitative comparison between the proposed SA method and the commercial solver Gurobi is also summarized in Table 1. The SA algorithm achieved a higher normalized aggregate objective value ($Q=0.646$) compared to Gurobi ($Q=0.638$). This performance is primarily attributed to the SA method’s significantly higher total replenishment amount (J = 23,080 t vs. 21,928 t). In contrast, Gurobi found a schedule with lower equipment travel distances ($D_1=62$, $D_2=96$), indicating its strength in minimizing movement costs. The most critical distinction lies in the computational expense: the SA algorithm obtained its high-quality solution in under 6 s, whereas the Gurobi run, terminated at the 1800 s time limit, failed to close the optimality gap, which remained at approximately 10%. This juxtaposition underscores the core trade-off: the exact solver (Gurobi) pursues, but cannot guarantee, optimality within a practical timeframe, while the proposed SA algorithm delivers a competitive solution for the defined composite objective within the strict latency requirements of online scheduling.

4.3.6. Weight Sensitivity Analysis

To further illustrate the influence of the weights, we conducted the sensitivity analysis by setting ${\omega }_1={\omega }_2$ (since the silo-filling cart and the reclaimers have similar running power) and varying ${\omega }_3$ from 0.01 to 1 while maintaining ${\omega }_1+{\omega }_2+{\omega }_3=1$. The results are shown as Figure 17, Figure 18 and Figure 19. As illustrated in Figure 17, J maintains a consistently high magnitude regardless of the variation in the weight coefficient ${\omega }_3$ from 0.01 to 1. This phenomenon is primarily attributed to the temporal span constraint integrated into our model, which mandates that the completion time of the final replenishment task must exceed 24 h.

The underlying reason for this setting is to prevent the algorithm from converging toward “trivial solutions.” Without such a long-term duration requirement, the optimization process might minimize reclaimer and cart travel distances ($D_1$ and $D_2$) by concentrating all replenishment tasks within an unnaturally short time window. While such solutions might satisfy the “no-empty-silo” constraint in the short term and appear numerically “optimal,” they are practically non-executable as they fail to sustain the continuous material flow required for a full production cycle. Therefore, the stable and large value of J reflects the baseline operational volume necessary to fulfill the actual daily demand of the blending yard, ensuring that the generated schedule is not just a mathematical optimum, but a robust and viable industrial solution.

The results (Figure 17, Figure 18 and Figure 19) demonstrate that our method maintains consistent performance across a wide range of weight configurations. Replenishment amount (J) remains substantially higher than the greedy benchmark across all weight values, typically showing a 20–25% improvement. Travel distances ($D_1$ and $D_2$) are generally lower than or comparable to greedy algorithm results, with only minimal degradation in extreme weight configurations. A key observation from the weight sensitivity analysis is that the performance metrics (J, $D_1$, $D_2$) do not exhibit monotonic relationships with the weight coefficient ${\omega }_3$. This behavior can be attributed to two main factors: firstly, the scheduling problem under this paper is highly complex and non-convex, featuring multiple local optima; secondly, the algorithm proposed in this paper is designed to obtain high-quality, feasible suboptimal solutions rather than exact global optima—a deliberate trade-off that prioritizes computational efficiency while preserving solution quality. This non-monotonic relationship actually demonstrates the robustness of our approach: the total replenishment amount J significantly outperforms the greedy baseline across all weight configurations (typically by 20–25%), while the travel distances ($D_1$ and $D_2$) are superior to the greedy algorithm in the vast majority of cases, with only minimal degradation observed at a few specific weight points.

4.3.7. Sensitivity Analysis on System Parameters

To evaluate the sensitivity and practical applicability of the proposed model and algorithm under varying operational conditions, we conduct a comprehensive sensitivity analysis on three critical system parameters. The performance of our SA-based algorithm is compared against the greedy baseline under these variations. The nominal parameter values from Section 4.1 serve as the baseline (Case 0).

Case 1 (Low Initial Weight): Initial silo weight W(0,j) is set to 60% of maximum capacity (vs. 85% nominal).

Case 2 (High Demand Pressure): Silo discharge rates $v_{-}\left(j\right)$ are uniformly increased by 20%, simulating heightened downstream demand.

Case 3 (Longer Setup Time): The inter-task delay $\Delta T$ is doubled.

The key metrics are the feasibility of the generated schedule (strict adherence to all constraints, especially the no-empty-silo rule), the total replenishment amount J, and the computation time. The results are summarized in

Table 2. Sensitivity analysis under different system parameter configurations.

Case	Description	Algorithm	J	${\mathit{D}}_1$	${\mathit{D}}_2$	Computing Time
0	Nominal	SA	23,080	74	111	<6 s
		Greedy	18,882	82	148	<0.001 s
1	Low Initial Weight (60%)	SA	23512	70	109	<6 s
		Greedy	20,765	85	150	<0.001 s
2	High Demand (+20%)	SA	22,631	70	121	<6 s
		Greedy	18,131	76	154	<0.001 s
3	Longer Setup Time (2$\Delta T$)	SA	21,846	78	116	<6 s
		Greedy	18,050	84	152	<0.001 s

.

In all scenarios, our SA algorithm maintains superior performance over the greedy baseline in terms of total replenishment J. The schedules adapt logically to parameter changes: under lower initial weight (Case 1), the total replenished amount increases; under higher demand (Case 2), the algorithm initiates replenishment tasks earlier for critical silos to prevent shortages; under longer setup times (Case 3), the total number of tasks is slightly reduced during 24 h. The computation time for our algorithm remains under 6 s across all cases, confirming its consistent real-time viability. This sensitivity analysis confirms that the performance advantages of our approach are not an artifact of a specific parameter set but hold across a range of realistic operating conditions.

4.3.8. Multi-Scale Benchmark Testing

To evaluate the scalability and generalizability of the proposed structural decomposition approach, we conducted a series of benchmark tests ranging from small-scale (20 tasks) to large-scale (100 tasks) scenarios. These cases represent different operational intensities in industrial raw material yards. The performance of our method is compared against a commercial MINLP solver, Gurobi, and the traditional greedy method.

The computational results are summarized in

Table 3. Multi-Scale benchmark test results.

Tasks	Algorithm	Q	J	${\mathit{D}}_1$	${\mathit{D}}_2$	Computing Time
Small (20)	SA	0.319	11,158	32	44	≈4.5 s
	Greedy	0.234	9058	42	70	<0.001 s
	Gurobi	0.320	11,160	30	44	≈116 s
Medium (42)	SA	0.646	23,080	74	111	<6 s
	Greedy	0.489	18,882	82	148	<0.001 s
	Gurobi	0.638	21,928	62	96	≈1800 s
Large (100)	SA	1.4	51,048	164	307	≈20 s
	Greedy	1.1	43,596	198	355	<0.001 s
	Gurobi	-	-	-	-	>1800 s

. As observed, the greedy heuristic, while extremely fast (<0.001 s across all scales), yields the lowest Q and J values, indicating its solutions are significantly suboptimal. In contrast, Gurobi finds high-quality solutions for small instances, achieving the best Q, J values. However, its computing time escalates drastically with problem size, requiring approximately 116 s for the small instance and 1800 s for the medium instance, and it fails to find a feasible solution within the 1800 s time limit for the large instance. The proposed SA algorithm strikes an effective balance. It consistently outperforms the greedy heuristic in all metrics by a significant margin. Compared to Gurobi, SA obtains competitive, near-optimal objective values but does so in a fraction of the time. Crucially, for the large-scale problem where Gurobi fails, SA successfully provides a high-quality solution in approximately 20 s. This pattern confirms that the SA algorithm delivers a robust and scalable performance, making it suitable for the real-time, rolling-horizon scheduling requirements of the target industrial application.

4.3.9. Robustness Analysis

To further validate the robustness of the proposed method against operational uncertainties, a dynamic stress test was conducted by introducing a 20% step increase in the discharge rates of all silos at t = 15,000 s.

As shown in Figure 20, taking silo 1 as an illustrative example, the weight trajectories for both the baseline and high-demand cases are identical before the disturbance. However, the local magnification reveals a distinct inflection point at t = 15,000 s. The depletion rate (represented by the curve’s slope) becomes significantly steeper, signaling the transition to a high-stress operating condition.

The proposed algorithm successfully mitigates this disturbance through its real-time feedback and online scheduling mechanism. By continuously monitoring the silo status, the scheduler triggers an instantaneous re-optimization that advances subsequent replenishment tasks and recalibrates reclaimer movements. Consequently, even under the 20% demand surge, the silo weight is maintained above the critical safety threshold without any stock-out incidents. This result confirms that the method’s capability extends beyond offline planning, demonstrating its potential for handling real-world production fluctuations within the defined operational framework.

4.4. Discussion of Results and Comparative Analysis

The experimental results presented in Section 4.3 demonstrate the efficacy of the proposed structural decomposition and two-stage metaheuristic algorithm. Beyond descriptive performance metrics, these findings carry significant implications when viewed through the lens of the methodological landscape reviewed in the Section 1. This section provides a comparative analysis, arguing how our approach addresses the specific limitations of existing methods.

4.4.1. Performance in the Context of Prior Methodological Trade-Offs

Our results can be structurally discussed by contrasting them against the three canonical approaches to complex scheduling problems:

(1)

Comparison with Exact Mathematical Programming

The commercial solver Gurobi, representing state-of-the-art exact methods, obtained a solution with a normalized aggregate performance metric of 0.638. While Gurobi’s solution featured lower equipment travel distances, its computation exceeded 1200 s, surpassing the practical limit for online, rolling-horizon scheduling. In contrast, the proposed method obtained a schedule with a higher aggregate Q (0.646) in under 6 s. This highlights a key trade-off: our method is designed to rapidly deliver high-quality, feasible solutions under strict time constraints, whereas the exact solver, even with significantly more time, could not close the optimality gap. The comparison underscores that the proposed approach effectively addresses the computational challenge of real-time decision-making, a domain where exact methods face inherent scalability limitations.

(2)

Comparison with Decomposition and Relaxation Techniques

Classical decomposition methods (e.g., Lagrangian, Benders) improve scalability but often at the cost of iterative, parameter-dependent procedures that may violate hard constraints during the solution. Our structural decomposition is fundamentally different: it is exact and non-iterative for a fixed sequence. The LP and DP sub-solvers provide a deterministic, feasibility-guaranteed evaluation in polynomial time. The consistent generation of feasible schedules across all tested scenarios empirically validates that our method overcomes the feasibility relaxation and parameter tuning challenges associated with traditional decomposition schemes.

(3)

Comparison with Heuristics and Metaheuristics

While the greedy heuristic is computationally fast, it produced substantially inferior solutions. This underscores a fundamental weakness of conventional heuristic and metaheuristic approaches: their lack of a built-in mechanism for rigorous constraint satisfaction. Our framework ingeniously embeds an exact evaluator within a metaheuristic search. This design means that every candidate sequence presented to the evaluator is verified for feasibility and precisely scored, effectively immunizing the search against constraint violations. The result is a hybrid method that retains the global exploration capability of metaheuristics while incorporating the feasibility guarantee characteristic of exact methods—a synergistic combination not achieved by pure heuristic approaches.

4.4.2. Synthesis of Contributions and Originality

The experimental comparisons collectively demonstrate that the proposed method successfully navigates the trilemma identified in the literature. It avoids the intractability of exact methods, the procedural complexity and relaxed feasibility of classical decomposition, and the infeasibility risk of pure heuristics. The key innovation is the identification of a problem structure that permits exact, constraint-preserving decoupling, enabling the creation of a fast and reliable evaluator. This evaluator, in turn, unlocks the potential for metaheuristics to explore the feasible solution space effectively. Therefore, the originality of this research lies not merely in obtaining better numerical results but in proposing and validating a new hybrid methodological paradigm. This paradigm is characterized by: (1) a theoretically grounded, exact decomposition that preserves all hard constraints; (2) a practical algorithm that leverages this decomposition to enable efficient, feasibility-guaranteed metaheuristic search; and (3) empirical evidence showing superior performance for real-time scheduling compared to benchmarks from all major methodological families. This work thus provides a tangible pathway for solving tightly constrained, integrated scheduling problems where traditional approaches face significant compromises.

4.5. Practical Implications for Industrial Operations Managers

From an industrial management perspective, the main value of the proposed framework is not only that it produces high-quality schedules, but that it can be embedded into a real-time decision-support workflow. In practice, operations managers need to repeatedly update the schedule as silo weights, reclaimer positions, discharge rates, and travel times change during execution. The proposed receding horizon framework is well aligned with this requirement: at each decision epoch, it generates a new replenishment plan using the latest system state and forecast information, executes only the first decision, and then re-optimizes as new data become available. Because each candidate replenishment sequence is evaluated exactly by the embedded LP and DP subproblems, the method provides deterministic and fast scheduling feedback, which is essential for online production environments. This makes the approach particularly suitable for industrial blending yards where short decision cycles, frequent disturbances, and strict no-empty-silo constraints must be handled simultaneously. Thus, for plant managers and controllers, the proposed method offers the following key values:

(1)

Dynamic, Risk-Averse Scheduling

The core capability to generate a feasible, high-quality schedule within seconds enables real-time, rolling-horizon rescheduling. This allows operations to adapt dynamically to disturbances (e.g., equipment breakdowns, urgent order changes) that are common in industrial yards. Most importantly, by strictly enforcing the “no-empty-silo” constraint, the model proactively mitigates the risk of production stoppages—a critical concern for continuous process industries.

(2)

Feasible Implementation Pathway

Deploying this system in a real production environment is feasible with current technology. The algorithm can be containerized as a software service that integrates with the plant’s existing control and data infrastructure (e.g., SCADA). It would periodically receive state data (silo weights, equipment positions) and output an optimized sequence of tasks to the dispatch console for human-in-the-loop execution. The modest computational requirement (demonstrated on a standard workstation) means it can run on existing industrial servers without significant new investment.

5. Conclusions

5.1. Limitations and Future Work

While the proposed model and algorithm demonstrate significant performance improvements, it is important to acknowledge their limitations to clearly define the scope of this work and motivate future research.

Deterministic Modeling Core: The current MINLP formulation and the LP/DP decomposition are fundamentally deterministic. The rolling-horizon framework mitigates uncertainty by frequently re-planning with updated state information, but the optimization within each horizon does not internalize probabilistic distributions of key parameters (e.g., stochastic equipment breakdowns). Future work could integrate robust optimization or stochastic programming techniques to explicitly handle these uncertainties within the scheduling model itself.

Simplified Equipment Dynamics: The model abstracts equipment movement and material handling into a sequence-dependent setup time $\Delta T$ and constant flow rates. This simplification enhances tractability but may not fully capture the complex dynamics of acceleration/deceleration or minor, unpredictable operational delays. Future models could incorporate more detailed discrete-event simulation or higher-fidelity kinematic models within the evaluation loop, potentially using simulation-based optimization.

Scalability to Highly Complex Configurations: This study validates the method on a single blending line with shared reclaimers. The computational complexity of the DP-based reclaimer scheduler, while polynomial, would increase with the number of reclaimers and stockpile locations. Extending the approach to coordinate multiple, interdependent blending lines competing for a common pool of reclaimers and a central silo-filling cart presents a significant combinatorial challenge. Future research could explore hierarchical or multi-agent coordination frameworks built upon the current decomposition principle.

5.2. Summary of Scientific Contributions

This study proposes a two-stage optimization framework for the integrated scheduling of blending processes in industrial raw material yards. The primary scientific contribution lies in the theoretical derivation of an exact structural decoupling property within the complex MINLP model. We analytically prove that once the replenishment sequence is fixed, the intractable global optimization can be rigorously decomposed into two tractable subproblems: a LP model for silo-filling cart coordination and a DP-based shortest-path problem for reclaimer assignment. Building on this structural insight, a two-stage metaheuristic algorithm is developed that integrates greedy initialization with multi-round simulated annealing. This architecture allows for the exact evaluation of candidate sequences without the need for heuristic feasibility repairs, significantly enhancing the efficiency of the search process in high-dimensional solution spaces.

Industrial case studies and stress tests further validate the superiority and operational readiness of the proposed framework. Compared to conventional greedy heuristics, the algorithm substantially increases the total replenishment volume while simultaneously optimizing equipment travel efficiency. Compared to the commercial solver Gurobi, our approach produces competitive results in mere seconds, offering a computationally efficient alternative to exact solvers that may encounter convergence challenges within the strict time limits of large-scale applications. Furthermore, robustness analysis under a 20% demand surge indicates the model’s adaptive potential, as it supports silo weight stability through rapid re-optimization. These results suggest that the proposed method achieves a viable balance between solution quality and computational tractability, providing a computationally efficient foundation for autonomous rolling-horizon scheduling in raw material yards.

5.3. Future Research Directions

Future research will focus on several directions. First, the proposed decomposition-based methodology will be extended to multiple blending processes, where coordination and resource-sharing constraints will introduce additional complexity. Second, uncertainty in reclaim rates, discharge rates, and travel times should be modeled more explicitly to improve robustness under highly variable operating conditions. Third, larger-scale systems may benefit from enhanced state-compression strategies, alternative decomposition schemes, or multi-objective extensions that provide Pareto-optimal trade-offs between throughput, travel distance, and computational time. These directions will further broaden the applicability of this framework to more complex and realistic industrial environments.