In modern manufacturing, the need for reliable and repeatable casting processes has driven the development of numerical simulation tools that can predict casting defects before expensive tooling is produced. My work focuses on one specific type of casting defect: cold shut. Cold shuts form during the filling stage when multiple streams of liquid metal meet but fail to fuse completely because the metal front is already semi-solid. This defect is difficult to analyze visually because the mold is opaque and the metal flow is complex. In this paper, I describe a method I developed to calculate the confluence positions of metal streams during casting filling and to use those positions for predicting cold shuts and other related casting defects.
Numerical simulation of casting processes has become an indispensable tool in foundry engineering. It allows engineers to visualize the filling of the mold, track temperature evolution, and predict casting defects such as shrinkage porosity, gas entrapment, and cold shuts. Traditional analysis of casting defects relies heavily on post-processing visualization of velocity fields and temperature fields. However, when the geometry is complicated, observing the post-processing results alone is insufficient for identifying critical areas, especially for defects formed at the meeting points of separate liquid fronts. Therefore, I propose an algorithm to automatically extract confluence positions from the time field reconstructed from the filling simulation.
This work is organized as follows. First, I review the governing equations for casting filling simulation and discuss the numerical techniques used to solve them. Then, I present the time-field method for calculating confluences, including an optimization that handles practical limitations such as large time steps and unstable flow fronts. After that, I describe a post-processing software system built with Qt and VTK, and validate the confluence calculation against simulated flow fields. Finally, I apply the method to an end cover casting and successfully predict cold shut defects that are then confirmed by experimental casting.
Governing Equations for Casting Filling Simulation
The filling of a mold with molten metal involves fluid flow, heat transfer, and often free surfaces. I start with several simplifying assumptions common in casting simulation: the fluid is incompressible, the flow is laminar, the mold is impermeable and no gas backpressure acts on the melt, and the liquid metal density is constant. Under these assumptions, the continuity equation, the momentum equations (Navier–Stokes), and the energy equation form the foundation of the simulation.
The continuity equation expresses mass conservation. For an incompressible fluid, the divergence of the velocity field is zero:
$$
\frac{\partial u}{\partial x}+\frac{\partial v}{\partial y}+\frac{\partial w}{\partial z}=0
$$
Here, \(u, v, w\) are the velocity components in the \(x, y, z\) directions. In the derivation, I considered a control volume in the shape of a hexahedron and balanced the net mass flux through its faces. For a constant density, this leads directly to the above equation.
The momentum equations are derived from Newton’s second law. For a viscous fluid, the Navier–Stokes equations take the form:
$$
\rho \frac{du}{dt}=-\frac{\partial p}{\partial x}+\mu \nabla^2 u + \rho f_x
$$
$$
\rho \frac{dv}{dt}=-\frac{\partial p}{\partial y}+\mu \nabla^2 v + \rho f_y
$$
$$
\rho \frac{dw}{dt}=-\frac{\partial p}{\partial z}+\mu \nabla^2 w + \rho f_z
$$
In these equations, \(p\) is pressure, \(\mu\) is dynamic viscosity, \(\rho\) is density, and \(f_x, f_y, f_z\) are body force components (usually gravitational). I derived these equations by considering the pressure forces, viscous shear stresses, and gravity acting on a small control volume. The full expansion yields the familiar convective terms \(u\partial u/\partial x + v\partial u/\partial y + w\partial u/\partial z\).
The energy equation describes the temperature evolution during filling. For an incompressible fluid with negligible viscous dissipation, the energy balance can be written as:
$$
\rho c_p \frac{\partial T}{\partial t} + \rho c_p \left( u\frac{\partial T}{\partial x}+v\frac{\partial T}{\partial y}+w\frac{\partial T}{\partial z} \right) = \lambda \left( \frac{\partial^2 T}{\partial x^2}+\frac{\partial^2 T}{\partial y^2}+\frac{\partial^2 T}{\partial z^2} \right)
$$
Where \(\lambda\) is thermal conductivity and \(c_p\) is specific heat. This equation accounts for both conduction and convection of heat in the liquid metal.
These equations are nonlinear partial differential equations, and analytical solutions are generally impossible for practical geometries. Therefore, I use a finite difference approximation on a structured grid of hexahedral cells. The computational domain is discretized into cells, and each cell stores scalar values such as pressure, temperature, and volume fraction, while velocities are stored on cell faces.
Several algorithms exist for solving the coupled flow equations. The SIMPLE algorithm, introduced by Patankar and Spalding, is a pressure-correction method that iteratively adjusts pressure to satisfy continuity. The MAC algorithm uses marker particles to track the free surface, while the SOLA-VOF algorithm combines a simple pressure iteration with the Volume-of-Fluid method. The SOLA-VOF method is particularly efficient for casting filling because it uses the volume fraction \(F\) to represent the liquid fraction in each cell:
$$
F(x,y,z,t)=\frac{V_l(x,y,z,t)}{V(x,y,z)}
$$
\(F=1\) means the cell is full of liquid, \(F=0\) means empty, and \(0<f<1\) a="" and="" casting="" free="" good="" has="" in="" indicates="" it="" making="" memory="" method="" p="" reduces="" simulation.
Table below summarizes the governing equations and their physical meaning:
| Equation | Physical Law | Mathematical Expression |
|---|---|---|
| Continuity | Conservation of mass | \(\frac{\partial u}{\partial x}+\frac{\partial v}{\partial y}+\frac{\partial w}{\partial z}=0\) |
| Momentum (x) | Newton’s second law | \(\rho\frac{du}{dt}=-\frac{\partial p}{\partial x}+\mu\nabla^2 u+\rho f_x\) |
| Momentum (y) | Newton’s second law | \(\rho\frac{dv}{dt}=-\frac{\partial p}{\partial y}+\mu\nabla^2 v+\rho f_y\) |
| Momentum (z) | Newton’s second law | \(\rho\frac{dw}{dt}=-\frac{\partial p}{\partial z}+\mu\nabla^2 w+\rho f_z\) |
| Energy | Conservation of energy | \(\rho c_p\frac{DT}{Dt}=\lambda\nabla^2 T\) |
In the finite difference formulation, I used a staggered grid to avoid pressure–velocity decoupling. The pressure and temperature are defined at cell centers, while velocity components are defined at cell faces. The advection terms are discretized using an upwind scheme to ensure numerical stability. The diffusion terms are discretized with central differences. The free surface is advanced using the VOF method, which tracks the volume fraction \(F\) in each cell.
For the time integration, I use an explicit scheme for the first step, followed by a pressure correction step. At each time step, the velocity field is computed from the momentum equations using the current pressure and body forces. Then the continuity equation is checked, and the pressure is corrected iteratively until the divergence of velocity is below a tolerance. This iterative process is repeated until convergence is achieved.
Calculation of Confluence Positions
Confluence positions are locations where two or more separate metal fronts meet during the filling process. These positions are critical for forming casting defects because they often trap oxides, gas, and cold material. My goal is to automatically extract these positions from the simulation data. To do this, I first obtain the transient filling front using the VOF method. By recording the time when the filling front passes through each cell, I can construct a static time field \(T(x,y,z)\). The time field is essentially a scalar map that represents the arrival time of the metal front at every point in the cavity.
The concept is illustrated in a one-dimensional example. Suppose two liquid streams move toward each other along the x-axis. At the location where they meet, the arrival time is larger than the arrival time of points immediately to the left and right. Thus, the confluence appears as a local maximum in the time field. By detecting local maxima of the time field, I can identify confluence positions.
For an ideal continuous function \(T(x)\), a local maximum occurs when the second derivative is negative:
$$
T”(x)<0
$$
In discrete form, using central differences, the condition becomes:
$$
\frac{T(x-\Delta x)-2T(x)+T(x+\Delta x)}{\Delta x^2}<0
$$
For three dimensions, I check the second derivative along the x, y, and z directions. If any of the second derivatives is negative, the cell is considered a confluence candidate:
$$
\frac{\partial^2 T}{\partial x^2}<0 \quad \text{or} \quad \frac{\partial^2 T}{\partial y^2}<0 \quad \text{or} \quad \frac{\partial^2 T}{\partial z^2}<0
$$
However, in actual simulations, the time step is not infinitesimally small, so within one time step, the metal front may traverse more than one cell. This leads to multiple adjacent cells with the same time value. When this occurs, the second derivative may become zero, and the confluence would be missed. To overcome this problem, I relax the detection condition by allowing the differencing increment \(\Delta x\) to be increased until a non-zero second derivative is found. I limit this expansion to five cell lengths. If the second derivative remains zero, the cell is not a confluence.
Another practical issue is that the metal front is not perfectly smooth. Turbulence and surface instability cause the front to break into smaller streams that recombine locally, creating many small-scale confluences. These small confluences are not of interest for defect prediction because they do not significantly affect the solidification structure. To filter them out, I introduce the concept of “confluence scale” \(L\). The confluence scale is defined as the distance along the inverse flow direction from the confluence point to the point where the time value starts to increase. In discrete terms, starting from a confluence cell, I move along the negative flow direction and count cells as long as the time value decreases. The smaller value of the two directions (on either side of the confluence) is chosen as the confluence scale. Then, I set a threshold based on the casting size. For example, a threshold of about 1% of the maximum casting dimension works well. Only confluences with scale larger than the threshold are retained as major confluences.
Table below summarizes the detection algorithm steps:
| Step | Description |
|---|---|
| 1 | Extract the filling front at each time step using VOF function \(F\). |
| 2 | Record the arrival time for each cell where \(F\) changes from 0 to a positive value. |
| 3 | Construct the time field \(T(x,y,z)\). |
| 4 | For each cell, compute the second derivative along x, y, z directions. |
| 5 | Identify cells that satisfy the maximum condition in at least one direction. |
| 6 | Increase the differencing step if the second derivative is zero (up to 5 cells). |
| 7 | Calculate the confluence scale for each candidate cell. |
| 8 | Filter out small-scale confluences according to the threshold. |
The time field compression is a key advantage. Rather than storing a transient three-dimensional field at every time step, I store a single three-dimensional scalar field \(T(x,y,z)\), which is much smaller and easier to analyze. This also allows me to quickly visualize the confluence positions in post-processing.
Post-Processing Software and Visualization
To validate my confluence calculation method, I built a post-processing software module using Qt and VTK. Qt provides a cross-platform user interface framework, while VTK provides a powerful visualization pipeline for scientific data. I integrated the VTK rendering into a Qt widget using the QVTKWidget class. This allows me to display three-dimensional models, scalar fields, and velocity fields interactively.
The software reads the simulation result files from a finite difference code. I designed classes to store the grid geometry and the scalar data associated with each cell. The visualization pipeline uses vtkStructuredGrid or vtkImageData depending on the mesh type. The data are then mapped to colors using a vtkDataSetMapper and displayed with a vtkActor. I also added a vtkScalarBarActor to show the color legend. Interaction with the model is handled by vtkRenderWindowInteractor, allowing rotation, zoom, and pan.
The software supports display of the STL model, temperature field, velocity field, and the calculated confluence positions. I also implemented clipping planes to visualize internal sections of the casting. A snapshot feature was added for recording results, and an animation mode allows stepping through time steps.
To test the method, I started with a simple 山-shaped casting where two lateral gates delivered liquid metal from both sides. The simulated filling process showed that the two streams met near the center of the casting and then split again due to the high velocity, causing secondary confluences near the side walls. The time field was extracted and displayed, and the confluence positions were calculated.
The intermediate results are shown in the sequence I generated: first the time field, then the raw confluence candidates, then the confluence scale field, and finally the filtered major confluences. Without filtering, the confluence candidates were spread almost everywhere because the unstable front created many small meeting points. After applying the confluence scale threshold, only the main confluences remained, which matched the visual observation of the flow field.
I then applied the method to a magnesium alloy steering wheel casting produced by high-pressure die casting. The wheel had four gates and eight overflow slots. The flow field simulation revealed six major confluences during filling. My algorithm also detected exactly these six positions on the casting surface. This confirmed that the method works for complex geometries.
A comparison between the visually identified confluences and my calculated confluences is shown in the table below:
| Case | Number of confluences from visual observation | Number of confluences from algorithm | Agreement |
|---|---|---|---|
| 山-shaped casting | 3 (including secondary) | 3 | Yes |
| Steering wheel | 6 | 6 | Yes |
Application to Cold Shut Defect Prediction
After validating the confluence calculation, I applied it to predict cold shut defects on an end cover casting. The end cover is made of ductile iron QT400-18, with dimensions 522 mm × 522 mm × 148 mm and wall thickness varying from 10 mm to 30 mm. The casting has many ribs, bosses, and through-holes on the back side, making the geometry quite complex. I designed a sand casting process with two cavities in one mold, using eight ingates and three cross runners. A separate pouring line was used for the actual experiment.
The model was discretized with a finite difference grid with a cell size of about 4 mm. The grid had 339 × 207 × 115 cells, totaling approximately 8 million cells. The initial casting temperature was set to 1350 °C and the pouring velocity at the gate was 1 m/s. Table below lists the key simulation parameters:
| Parameter | Value | Unit |
|---|---|---|
| Liquid metal density | 6702 | kg/m³ |
| Air density | 1 | kg/m³ |
| Gravity acceleration | 9.8 | m/s² |
| Inlet velocity | 1 | m/s |
| Pouring temperature | 1350 | °C |
| Mold initial temperature | 20 | °C |
| Air temperature | 20 | °C |
| Casting–air heat transfer coefficient | 10 | W/(m²·K) |
| Casting–mold heat transfer coefficient | 1000 | W/(m²·K) |
During the filling simulation, the metal entered through the sprue, flowed down the main runner, split into three cross runners, and finally entered the cavity through eight ingates. Due to the complex ribs and bosses on the bottom of the casting, the metal immediately split into multiple small streams. These small streams recombined at several locations near the bottom, creating numerous small confluences.
Observing the velocity field alone was extremely difficult because the flow pattern was chaotic. The temperature field showed relatively small differences inside the cavity, while the temperature dropped significantly in the runner system. Therefore, I could not easily judge where cold shuts might form just by looking at the temperature field.
I applied my confluence algorithm to the filling data. The raw confluence results contained many scattered small patches. After setting the confluence scale threshold, I obtained a set of major confluence positions. These positions were concentrated on the side walls away from the ingates, where the metal flowed from two opposite directions and met near the end of the filling phase.
For each selected confluence point, I extracted the temperature history from the simulation. The temperature curves showed that when the metal fronts arrived at these confluence points, the temperature had dropped to near the solidus temperature of the ductile iron. This indicates that the metal fronts were already partially solidified before the actual contact, which creates a high risk of cold shuts. The temperature remained below the solidus during subsequent filling, so the two fronts could not fuse completely.
Based on this analysis, I predicted that cold shuts would appear at these major confluence positions. The actual casting experiment was then carried out on a production line. After the casting solidified and was cleaned, I inspected the casting surface. The casting showed clear cold shut defects on the middle side wall, which corresponded very well with the predicted locations. The cold shuts appeared as thin gaps with poor fusion, exactly as expected.
The table below summarizes the comparison between the predicted cold shut locations and the experimental observations:
| Predicted location | Experimental result | Defect type |
|---|---|---|
| Center of side wall near the end of filling | Visible cold shut | Partial penetration crack-like gap |
| Upper thin sections | No significant defect | — |
| Lower complex rib region | Minor cold shut | Small lap |
Discussion
The method I have presented enables automatic detection of confluence positions without requiring the analyst to manually track the moving metal fronts. This is particularly valuable for commercial simulation software where the user wants quick identification of potential cold shut zones. The time-field compression not only reduces data storage but also provides a clear physical interpretation: positions with local maxima in arrival time are exactly where fronts meet.
One important limitation is the dependence on the quality of the VOF front extraction. If the front is smeared due to numerical diffusion, the time field may be inaccurate. However, in my tests with a reasonably fine grid, the method worked well. The relaxation of the detection condition (expanding the differencing interval) helps to handle larger time steps, but if the time step is excessively large, the time field will lose its resolution and the confluence may be missed entirely. Therefore, I recommend that the time step be small enough so that the front moves no more than a few cells per time step.
Another limitation is the threshold selection for the confluence scale. My suggestion of 1% of the maximum linear dimension is empirical. For castings with very thin walls, a smaller threshold may be more appropriate. The user may need to adjust the threshold based on the casting geometry and the scale of the defects of interest.
The method can be extended to predict not only cold shuts but also other casting defects that form at the meeting of liquid fronts, such as oxide inclusions and gas entrapment. In addition, by combining the confluence positions with the local temperature at the moment of contact, a quantitative criterion for cold shut formation could be developed. In my analysis, I observed that cold shuts occurred when the front temperature was near the solidus. By calibrating the threshold temperature for a given alloy, the method could be transformed into a more direct predictive tool.
Future work will focus on integrating this technique into mainstream casting simulation packages and adapting it to unstructured meshes. The concept of the time field is independent of the mesh type, but the discrete second derivative needs to be implemented differently for non-hexahedral elements. I also plan to study the effect of mold filling direction and gate design on the number and location of confluences, enabling the foundry engineer to optimize the gating system to reduce the risk of cold shuts.
Conclusion
In this article, I presented a method for calculating confluence positions in casting filling processes and applying them to predict cold shut defects. The key steps are:
- Extract the metal front at each time step using the VOF method.
- Construct a time field \(T(x,y,z)\) from the arrival times.
- Detect local maxima of the time field using second derivatives in three dimensions.
- Relax the detection condition by expanding the differencing interval when necessary.
- Filter out small-scale confluences using a scale threshold based on the casting size.
- Analyze the temperature evolution at the major confluence positions.
- Predict cold shuts where the front temperature is near or below the solidus at the time of contact.
I validated the method on a simple geometry and a complex steering wheel casting, achieving excellent agreement with visual observations of the flow field. I then successfully predicted cold shut defects on an end cover casting, and the experimental casting confirmed the predicted locations. This work provides a scientific basis for quantitative prediction and analysis of cold shuts and other casting defects related to liquid metal confluences.
The main contribution of this research is the transformation of a dynamically changing flow field into a static time field that can be quickly analyzed for critical meeting positions. The post-processing tool built with Qt and VTK demonstrates the practicality of the method for engineering use. I believe this approach will improve the efficiency and accuracy of casting process analysis in the foundry industry.
</f