Over the past decade, the rapid advancement of computer hardware and the widespread adoption of the Windows operating system have enabled three-dimensional CAD systems, once confined to high-end workstations, to become common tools in engineering practice. In the field of casting process design, three-dimensional modeling software represents the inevitable direction for solid modeling technology, as it greatly facilitates the integration of CAD/CAE/CAM in casting production. My research focuses on a riser design CAD system for large steel castings. The secondary development platform I chose is Unigraphics NX (UG), a powerful three-dimensional design software developed by Siemens (formerly UGS Corporation), which provides robust solid modeling and collaborative assembly capabilities. Traditional riser design demands comprehensive theoretical knowledge and extensive manual consultation, making the process tedious and error-prone. Riser design is not only a critical step in casting process planning but also directly linked to CAE simulation, since a well-designed casting process model can be directly imported into simulation software for verification. Motivated by these considerations, I developed a riser design system based on UG NX, using Visual Studio 2008 as the development tool and UG/Open as the programming environment. The design method adopted in the system is the cubic equation method, which ensures both accuracy and efficiency for common riser geometries. This system serves as a major functional module of a casting process CAD system for steel castings, and it can also run as a standalone application with a user-friendly interface and independent data management, while maintaining a consistent operating style with UG.
1. Introduction and Background
Casting, as a fundamental forming process, directly affects the quality of manufactured products and thus occupies a critical position in industrial production. In 2010, China produced 39.6 million tons of castings, ranking first in the world for the eleventh consecutive year, accounting for one-third of the global total output. However, the quality of castings produced in China has not always been guaranteed, and with the guidance of scientific development and sustainability, the urgent need to resolve casting quality issues has become increasingly apparent. Because the microstructural changes of molten metal during casting cannot be directly observed, process design has traditionally relied on experience and repeated trial-and-error. This leads to unstable quality, high rejection rates, and high trial production costs. Casting defects are closely related to the filling and solidification processes. Therefore, understanding the state of liquid metal after entering the mold cavity and the causes of defects is crucial for process improvement. The main task of casting process CAD is to improve casting techniques while consuming fewer resources.
Casting process CAD includes two aspects: process design and numerical simulation. Casting simulation is an interdisciplinary frontier field, and countries around the world have invested heavily in its research. The simulation process uses computer algorithms to perform complex calculations based on the process parameters set by the user, ultimately yielding the required results—such as temperature fields, flow fields, and defect predictions. Compared with developed countries, China’s foundry industry still lags significantly in the development and application of simulation software due to technological and financial constraints. When designing a new product process, engineers often rely only on experience and compare trial castings to finalize a process scheme. Moreover, many companies only resort to simulation software when major problems arise, but by then it is often too late to avoid unnecessary losses.
It is precisely in this context that I developed a riser design system for large steel castings based on the UG platform. UG is one of the most widely used 3D modeling software packages, and its parametric and feature-based modeling approach provides an easy-to-learn drafting environment. UG also provides convenient program functions for developers, enabling users to customize the software through a well-defined API. Using Visual Studio 2008 as the development platform, I was able to carry out secondary development on UG, making the software more suitable for the specific needs of casting process design. At the same time, by coupling with ProCAST, a leading casting simulation software, it becomes possible to simulate the casting process from pouring to solidification, thereby verifying the accuracy of the process plan and providing substantial assistance for deriving an optimal process. This is particularly important for large steel castings where major defects are unacceptable.
2. Literature Review and Development Trends
The term CAD was coined in 1959 at a planning conference at MIT. Since then, CAD has undergone tremendous changes. The definition of casting CAD was historically misunderstood as numerical simulation of solidification, while its true meaning is the design of the casting process. This confusion persisted until the mid-1990s, when the casting community began to distinguish casting CAE (simulation) from casting process CAD (design). Casting process CAD covers all design tasks from reading a part drawing to completing the process plan, including the gating system and, most importantly, the riser system. The riser design varies depending on the material being cast. Casting simulation, on the other hand, mainly includes the simulation of temperature fields, flow fields, and microstructure evolution, with the aim of observing the solidification process of the metal after filling and predicting possible defects, thus enabling process improvement, lower production costs, and higher process yield.
2.1 Foreign Developments
Internationally, research on casting process CAD has been relatively less prominent, whereas casting CAE has been at the forefront. In 1962, Forsund in the United States used the finite difference method to calculate heat transfer during solidification for the first time. In 1965, Henzel and Keverian at General Electric computed the solidification process of large steel castings using a transient heat transfer program. In 1970, Marrone at the University of Michigan used explicit and alternating-direction implicit finite difference schemes to solve the solidification of low-carbon steel T-shaped and L-shaped samples. They assumed ideal conditions and used Fourier’s heat conduction equation to calculate heat transfer, plotting solidification isotherms and concluding that the thermal properties of the metal and sand mold at high temperatures were the key factors affecting calculation accuracy. In 1976, a seminal paper titled “Computational Simulation of Solidification” was published by Pehlke and colleagues, which detailed the physical principles of heat transfer, numerical methods, and the application to various alloy castings. These pioneering efforts laid a solid foundation for subsequent researchers worldwide. During the 1970s, many researchers entered this field, including P.N. Hansen in Denmark, Eisuke Niyama in Japan, and Ituo Ohnaka in Japan. In the 1980s, solidification simulation advanced rapidly. At the 52nd International Foundry Congress, Pehlke and Berry proposed the concept of casting process CAD. The first commercial casting simulation software appeared at the 7th International Foundry Fair in Germany in 1989. Since the beginning of the new millennium, many casting simulation software packages have emerged, with mature mathematical models and algorithms, such as FLOW-3D, ProCAST, and MAGMASoft. In recent years, more research has been directed toward casting process CAD, and several production-oriented tools have been introduced, such as FEEDERCALC by Foseco. However, their universality remains limited, and much work is needed to develop industry-wide casting CAD/CAE software.
2.2 Domestic Developments
China began research in computer applications in casting in the early 1980s. At that time, the national key project “Research on Solidification Control of Large Steel Castings” was initiated. However, due to the lack of computer availability, the research results were not widely applied. In the mid-to-late 1980s, another project “Casting Process CAD Research for Large Steel Castings” was selected as a national key project. At that time, international research on casting process CAD was just in its infancy, so China was almost at the same starting point.
Domestic simulation research developed rapidly. Universities and research institutes, including Dalian University of Technology, Shenyang Research Institute of Foundry, Xi’an Jiaotong University, Northwestern Polytechnical University, Tsinghua University, and Huazhong University of Science and Technology, made significant contributions. Dalian University of Technology published papers using the finite difference method to calculate temperature fields during solidification of large castings, followed by riser optimization design. Shenyang Research Institute of Foundry developed a series of casting software for five typical casting categories. In the late 20th century, Tsinghua University developed a casting process design software named THFSCAD, but its complexity limited its adoption. Later, a software named castCAD was developed for a specific company, with good results but limited generality. With the deepening of research, secondary development on existing CAD platforms became a trend. Three-dimensional modeling has gradually replaced two-dimensional drafting, and therefore developing casting process CAD systems based on UG, ProE, and other 3D CAD software is the direction for future development.
2.3 Future Trends
The future of casting CAD technology includes the development of computer-integrated manufacturing systems (CIMS) for casting production and concurrent engineering. This implies that design, simulation, computing, and other tasks should be organically linked, aiming to create a full lifecycle concept where products are developed in a fully integrated working mode from the beginning, making the production process more transparent. However, in China, both casting process design software and simulation software are still in early stages of development, and the concurrent technology is not yet mature. Implementing CIMS and concurrent engineering in the foundry industry remains a long-term challenge.
Another trend is the integration of casting process CAD tools. Current systems often have strong specificity but poor generality, which hinders their widespread use. To address this, national standards for casting processes should be established, and a comprehensive engineering database should be built upon those standards. With a unified standard and thorough execution of each task, an intelligent casting CAD system can be achieved.
3. UG NX Secondary Development Environment
UG NX is a world-renowned product design solution by Siemens. It provides not only drafting capabilities but also manufacturing validation tools. One of the most appealing features of UG is its powerful 3D product conceptual design capability. Many successful products have been created on the UG platform. UG also provides a user-friendly secondary development language module, offering numerous high-level language interfaces and program packages that enable customizations for better user experience. UG is a mature 3D mechanical CAD/CAM/CAE integrated software. By mastering its functions and applying them in different domains, users can achieve significant productivity gains. For instance, in stamping die design, users can now create 3D models manually, but the software cannot remember past steps for automation. With UG/Open secondary development, users can encapsulate existing design experience and successful cases into an interactive system, reducing repetitive work and improving design efficiency.
UG/Open is the primary secondary development tool provided by Siemens PLM Software. It consists of four modules: API, GRIP, MenuScript, and UIStyler.
3.1 UG/Open API
UG/Open API is a program set that encapsulates nearly 2000 UG operation functions, allowing users and developers to access and modify UG object models. By using the API, programmers can avoid writing many low-level routines. The API supports multiple high-level languages, including C, C++, C#, Java, and VB. The latest UG NX versions require development in Visual Studio 2008. After installing the appropriate wizard files, one can create a new project in Visual Studio 2008 using the UG/Open App Wizard and then directly call API functions. The API saves programming time, implements most UG operations, and reduces error rates. However, users must become familiar with the function signatures and parameter types to avoid mistakes.
3.2 UG/Open GRIP
GRIP is a graphics interactive programming language developed by Siemens specifically for UG. It has its own syntax, variables, and structure, and supports calls to and from other high-level languages. GRIP is easy to learn and use, but the resulting programs are often long and complex. It is suitable only for small programs. In contrast, API-based programming offers broader coverage and greater potential.
3.3 UG/Open MenuScript
MenuScript is a tool for editing menus. It is simple and does not require a dedicated development environment—Windows Notepad is sufficient. With MenuScript, users can modify the UG menu bar layout, add or delete menu options, and connect custom menus with programs. The menus are automatically loaded when UG starts.
3.4 UG/Open UIStyler
UIStyler is a visual dialog box editor similar to Visual Basic, but dedicated to dialog creation. It is very easy to use, and the generated dialogs perfectly match the UG style. With UIStyler, developers can avoid writing GUI code manually. The UIStyler interface consists of four parts: the dialog design window, the tool palette, the object browser, and the resource editor. After saving, UIStyler generates three files: a .dlg file (the dialog resource), a .h header file, and a template.c file. The developer then writes the logic in Visual Studio 2008, adds the header and template files, compiles, and links to generate a .dll file. The combination of MenuScript and UIStyler enables rapid creation of a customized UG interface.
4. Casting Simulation Method and ProCAST Software
4.1 Finite Element Method (FEM)
The finite element method is a highly efficient numerical technique for solving engineering problems. It originated from the variational principle and was later applied to fields governed by Laplace’s and Poisson’s equations. The development of FEM was accelerated by the aircraft industry’s triangular stress elements in the 1950s. The first paper on finite elements was presented by Jon Turner in 1954, and the term “finite element” was coined by Clough in 1962. Zienkiewicz’s book “The Finite Element Method” published in 1967 remains a classic. FEM starts by converting the boundary value problem (with initial conditions) of a partial differential equation into an equivalent variational or weighted residual problem. The continuous domain is discretized into a set of non-overlapping elements. Within each element, shape functions ensure continuity, and at element boundaries, continuity conditions can be relaxed. As the discretization is refined, the discrete solution converges to the exact solution. In practice, the number of elements must be balanced against computational resources and simulation time. An optimal compromise between accuracy and computational load must be found.
4.2 ProCAST Software
ProCAST, developed by ESI Group, is a world-leading casting simulation software based on FEM. It satisfies the foundry industry’s requirements for fast and accurate process simulation. By using ProCAST, companies can reduce manufacturing costs, shorten development times, and improve casting quality. ProCAST offers a complete set of simulation capabilities, including mold filling, solidification, and microstructure prediction. Its comprehensive simulation reports allow process designers to make informed decisions at the early stages of product development. ProCAST supports almost all common casting processes, with a standardized user interface across different process types. It includes a powerful material database capable of simulating any alloy—from steel, iron, and aluminum alloys to non-conventional and polymeric materials. The database is continuously updated, and ProCAST also offers a thermodynamic calculation system that automatically computes thermophysical properties from chemical composition. ProCAST excels in its analysis and prediction capabilities, such as detecting shrinkage porosity, cracks, and other defects. The simulation results can be visualized and shared with the community.
Compared with finite difference methods (FDM), FEM has distinct advantages in preserving details of complex shapes. The advantages can be summarized as follows:
1. In describing complex curved surfaces, FDM may lose some details, while FEM preserves them accurately.
2. FEM allows local refinement or coarsening of the mesh, thus optimizing the number of elements and accelerating computation. FDM cannot easily perform local refinement, so FDM meshes are typically larger, leading to longer computation times.
3. For thermal stress and strain simulation, FDM meshes cannot deform, so FEM is required.
4. When handling curved boundaries, FEM provides a better representation, whereas FDM approximates curved boundaries with stair-step segments, which may affect filling flow simulation.
5. For radiation heat transfer, FDM cannot accurately handle curved surfaces, affecting view factor and shading calculations, so FDM is inadequate for complex radiation problems.
5. Research Content
Based on the above background, the research content of this thesis includes:
1. Analyzing existing riser design theories and combining them with the actual production at a heavy steel casting company to determine an appropriate calculation method.
2. Summarizing casting manuals and company standards, creating three-dimensional models of standard risers in UG, and establishing a riser library.
3. Studying the key technology that combines a general-purpose riser calculation program with a standard steel casting riser library. Using UG NX 7.5 as the development platform, the Open API interface, and Visual Studio 2008, the casting process riser system was designed.
4. Implementing CAD/CAE interaction. The developed system is a 3D casting process CAD system that can directly import models into ProCAST for simulation, enabling process optimization.
6. Experimental Content and Methods
6.1 Riser Basics and Design Principles
A riser is a cavity in the mold that stores sufficient liquid metal to feed the casting during solidification, thereby preventing shrinkage defects such as porosity and hot tears. Riser types vary according to product structure and alloy composition. Riser classification includes:
– By function: ordinary risers and special risers (e.g., atmospheric risers, exothermic risers, insulating risers).
– By visibility: open risers and blind risers. Open risers have a flat top surface and are simple to make, easy to inspect, and help with venting. But they lose more heat through the top surface, so their feeding efficiency is lower. Blind risers are enclosed within the mold and have a spherical (dome) top to improve efficiency; they retain heat better and are most suitable for smaller castings. However, blind risers should generally be limited to diameters below 300 mm.
– By location: top risers and side risers. Top risers are placed above the casting and use gravity to feed, allowing inclusions to float upward. Side risers can be open or blind.
Riser design principles include:
– There must be a feeding path between the riser and the region being fed during solidification.
– The riser modulus must be greater than that of the fed region to create a feeding path.
– The riser must be large enough to provide sufficient liquid metal for feeding.
– The riser volume should be minimized as much as possible while facilitating mold making.
– When allowed, the riser should be placed near the ingate to improve feeding efficiency.
– Avoid placing risers at locations prone to hot tearing, as risers slow cooling and reduce strength during contraction.
– Consider fettling and cleaning when positioning risers, and avoid interference with free contraction of the casting.
– Design risers for easy removal by machining. If placed on non-machined surfaces, additional cleaning costs may arise.
6.2 Common Riser Design Methods
Several methods are used for riser design, each with its own advantages and limitations. I compared the following common methods:
(1) Modulus Method
The basic modulus method relies on the relationship between solidification time and the square root of the modulus. The modulus is defined as
$$
M = \frac{V}{A}
$$
where \(V\) is the volume and \(A\) is the cooling surface area. According to the square root law,
$$
T_f = k M^2
$$
where \(T_f\) is the solidification time, \(M\) is the modulus, and \(k\) is the solidification coefficient. To ensure the riser solidifies after the fed region, the riser modulus must be greater than the casting region modulus. For ordinary risers, where \(k_R \approx k_C\), one obtains
$$
M_R \ge M_C
$$
by applying an expansion factor \(f\):
$$
M_R = f M_C
$$
Typical values for side risers: \(M_N : M_C : M_R = 1 : 1.1 : 1.2\) (when not used as ingate), and when used as ingate \(M_N : M_C : M_R = 1 : (1.03–1.10) : 1.2\). The riser volume must then be checked for adequate metal supply.
(2) Cubic Equation Method
The cubic equation method is an extension of the modulus method. It is based on the principle that the heat-dissipating surface area of the riser is the same at the beginning and end of solidification. At the end of feeding, the riser volume \(V_r\) reduces to \(V_r – \varepsilon V_c\), where \(\varepsilon\) is the volumetric contraction of the casting. The riser modulus is
$$
M_R = \frac{V_r – \varepsilon V_c}{A_r}
$$
The casting modulus is
$$
M_C = \frac{(1+\varepsilon)V_c}{A_c}
$$
When the riser and casting modulus are equal at the end of solidification, we have
$$
\frac{V_r – \varepsilon V_c}{A_r} = \frac{(1+\varepsilon)V_c}{A_c}
$$
For any riser shape, the volume and surface area can be expressed as functions of geometric dimensions. For a cylindrical riser with diameter \(d_r\) and height \(B\) (where \(B = h/d_r\)), we have
$$
V_r = \frac{\pi d_r^2 B}{4}, \qquad A_r = \pi d_r^2\left(B + \frac{1}{4}\right)
$$
Substituting these into the equality equation and rearranging yields a cubic equation in terms of \(d_r\):
$$
K_1 M_C d_r^2 + K_2 M_C^2 d_r – V_c – \frac{\varepsilon V_c}{1+\varepsilon} = 0
$$
or more standardly:
$$
K_1 M_C d_r^2 + K_2 M_C^2 d_r – V_r + \varepsilon V_c = 0
$$
The constants \(K_1\) and \(K_2\) depend on the riser geometry. For various common riser shapes, the values are given in Table 1.
**Table 1. Shape coefficients for different riser types**
| Riser Type | \(K_1\) | \(K_2\) |
|———–|———|———|
| Spherical cap (\(f_1=0.61\)) | 0.508033 | 3.107744 |
| Cylindrical open riser (\(f_1=1.0\)) | 0.785398 | 4.712389 |
| Cylindrical open riser (\(f_1=1.5\)) | 1.178097 | 6.283185 |
| Cylindrical blind riser (\(f_1=1.0\)) | 0.654498 | 3.926991 |
| Cylindrical blind riser (\(f_1=1.2\)) | 0.811578 | 4.555309 |
| Cylindrical blind riser (\(f_1=1.5\)) | 1.047198 | 5.497787 |
| Straight waist open riser (\(f_1=1.25, f_2=1.5\)) | 1.606748 | 7.747787 |
| Straight waist open riser (\(f_1=1.5, f_2=2.0\)) | 2.678097 | 11.283185 |
| Straight waist blind riser (\(f_1=1.25, f_2=1.5\)) | 1.743547 | 7.783185 |
| Straight waist blind riser (\(f_1=1.5, f_2=2.0\)) | 2.439897 | 10.068583 |
| Side riser (\(f_1=1.5\)) | 1.018669 | 5.492135 |
| Side riser (\(f_1=2.0\)) | 1.411368 | 7.062931 |
| Truncated cone open riser (\(f_1=1.0\)) | 0.952950 | 5.389359 |
| Truncated cone open riser (\(f_1=1.5\)) | 1.566869 | 7.558997 |
| Truncated cone straight waist open riser (\(f_1=1.25, f_2=1.5\)) | 1.950763 | 8.833716 |
| Truncated cone straight waist open riser (\(f_1=1.5, f_2=2.0\)) | 3.291869 | 12.873960 |
The cubic equation method can find the minimum riser size that satisfies feeding requirements, making it scientifically the most reasonable method. However, due to the complexity of solving cubic equations, it was rarely used manually. With the availability of computers, this method becomes practical and accurate. I therefore selected the cubic equation method as the basis for the riser calculation program.
(3) Perimeter Modulus Method
The perimeter modulus method introduces a “perimeter ratio” concept into the basic modulus method. As solidification proceeds, the liquid level in the riser drops, and the actual riser modulus decreases due to the formation of a shrinkage cavity. The perimeter ratio is defined experimentally. But because limited data are available, this method has not been widely used.
(4) Hot Spot Circle Method (Proportional Method)
The hot spot circle method determines riser dimensions by expanding the hot spot circle diameter by an empirical factor. It is simple to use, but it depends heavily on the technician’s experience and lacks theoretical rigor. It is not suitable for computer-based automated design.
6.3 Development Approach of the UG-Based Riser System
UG’s parametric modeling capability is fully developed. One can create parametric solid models manually, or use the secondary development tools to generate models programmatically. There are two main approaches for constructing a parametric standard part library in UG:
1. **Template-based parametric modeling**: First, create a riser template using parametric features. Extract the key parameters and express other dimensions as functions of these parameters in the Expression tool. Users can directly input key parameters to generate the required riser. This method requires having one template per riser type.
2. **Program-controlled modeling**: Use the UG/Open API to write programs that control the parameters and create the model. This is entirely program-driven and requires strong programming skills. The parametric data can be stored in databases, and the user interacts with a dialog box. This method is convenient and maintainable.
I adopted a hybrid approach that combines the strengths of both methods. First, I created 3D riser templates in UG with full parameterization using the Expression function. Then I used the Part Family function to create a database in Excel for each riser type, populating it with standard sizes from handbooks and factory standards. Finally, I used MenuScript and UIStyler to create a custom menu and dialog box, and wrote API programs in Visual Studio 2008 to connect the interface to the database and drive parametric modeling.
6.4 Establishment of the Standard Riser Library
The process for creating the standard riser library is summarized as follows:
1. **Riser template creation**: Analyze the geometric structure of each riser type, and create a parametric 3D model. Keep the number of features to a minimum to simplify expression editing.
2. **Database creation**: Use the Part Family tool to extract the principal parameters into an Excel spreadsheet. Add the standard sizes from the relevant manual and factory data.
3. **User interface design**: Use MenuScript to create a custom menu item “Riser Design System”. Use UIStyler to create a dialog box for input parameters.
4. **Application programming**: Write API code to read the database, perform the cubic equation calculation, and generate the riser model in the assembly.
The project directory structure is shown in Table 2.
**Table 2. Project directory structure for UG development**
| Folder | Purpose |
|——–|———|
| `Startup` | Contains menu files (.men) and startup DLLs |
| `Application` | Contains dialog resource (.dlg) and application DLLs |
| `Udo` | Contains user-defined object files (if any) |
| `Bitmap` | Stores icons and images for menus/toolbars |
The environment variable `UGII_USER_DIR` is set to `D:\experiment` to allow UG to find the custom modules.
For example, to create a straight waist open riser template, I analyzed the geometry and defined the main parameters: bottom length \(a\), bottom width \(b\), height \(h\), and chamfer dimensions. The length \(a\) is the main design variable. Using UG’s Expression tool, I established relationships between these parameters. The part family table included columns for the riser name and all key dimensions. Each row represented one standard riser size. After verification, the template was saved, and the family data were stored.
In total, I created ten types of common riser templates, including open cylindrical risers, blind cylindrical risers, spherical cap risers, straight waist open risers, straight waist blind risers, side risers, and truncated cone risers.
7. System Implementation and Application Example
7.1 Development Environment Setup
To enable secondary development in UG, the UG/Open wizard files were copied to the appropriate folders in Visual Studio 2008. After restarting Visual Studio, a new project type “UG/Open App Wizard” became available. I created a new project named “RiserDesign” and added the generated `.h` and `.c` files from UIStyler to the project. The core calculation algorithm (cubic equation) was written in C++.
7.2 Riser Calculation Program
The program flow is as follows:
1. The user enters the casting material properties (e.g., volumetric contraction ratio \(\varepsilon\)), the modulus of the casting region \(M_C\), the volume of the casting region \(V_C\), and selects the riser type.
2. The program determines the appropriate coefficients \(K_1\) and \(K_2\) from the riser type.
3. It solves the cubic equation:
$$
K_1 M_C d_r^2 + K_2 M_C^2 d_r – \frac{V_C}{1+\varepsilon} = 0
$$
or more precisely for a cylindrical riser:
$$
K_1 M_C d_r^2 + K_2 M_C^2 d_r – \frac{V_C}{1 – \varepsilon} = 0
$$
Note: The exact form depends on the convention used. In my implementation, the equation was rearranged to solve for the riser diameter \(d_r\) given the casting volume and modulus.
4. The program then computes the riser height \(h = B d_r\), where \(B\) is the height-to-diameter ratio (input by the user or selected from the database).
5. The program checks whether the riser volume satisfies the feeding requirement by calculating the available feeding volume.
6. If the riser is not large enough, the program iteratively increases the diameter using a numerical method (e.g., Newton-Raphson) until the volume condition is met.
7. Finally, the program displays the computed riser dimensions in the dialog box and offers to create the 3D model in the current assembly.
I implemented the cubic equation solver using a closed-form algebraic solution, which is fast and accurate. The program also allows the user to select a standard riser from the library instead of calculating one from scratch.
7.3 Application to a Grinding Disc Seat
To validate the system, I used a real steel casting: a grinding disc seat (磨盘座, but in this English context, a grinding disc seat). The material was ZG270-500, a typical carbon steel used in heavy castings. The chemical composition limits are shown in Table 3.
**Table 3. Chemical composition of ZG270-500 (mass fraction, %) (max)**
| C | Si | Mn | P | S | Cr | Mo | V | Ni | Cu |
|—|—|—|—|—|—|—|—|—|—|
| 0.40 | 0.50 | 0.90 | 0.04 | 0.04 | 0.35 | 0.20 | 0.05 | 0.30 | 0.30 |
First, I created the 3D model of the grinding disc seat in UG. Then, using the “Split Body” function, I identified the hot spot region that requires feeding and measured its volume and modulus using the UG analysis tools. Next, I launched the riser design program from the custom menu. The dialog box allowed me to enter the required parameters:
– Casting material: ZG270-500
– Volumetric contraction ratio \(\varepsilon = 0.05\)
– Casting modulus \(M_C = 3.5\) cm
– Casting volume \(V_C = 17500\) cm³
– Riser type: cylindrical open riser with height/diameter ratio \(B = 1.5\)
The program calculated the required riser diameter and height. It then displayed the results, as shown in the parameter display window. The program then created the riser model in the assembly at a user-specified position, completing the riser design. The final process drawing showed the casting with the riser attached.
8. Casting Simulation with ProCAST
8.1 Preprocessing and Mesh Generation
To verify the designed riser, I exported the assembly model (casting plus riser) from UG in IGS format. The IGS format is well recognized by GEOMESH, the surface mesh generator used in conjunction with ProCAST. I imported the IGS file into GEOMESH, checked the geometry, and performed automatic repair as needed. I then generated surface meshes with appropriate density: finer mesh in the thin sections and slightly coarser mesh in the bulk regions to balance accuracy and computational cost. The surface mesh was saved as an STL file and imported into MeshCAST, the volume mesh module of ProCAST. After generating the volume mesh, I performed smoothing and optimization. The final mesh file was saved with the `.mesh` extension. The mesh statistics are shown in Table 4.
**Table 4. Volume mesh statistics**
| Parameter | Value |
|———–|——-|
| Material count | 1 |
| Number of nodes | 93,747 |
| Number of volume elements | 399,419 |
| Model dimensions (x,y,z) | ~1200 mm × 800 mm × 600 mm (approximate) |
8.2 Virtual Mold Setup
Since the primary objective was to study the casting and riser solidification behavior, I used the virtual mold feature in ProCAST instead of creating a full sand mold. The virtual mold acts as a heat sink and allows reasonable heat transfer simulation without the need to model the entire mold geometry. The virtual mold was set to a size slightly larger than the casting assembly, with its top surface flush with the pouring cup. After setting the virtual mold, I ran a thermal depth calculation to ensure that the mold size was adequate.
8.3 Material Parameters
ProCAST contains a comprehensive material database. For ZG270-500, I defined the material composition manually to compute the temperature-dependent thermophysical properties. The thermal properties used in the simulation are shown in Table 5.
**Table 5. Thermophysical properties of ZG270-500 used in simulation**
| Temperature (°C) | Density (kg/m³) | Thermal conductivity (W/m·K) | Enthalpy (kJ/kg) | Solid fraction |
|——————|—————–|——————————-|——————|—————-|
| 20 | 7800 | 35 | 0 | 1.0 |
| 500 | 7700 | 38 | 310 | 1.0 |
| 1000 | 7500 | 33 | 680 | 1.0 |
| 1450 | 7200 | 41 | 980 | 0.9 |
| 1520 | 7000 | 44 | 1100 | 0.5 |
| 1580 | 6800 | 48 | 1250 | 0.0 |
These data were obtained from the ProCAST database and verified against literature values for steel castings.
8.4 Interface and Boundary Conditions
The interface between the casting and the virtual mold was defined with a heat transfer coefficient of \(h = 500\ \mathrm{W/m^2K}\), which is typical for steel-steel or steel-sand interfaces. The boundary conditions were set as follows:
– Pouring temperature: 1580 °C
– Pouring time: 180 seconds (3 minutes)
– Initial mold temperature: 25 °C (room temperature)
– Cooling condition: ambient air cooling
– Gravity direction: positive Y-axis (as defined by the coordinate system)
The simulation was set to use gravity filling, which is the default for gravity casting. The time step was chosen to ensure the simulation would complete within a reasonable computation time. After setting all parameters, I ran the DataCAST check to ensure consistency of the mesh and boundary conditions. The `-u` update option was enabled to refine the time step if necessary.
8.5 Simulation Results
8.5.1 Filling Process
The filling simulation results are presented in the form of temperature fields at different times. The temperature scale is shown on the right side of the figure in degrees Celsius. At \(t=50\) s, the molten steel enters the sprue and begins to flow through the runner system. At \(t=150\) s, the metal travels along the circular runner and enters the casting cavity through multiple ingates. The liquid level rises steadily. At \(t=250\) s, more than half of the cavity is filled. At \(t=300\) s, the filling is almost complete. The flow pattern was smooth, with only minor waves and no obvious turbulence or air entrapment. This indicates that the gating system design was sound.
8.5.2 Solidification Process
After filling, the solidification simulation started. The temperature fields were recorded at various cooling times. At \(t=14000\) s, the thin ingates have already solidified, and the bottom part of the casting begins to cool below the solidus temperature. At \(t=34000\) s, the solidification progresses upward, with the riser still liquid. At \(t=54000\) s, the casting is mostly solid, but the riser still contains some liquid metal, feeding the shrinkage. At \(t=84000\) s, the riser is the last region to solidify. The solidification sequence follows the desired directional solidification from the bottom of the casting up to the riser. This confirms that the riser size and location are appropriate.
8.5.3 Defect Prediction
ProCAST’s shrinkage porosity module was used to predict the location and amount of porosity. The criterion is based on the volume fraction of porosity: values above 0.1 indicate macro-porosity (shrinkage cavities), while values below 0.1 indicate micro-porosity. The simulation showed a small amount of micro-porosity in the waist section of the casting, which is acceptable under the inspection standard. No macro-porosity was observed. The casting was judged to meet the process requirements.
8.5.4 Actual Casting Inspection
Based on the simulation, the production trial was carried out. The grinding disc seat was produced successfully. Non-destructive testing was performed using magnetic particle inspection and ultrasonic testing, according to the acceptance standard JB/T500.14-1998, level II. The sensitivity was set to detect a minimum defect diameter of 6 mm. The inspection revealed no significant internal or surface defects in the prescribed critical areas. This validates the accuracy of the riser design system and the overall process simulation approach.
9. Conclusion
In this work, I developed a riser design CAD system for large steel castings based on the Unigraphics NX platform. The system integrates parametric modeling, a standard riser library, the cubic equation design method, and the capability to interface with ProCAST for casting simulation. The main conclusions are as follows:
1. Using Visual Studio 2008 and the UG/Open API, I successfully developed a user-friendly riser design system that is consistent with UG’s native interface.
2. The system includes a standard riser library with ten common riser types, built using parametric 3D models and Excel-based part families. This library enables fast selection and insertion of risers.
3. The cubic equation method was implemented to compute minimum required riser dimensions. This method is both accurate and efficient, and it reduces the reliance on empirical proportional methods.
4. The system was applied to design the riser for a grinding disc seat made of ZG270-500. The resulting process was simulated using ProCAST, including filling and solidification analyses.
5. The simulation predicted only minor micro-porosity in a non-critical area, and the actual production casting passed magnetic particle and ultrasonic inspections, confirming the reliability of the design system.
6. The integration of the CAD system with ProCAST enables a seamless workflow from design to simulation, which is beneficial for process optimization and defect reduction in large steel casting production.
The developed system is currently tailored for steel castings, but the methodology can be extended to other alloys and casting processes. Future work may involve expanding the riser library to include more exotic riser geometries and incorporating a knowledge base of casting defects and remedies. Overall, this study demonstrates that a well-designed CAD system based on parametric modeling and secondary development can significantly improve the efficiency and accuracy of riser design for large steel castings, and when coupled with CAE simulation, it provides a powerful tool for modern foundry engineering.