The rapid expansion of offshore wind power, particularly the shift towards 8–12 MW class turbines as the mainstream technology, has precipitated a significant surge in demand for large-scale, safety-critical components. Key structural elements such as hubs, main shafts, bearing housings, and front frames are predominantly manufactured from thick-section nodular cast iron (ductile iron), with single casting weights often ranging from 20 to 60 tonnes. This presents a formidable logistical challenge for foundries: the weight of an individual casting frequently exceeds the safe melting capacity of their largest available induction furnace. Consequently, it is impossible to produce the required volume of molten metal for a single large casting in one furnace cycle, or “heat.” The production of such massive nodular cast iron castings necessitates the simultaneous operation of multiple furnaces, whose combined molten metal output is then used in a coordinated pour.
This multi-heat requirement fundamentally transforms the production scheduling problem at the melting stage, known as the furnace or “heat” planning problem. The core objective is to group various casting orders from the job shop into batches (heats) to be melted simultaneously across several furnaces. This grouping must satisfy critical constraints: all castings within a single furnace must be of the identical nodular cast iron grade (material constraint), and the total weight allocated to a furnace cannot surpass its safe operational capacity. For smaller castings, this is a complex batch-scheduling puzzle. However, for large wind turbine castings, an additional layer of complexity is introduced: these orders must be split and allocated across multiple furnaces in a single planning cycle. This creates a dual-constraint space where the planning model must handle non-splittable small orders and splittable large orders concurrently, all while optimizing for production efficiency and timely delivery.
Traditional furnace planning models in foundry literature typically assume that no single order’s weight exceeds a furnace’s capacity. They focus on optimizing metrics like furnace utilization, makespan, or delay penalties for batches of small to medium castings. These approaches are inadequate for the modern reality of producing gigantic nodular cast iron components. This article addresses this gap by presenting a comprehensive multi-furnace, multi-heat planning model specifically designed for foundries producing large wind turbine nodular cast iron castings. The model simultaneously schedules multiple parallel furnaces, allows for the splitting of oversized orders, and aims to maximize a composite objective function balancing delivery urgency and furnace capacity utilization. A tailored Hybrid Genetic Whale Optimization Algorithm (HGWOA) is developed to solve this NP-hard problem efficiently. Validation using real-world production data demonstrates the model’s effectiveness in significantly improving resource utilization and reducing total furnace heats required compared to manual scheduling methods.
Problem Description and Formulation
The core production flow for large castings involves several key stages: mold making (often completed in advance), core making, melting, and pouring. The melting stage is typically the bottleneck. The specific challenge is illustrated in the following simplified model: a set of casting orders of varying weights and material grades must be scheduled for melting on a finite number of parallel induction furnaces over a planning horizon (e.g., one night’s production shift).
Key Assumptions:
- The total weight of any single casting order must not exceed the combined safe melting capacity of all furnaces scheduled for a simultaneous heat.
- Furnaces scheduled in the same heat cycle can pour their molten metal into the same mold cavity concurrently (via multiple gates/runners).
- No leftover molten metal is considered; each furnace’s output is entirely used for the assigned pour(s).
Mathematical Model:
We define the following indices, parameters, and decision variables.
| Symbol | Description |
|---|---|
| $L$ | Total number of casting orders (tasks). |
| $K$ | Total number of furnace heats to be planned. |
| $N$ | Number of distinct nodular cast iron material grades. |
| $l$ | Index for a casting order, $l \in \{1, 2, …, L\}$. |
| $k$ | Index for a furnace heat, $k \in \{1, 2, …, K\}$. |
| $n$ | Index for a material grade, $n \in \{1, 2, …, N\}$. |
| $W_l$ | Gross weight (demand) of casting order $l$. |
| $V_l$ | Remaining slack time until the due date for order $l$. |
| $Q_k$ | Safe melting capacity of the furnace used in heat $k$. |
| $M_l$ | Material grade index of order $l$. |
| $T_k$ | Material grade index assigned to heat $k$. |
| $P_{lk}$ | Decision Variable: The fraction of order $l$’s weight allocated to furnace heat $k$ ($0 \le P_{lk} \le 1$). |
The urgency or priority $U_l$ of an order is defined based on its remaining slack time $V_l$. A common formulation is:
$$ U_l = \frac{1}{1 + V_l} $$
This yields a priority value between 0 and 1, where a value closer to 1 indicates a more urgent order (shorter slack time).
Objective Function:
The goal is to maximize the total “melting value” of the scheduled plan. This value combines both furnace utilization (weight) and adherence to delivery priorities. A multiplicative combination is chosen over an additive one to prevent the schedule from simply selecting many small, non-urgent orders. The objective is:
$$ \text{Maximize } Z = \sum_{k=1}^{K} \left[ \left( \sum_{l=1}^{L} P_{lk} \cdot W_l \right) \cdot \left( \frac{\sum_{l=1}^{L} P_{lk} \cdot W_l \cdot U_l}{\sum_{l=1}^{L} P_{lk} \cdot W_l} \right) \right] $$
This can be simplified to:
$$ \text{Maximize } Z = \sum_{k=1}^{K} \sum_{l=1}^{L} P_{lk} \cdot W_l \cdot U_l $$
Thus, the objective is to maximize the sum of the priority-weighted weight allocated across all heats. This inherently pushes the schedule to utilize furnace capacity fully (high $\sum W_l$) while favoring orders with higher urgency (high $U_l$).
Constraints:
- Order Completion: An order must be either fully allocated across one or more heats or not scheduled at all. For large nodular cast iron castings ($W_l > \min(Q_k)$), the sum of allocations can be 1. For small castings ($W_l \le \min(Q_k)$), which cannot be split due to gating system design, the allocation variable must be binary.
$$ \sum_{k=1}^{K} P_{lk} \in \{0, 1\} \quad \text{for } W_l \le \min(Q_k) $$
$$ \sum_{k=1}^{K} P_{lk} \le 1 \quad \text{for } W_l > \min(Q_k) $$ - Furnace Capacity: The total weight assigned to any furnace heat must not exceed its safe capacity.
$$ \sum_{l=1}^{L} P_{lk} \cdot W_l \le Q_k \quad \forall k $$ - Material Homogeneity (合炉材质约束): All castings melted in the same furnace heat must be of the same nodular cast iron grade. This is enforced by only allowing $P_{lk}$ to be non-zero if the order’s material matches the heat’s assigned material.
$$ P_{lk} (M_l – T_k) = 0 \quad \forall l, k $$ - Non-negativity and Bounds:
$$ 0 \le P_{lk} \le 1 \quad \forall l, k $$
Solution Strategy: A Decomposition Approach
The model’s complexity arises from the interplay between the batch selection problem (which orders to melt together) and the subsequent weight-splitting problem for large castings. To solve it efficiently, a three-phase heuristic decomposition strategy is employed.
Phase 1: Grouping by Material. The entire set of orders is first partitioned into $N$ disjoint subsets based on their nodular cast iron grade (e.g., QT400, QT500, QT600). Scheduling is then performed independently for each material group, as no cross-group mixing is allowed.
Phase 2: Batch Selection via a Modified 0-1 Knapsack Model. For each material group, the problem of selecting a batch of orders for a single multi-furnace heat cycle is analogous to a knapsack problem. The “knapsack” has a capacity equal to the combined capacity of all furnaces operating in parallel for that heat. The “items” are the orders. The “value” of an item is its priority-weighted weight ($W_l \cdot U_l$). The goal is to select a subset of items that maximizes the total value without exceeding the total capacity. This phase determines which orders will be produced in a given heat. It must account for the splittability of large nodular cast iron castings by ensuring that if a large order is selected, there is sufficient capacity across furnaces to accommodate its entire weight. This adds an extra layer of feasibility checking to the knapsack solution.
Phase 3: Weight Allocation via Linear Programming. Once a batch of orders is selected for a heat, the specific allocation of weights to each parallel furnace must be determined. This is a linear programming (LP) or mixed-integer linear programming (MILP) sub-problem. For the selected orders in set $S$, we solve for $P_{lk}$:
$$ \text{Maximize } \sum_{l \in S} \sum_{k=1}^{K} P_{lk} \cdot W_l \cdot U_l $$
subject to:
$$ \sum_{l \in S} P_{lk} \cdot W_l \le Q_k \quad \forall k $$
$$ \sum_{k=1}^{K} P_{lk} = 1 \quad \forall l \in S \text{ where } W_l > \min(Q_k) $$
$$ \sum_{k=1}^{K} P_{lk} \in \{0, 1\} \quad \forall l \in S \text{ where } W_l \le \min(Q_k) $$
$$ 0 \le P_{lk} \le 1 $$
Standard solvers (e.g., `intlinprog` in MATLAB) can efficiently solve this sub-problem for a single heat.
The overall scheduling algorithm iterates through Phases 2 and 3, removing scheduled orders from the pool, until all urgent orders within the planning horizon are scheduled.
The Hybrid Genetic Whale Optimization Algorithm (HGWOA) for Batch Selection
Phase 2 (the knapsack problem) is solved using a novel Hybrid Genetic Whale Optimization Algorithm. Standard Genetic Algorithms (GA) are effective for global search but can converge slowly. The Whale Optimization Algorithm (WOA) converges quickly but may get trapped in local optima. HGWOA merges the strengths of both to efficiently find high-quality batch selections.
Encoding: An individual (solution) is represented as a binary string of length equal to the number of orders in the current material group. A gene value of ‘1’ indicates the corresponding order is selected for the current batch; ‘0’ indicates it is not.
Fitness Function: The fitness of an individual is the total value of the selected orders, i.e., $\sum_{l} (gene_l \cdot W_l \cdot U_l)$. Only individuals whose total selected weight satisfies the combined furnace capacity constraint and the “splittability feasibility check” are considered valid.
Algorithm Flow:
1. Initialization: Generate a random population of binary strings.
2. Iteration: For each generation:
a. Evaluate the fitness of all individuals.
b. Identify the best individual (the “lead whale”).
c. For each other individual (“follower whale”):
i. Generate random numbers $p$ and $A$, where $|A|$ controls exploration vs. exploitation.
ii. If $p < 0.5$:
– If $|A| \ge 1$: Perform a crossover operation between the follower and a randomly selected individual from the population (exploration).
– If $|A| < 1$: Perform a crossover operation between the follower and the best individual (exploitation).
iii. If $p \ge 0.5$: Perform a mutation operation on the follower (simulating the bubble-net attacking behavior).
d. Apply a greedy repair mechanism to infeasible solutions. If the total weight exceeds capacity, orders are removed from the batch starting with the lowest $W_l \cdot U_l$ value until feasible. Then, to improve the solution, unscheduled orders are added in descending order of $W_l \cdot U_l$ until no more can fit.
3. Termination: Repeat until a maximum number of generations is reached. The best individual provides the selected batch of nodular cast iron castings.
The incorporation of GA’s crossover and mutation into the WOA framework enhances population diversity and helps escape local optima, leading to faster convergence towards a near-optimal batch selection.
Computational Experiments and Case Study
The model and HGWOA were implemented in MATLAB and tested using real production data from a foundry specializing in large wind turbine nodular cast iron castings. The foundry typically operates two 20-tonne medium-frequency induction furnaces in parallel during a night shift, aiming for 4 heats per furnace (8 heats total). A melting ratio of 1.1 (molten metal weight to casting weight) is used to ensure adequate feed metal.
Test Data: A dataset of 191 casting orders was used, categorized into three primary nodular cast iron grades.
| Material Grade | Number of Orders | Typical Application |
|---|---|---|
| QT400 | 116 | Hubs, Brackets |
| QT500 | 21 | Main Shafts, Gearbox Housings |
| QT600 | 54 | High-Stress Components |
Sample Heat Schedule: The algorithm generated a detailed schedule. An example heat for QT400 material is shown below, demonstrating the splitting of a large casting (Order 98).
| Casting Order ID | Gross Weight (kg) | Allocated to Furnace 1 (kg) | Allocated to Furnace 2 (kg) |
|---|---|---|---|
| 9 | 1,028 | 0 | 1,130.8 |
| 71 | 1,240 | 0 | 1,364.0 |
| 23 | 920 | 0 | 1,012.0 |
| 98 | 21,800 | 20,000.0 | 3,980.0 |
| 15 | 1,033 | 0 | 1,136.3 |
| 17 | 1,100 | 0 | 1,210.0 |
Note: Weights shown include the 1.1 melting ratio.
Performance Metric – Furnace Capacity Utilization:
$$ \text{Utilization}_k = \frac{\sum_{l} P_{lk} \cdot W_l}{Q_k} \times 100\% $$
The average utilization across all 8 heats in the planned shift was 99.77%.
Comparative Results: The intelligent scheduling system was compared against the foundry’s existing manual scheduling method for the entire 191-order dataset.
| Performance Metric | Manual Scheduling | Intelligent Scheduling (HGWOA) | Improvement |
|---|---|---|---|
| Average Furnace Utilization | 86.57% | 95.89% | +10.76% |
| Total Heats Required | 42 | 39 | -7.14% (3 heats saved) |
The results confirm that the model significantly optimizes resource use. Higher utilization reduces energy waste per tonne of metal melted. Fewer total heats save on furnace lining wear, refractory costs, and non-productive setup/time, contributing to lower overall production costs and a reduced carbon footprint for manufacturing these critical nodular cast iron components.
Algorithm Performance Comparison
To evaluate the efficacy of HGWOA, it was compared against the standard Genetic Algorithm (GA) and Particle Swarm Optimization (PSO) on the batch selection (knapsack) sub-problem. Each algorithm was run 20 times on test sets with varying material complexity. Parameters were standardized (Population=500, Max Generations=300).
| Test Set (# of Materials) | Algorithm | Avg. Run Time (s) | Best Fitness Found (×10⁴) | Avg. Fitness (×10⁴) |
|---|---|---|---|---|
| 1 | PSO | 2.25 | 3.1842 | 2.9935 |
| GA | 3.42 | 3.1911 | 3.0222 | |
| HGWOA | 2.53 | 3.1918 | 3.0230 | |
| 2 | PSO | 6.34 | 3.2178 | 3.0114 |
| GA | 10.98 | 3.2169 | 3.0928 | |
| HGWOA | 7.98 | 3.2113 | 3.0898 | |
| 3 | PSO | 11.12 | 3.2945 | 3.0521 |
| GA | 17.24 | 3.2961 | 3.1121 | |
| HGWOA | 12.18 | 3.2969 | 3.1125 |
Analysis: PSO is the fastest but consistently yields the lowest fitness values, indicating a tendency to settle for sub-optimal solutions (local optima). GA finds better solutions (higher fitness) but is computationally slower. HGWOA strikes an excellent balance: it matches or slightly exceeds the solution quality of GA while requiring significantly less computation time, especially as problem complexity grows. It inherits WOA’s rapid convergence while using genetic operators to maintain solution diversity and quality.
Conclusion
This article has addressed a critical and previously understudied problem in heavy foundry operations: the optimal scheduling of melting operations for producing oversized nodular cast iron castings, such as those for modern wind turbines. The proposed multi-furnace, multi-heat planning model successfully integrates the need to split large orders across parallel furnaces with the classical batching of smaller orders. Its multiplicative objective function effectively balances the dual goals of high resource utilization and adherence to delivery deadlines, which are paramount for customer satisfaction in project-based manufacturing.
The solution strategy, decomposing the problem into material grouping, batch selection, and weight allocation, provides a practical and computationally manageable framework. The development of the Hybrid Genetic Whale Optimization Algorithm (HGWOA) offers a robust and efficient solver for the core combinatorial batch selection problem, outperforming standard methods in the trade-off between speed and solution quality.
Validation with real industrial data confirms the model’s significant practical value. The intelligent scheduling system can increase average furnace utilization by over 10% and reduce the total number of required heats, leading to direct savings in energy, consumables, and time. This enhances the competitiveness and sustainability of foundries producing these essential large-scale nodular cast iron components for the renewable energy sector. Future work could integrate this melting-stage model with upstream (molding capacity) and downstream (pouring time) constraints for a fully integrated production planning system.