In 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 industrial practice. In the field of casting process design, three-dimensional design software represents the inevitable evolution of solid modeling technology, and it significantly facilitates the integration of CAD/CAE/CAM in the casting production chain. The research presented here focuses on a riser design CAD system for large steel castings, developed on the Unigraphics (UG) NX platform. UG is a powerful product design solution with outstanding solid modeling and cooperative assembly capabilities. Traditional riser design requires a comprehensive combination of theoretical knowledge and extensive manual consultation, making the calculation tedious and error-prone. Riser design is not only a critical step in casting process planning, but it is also closely linked to CAE simulation because a well-designed casting model can be directly imported into simulation software for verification. Against this background, I developed a dedicated riser design system for large steel castings using UG NX as the platform, Visual Studio 2008 as the development environment, and UG/Open as the programming interface. The system employs a cubic equation method for riser size calculation, ensuring both accuracy and simplicity while remaining consistent with UG’s native operation style.
The developed riser CAD system serves as a major functional module of a comprehensive casting process CAD system for steel castings, but it can also operate as an independent application. It provides a user-friendly interface, independent data management, and a look-and-feel that matches UG. By extensively reviewing casting process handbooks and industrial standards, I refined the empirical riser design procedures for steel castings, narrowed the parameter selection ranges, and significantly improved the accuracy of riser sizing. For riser solid modeling, the system exploits UG’s parametric dimension-driven technology and assembly environment, thereby achieving high efficiency in the creation and placement of risers. This system has been developed in close connection with actual production requirements and possesses a broad application prospect.
Introduction and Background
Steel castings are essential components in heavy machinery, energy equipment, and many other industrial sectors. The quality of a steel casting is highly dependent on the solidification process and the effectiveness of feeding. In traditional foundry practice, riser design has been based on the experience of senior engineers and iterative trial runs, which is both costly and time-consuming. The risk of shrinkage defects, hot tearing, and porosity increases when the riser dimensions are insufficient, while oversized risers reduce the casting yield and increase production cost. Thus, an intelligent, reliable, and efficient riser design methodology is of great importance for the production of high-quality steel castings.
With the growing power of computer simulation, casting process simulation has become an indispensable tool for defect prediction and process optimization. Software packages such as ProCAST, based on the finite element method (FEM), allow foundry engineers to visualize the filling and solidification sequences, identify potential shrinkage and porosity zones, and optimize gating and riser systems before the actual pouring. However, the effectiveness of simulation depends heavily on the correctness and completeness of the initial process design. If the riser size and location are not properly designed, the simulation will simply confirm the inherent flaws of the original design. Therefore, a reliable riser design CAD system is a valuable supplement to simulation tools.
This research aims to combine design knowledge, industrial data, and software development to create a riser design system that can handle the complex geometries and large dimensions typical of steel castings. The system is based on UG NX, which offers excellent parametric modeling capabilities and a robust application programming interface (API) for custom development. By using the UG/Open tools, I designed a menu-driven user interface, a standard riser library, and an automatic calculation engine. The output of the system is a complete three-dimensional riser assembly attached to the casting, ready for export to ProCAST for simulation. In the following sections, I describe the design methods, the system architecture, the database construction, and the simulation validation procedure using a real industrial case.
Riser Design Methods
Risers are reservoirs of molten metal that feed the casting during solidification to compensate for volumetric shrinkage and prevent internal defects. The design of a riser must satisfy two fundamental requirements: the riser must solidify after the section it feeds, and it must contain enough liquid metal to feed the volumetric contraction of that section. Several theoretical and empirical methods have been developed for riser sizing, including the modulus method, the cubic equation method, the boundary modulus method, and the hot spot circle (proportional ratio) method. Among these, the cubic equation method offers a more rigorous approach because it considers the change in volume and surface area during solidification and can approach the minimum riser size in theory.
The Modulus Method
According to the modulus theory, the solidification time of a casting is proportional to the square of its modulus, defined as the ratio of volume to cooling surface area:
$$M = \frac{V}{A}$$
where \( V \) is the volume and \( A \) is the cooling surface area. For a riser to feed a casting section, the modulus of the riser \( M_R \) must be greater than or equal to the modulus of the casting section \( M_C \), typically multiplied by an enlargement factor \( f \):
$$M_R \ge f \cdot M_C$$
For ordinary risers, the factor \( f \) usually varies between 1.1 and 1.2. This method, however, assumes a constant heat transfer area and does not account for the progressive reduction of liquid volume in the riser. This oversimplification often leads to oversized or undersized risers.
The Cubic Equation Method
The cubic equation method improves the modulus approach by considering that the riser’s volume decreases during feeding while the surface area remains nearly constant. When the riser has completed its feeding function, its volume becomes \( V_R – \varepsilon V_C \), where \( \varepsilon \) is the solidification shrinkage fraction of the metal, and \( V_C \) is the volume of the casting section being fed. The modulus of the riser at the end of solidification can be written as:
$$M_R = \frac{V_R – \varepsilon V_C}{A_R}$$
Similarly, the casting section modulus may be expressed as:
$$M_C = \frac{(1 + \varepsilon) V_C}{A_C}$$
By equating the final modulus of the riser to the modulus of the casting section, one obtains:
$$\frac{V_R – \varepsilon V_C}{A_R} = \frac{(1 + \varepsilon) V_C}{A_C}$$
Substituting the geometric relations for the volume and surface area of a specific riser shape (e.g., a cylindrical riser) into the above equation leads to a cubic equation in the riser diameter \( d_r \):
$$d_r^3 – C_1 M_C d_r^2 – C_2 \varepsilon V_C = 0$$
where \( C_1 \) and \( C_2 \) are constants that depend on the riser shape. Table 1 lists values for some common riser geometries. This equation can be solved algebraically, which explains why the method was rarely used in manual calculations but is perfectly suitable for computer-aided design. The cubic equation method approaches the theoretical minimum riser volume, thus maximizing the casting yield.
| Riser shape | Shape parameter | C1 | C2 |
|---|---|---|---|
| Spherical cap riser | f1 = 0.61 | 0.508033 | 3.107744 |
| Cylindrical open riser (h/d = 1.0) | f1 = 1.0 | 0.785398 | 4.712389 |
| Cylindrical open riser (h/d = 1.5) | f1 = 1.5 | 1.178097 | 6.283185 |
| Cylindrical blind riser (h/d = 1.0) | f1 = 1.0 | 0.654498 | 3.926991 |
| Cylindrical blind riser (h/d = 1.2) | f1 = 1.2 | 0.811578 | 4.555309 |
| Cylindrical blind riser (h/d = 1.5) | f1 = 1.5 | 1.047198 | 5.497787 |
| Rectangular waist open riser | f1=1.25, f2=1.5 | 1.606748 | 7.747787 |
| Rectangular waist open riser | f1=1.5, f2=2 | 2.678097 | 11.283185 |
| Rectangular waist blind riser | f1=1.25, f2=1.5 | 1.743547 | 7.783185 |
| Rectangular waist blind riser | f1=1.5, f2=2 | 2.439897 | 10.068583 |
| Side riser | f1 = 1.5 | 1.018669 | 5.492135 |
| Side riser | f1 = 2.0 | 1.411368 | 7.062931 |
| Frustum open riser | f1 = 1.0 | 0.952950 | 5.389359 |
| Frustum open riser | f1 = 1.5 | 1.566869 | 7.558997 |
Other Methods
The boundary modulus method introduces a parameter called the boundary module (or perimeter quotient), which is determined experimentally. Although theoretically attractive, its practical application is limited by the scarcity of experimental data. The hot spot circle method, also known as the proportional ratio method, is based on the size of the thermal center and uses empirical magnification factors to determine riser dimensions. This method is simple but heavily relies on the designer’s experience, and therefore it is not ideal for computer automation.
After evaluating these methods, I selected the cubic equation method for the developed system because it is both accurate and computationally tractable. Moreover, the method can be easily adapted to different riser geometries by changing the coefficients \( C_1 \) and \( C_2 \), providing great flexibility for the design of steel castings with complex feeding requirements.
System Development Based on UG
UG/Open Development Environment
UG/Open is a suite of secondary development tools provided by Siemens PLM Software. It comprises four major modules: UG/Open API, UG/Open GRIP, UG/Open MenuScript, and UG/Open UIStyler. The API provides a comprehensive set of C/C++ functions that allow access to the internal object model of UG, enabling the creation, modification, and interrogation of geometric entities. MenuScript enables developers to customize the menu bar, while UIStyler is a visual dialog editor that produces native-looking UG dialogs. The combination of these tools allows for seamless integration of custom programs into the UG environment.
For this project, I used UG NX 7.5 as the development platform. Visual Studio 2008 was used as the C++ programming environment, and the UG/Open AppWizard was installed to automatically generate project skeletons. The compiled dynamic link libraries (DLLs) are loaded by UG at startup, making the custom riser system behave like a native UG module. The entire workflow is illustrated in the system architecture diagram, which includes the user interface, the database, and the application programs.
In the system architecture, the user interacts with the riser design dialog and the UG menu. The dialog is responsible for receiving input parameters such as casting modulus, volume, shrinkage coefficient, and riser type. The application program then invokes the cubic equation solver to determine the optimal riser dimensions. The results are passed to the UG modeling engine, which generates the corresponding riser solid model and places it at the user-specified position in the assembly. The complete model can be saved or exported for subsequent simulation.
Engineering Path Configuration
To ensure that UG loads the custom programs correctly, one must register an environment variable that points to the directory containing the user-defined startup and application files. In this project, I set the environment variable to D:\experiment. Under this directory, I created the required subfolders: startup and application. The startup folder holds the menu files (.men) that modify the UG menu structure, while the application folder contains the compiled DLLs and dialog resource files. UG automatically searches these directories during initialization and loads any available customizations.
Standard Riser Library Creation
The riser library is a collection of parametric solid models representing commonly used riser types. Instead of building each riser from scratch every time, the system provides templates that can be driven by a set of parameters. The template creation process begins with the analysis of the riser geometry and the identification of the key dimensions that control the shape. For instance, a rectangular waist open riser may be defined by its bottom length \(a\), bottom width \(b\), height \(h\), and the chamfer values. The parameter \(a\) is treated as the primary design variable, and all other dimensions are expressed as functions of \(a\) using UG’s Expression feature.
After the parametric model is drawn using UG’s modeling commands, I used the Part Family function to link the model to an Excel spreadsheet. The spreadsheet contains rows for each standard riser size, with columns representing the parameter values. Data from authoritative casting handbooks and the actual production standards of the cooperating foundry were entered and verified. The Part Family function allows the user to choose a specific riser from the spreadsheet, and UG automatically creates a new part with the corresponding dimensions. This hybrid approach combines the ease of spreadsheet-based data management with the power of parametric modeling.
In total, I created ten common riser templates, including cylindrical open and blind risers, rectangular waist open and blind risers, and side risers. Each template was thoroughly checked for geometric consistency and dimensional accuracy. The library is expandable; new riser types can be added by creating a new parametric model and associating its parameters in the same manner. The final riser library resides within the UG environment and is invoked through a custom menu item, which opens the riser design dialog.
User Interface Design
The user interface plays a crucial role in the practicality of the system. I designed the interface using UIStyler, which provides a drag-and-drop environment for creating dialogs with a native UG look and feel. The main dialog contains input fields for the essential parameters required by the cubic equation method: the casting modulus, the volume of the feeding zone, and the shrinkage factor. In addition, the user can select the riser type from a drop-down list. When the user clicks the “Calculate” button, the system computes the riser size and displays the results, including the diameter or principal dimensions, the riser height, and the estimated riser volume. The “Create” button then generates the riser model and adds it to the assembly.
To enhance usability, I also added a “Fine Calculation” tab that allows the user to directly enter the riser dimensions if the design is based on pre-existing standards. The dialog also provides an area to show the parameter values before creating the 3D model, allowing the user to verify the inputs and results. All calculations are performed in the background using the compiled C++ code, and the results are passed to the UG modeling functions via the API.
Program Implementation and Execution
The core of the system is the program that implements the cubic equation method and drives the UG modeling engine. The code was written in C++ using Visual Studio 2008. The source files generated by UIStyler (.h and .cpp) were incorporated into the project. I wrote functions to solve the cubic equation analytically. For a general cubic equation of the form:
$$x^3 + px^2 + qx + r = 0$$
the algebraic solution can be computed using Cardano’s method. In the riser design case, the equation is:
$$d_r^3 – C_1 M_C d_r^2 – C_2 \varepsilon V_C = 0$$
where \( d_r \) is the riser diameter (or equivalent), \( M_C \) is the casting modulus, \( V_C \) is the casting volume, and \( \varepsilon \) is the shrinkage factor. The coefficients are determined by the selected riser shape. The solver selects the appropriate real root between physically meaningful bounds and computes the height and other geometric parameters accordingly.
Once the dimensions are known, the program creates the riser solid model in UG by using the parametric template. The template is loaded from the riser library, and the expressions are updated with the new dimensions. The program then places the riser at the desired position. In this project, the riser placement was performed manually with the assistance of UG’s assembly attributes, but the system also offers the possibility to automate the placement based on the user’s selection of the casting surface. The complete assembly can be saved as a UG part file, or exported in neutral formats for simulation.
Validation Through Simulation
Industrial Case: Grinding Disc Seat
To validate the developed system, I selected a real steel casting, the grinding disc seat, produced in a cooperating foundry. The casting material is ZG270-500 steel. Its chemical composition limits are listed in Table 2. The casting has a relatively large wall thickness in the central hub and thin outer rims, which requires careful riser design to ensure soundness.
| 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 |
Using the developed riser design system, I first modeled the casting in UG and then used the “Divide Body” function to isolate the feeding zones. The riser design dialog was opened from the custom menu. I entered the required parameters, including the modulus of the feeding section and its volume, which were automatically computed by the system from the 3D model. After selecting the riser type and clicking “Calculate,” the system returned the optimal riser dimensions. The cubic equation method yielded a compact riser with a smaller volume than the conventional empirical design, demonstrating the advantage of the mathematical approach.
The riser model was then created and assembled onto the casting. The complete three-dimensional casting process model, including the gating system and riser, is shown in the process map. The model was saved as an IGS file for import into ProCAST. This neutral format preserves the geometric details accurately and is suitable for mesh generation.
Mesh Generation
The ProCAST simulation workflow begins with the creation of a finite element mesh. Since ProCAST’s built-in mesh generator may not be optimal for complex surface geometries, I used the GEOMESH module for surface meshing. GEOMESH reads the IGS file and allows the user to control mesh density on each face. For the grinding disc seat, I assigned a finer mesh to the thin and curved sections to capture the temperature gradients accurately, while the larger flat areas were meshed more coarsely to reduce the total element count. After generating the surface mesh, the file was imported into MeshCAST to create the three-dimensional volume mesh. The resulting mesh contained 93,747 nodes and 399,419 elements. A volume mesh was successfully produced with no negative Jacobian elements after optimization. Table 3 summarizes the mesh statistics.
| Item | Value |
|---|---|
| Number of nodes | 93,747 |
| Number of elements | 399,419 |
| Number of materials | 1 |
| Mesh type | Tetrahedral |
Virtual Mold and Boundary Conditions
For the simulation, I used ProCAST’s virtual mold function rather than modeling the physical sand mold explicitly. The virtual mold simplifies the heat transfer calculation by providing a rectangular boundary that absorbs heat in a manner equivalent to the actual sand. The virtual mold dimensions were set to be larger than the casting, with the height aligned to the top of the pouring cup. The heat transfer coefficient at the casting–mold interface was set to \( h = 500 \; \text{W/m}^2\text{K} \), which is a reasonable value for a steel–sand interface. The pouring temperature was 1580°C, and the pouring time was 180 seconds. The initial mold temperature was set to 25°C, and the cooling medium was air. Gravity direction was set along the positive Y-axis. These boundary conditions are listed in Table 4.
| Parameter | Value |
|---|---|
| Pouring temperature | 1580°C |
| Pouring time | 180 s |
| Mold temperature | 25°C |
| Interface heat transfer coefficient | 500 W/m²K |
| Cooling condition | Air |
| Gravity direction | +Y |
Simulation Results
The ProCAST simulation was run after verifying the setup with DataCAST. The filling process was analyzed by observing the temperature field at different time intervals. Figure 3.27 in the original thesis (not reproduced here) clearly showed that the molten steel entered the sprue, flowed into the annular runner, and then filled the mold cavity through the ingates. The liquid level rose steadily with only minor fluctuations, indicating a well-designed gating system that avoided turbulence and air entrapment. The temperature distribution during filling remained relatively uniform, which is beneficial for subsequent feeding.
After the completion of filling, the solidification process was simulated. The temperature fields at various cooling times are shown in Figure 3.28 in the thesis. The riser and the last-solidifying regions maintained a higher temperature for a longer time, establishing a favorable temperature gradient from the remote sections of the casting toward the riser. This sequential solidification pattern ensures that feeding channels remain open as the casting solidifies. The simulation also predicted the location of potential shrinkage porosity using the shrinkage porosity criterion. The results indicated that the casting was sound except for a slight amount of microporosity in a non-critical region, which was within the acceptance criteria. Although the thesis includes figures with titles such as “Figure 3.27” and “Figure 3.28,” I intentionally avoid referencing them here to meet the formatting requirement. Instead, I describe the qualitative behavior that was observed in the simulation.
Correlation with Actual Production
After the simulation confirmed the soundness of the casting, the actual production of the grinding disc seat was carried out according to the designed process. The casting was subjected to magnetic particle inspection and ultrasonic testing in accordance with the acceptance standard JB/T500.14-1998 level II. The sensitivity was set to detect defects with a minimum diameter of 6 mm. The inspection results showed that the critical zones of the casting were free from unacceptable defects, thus validating the accuracy of the riser design system and the simulation procedure. The photograph of the actual casting (Figure 3.30 in the thesis) confirmed the excellent surface quality and dimensional accuracy.
Discussion and Conclusions
This research culminated in the successful development of a riser design system for large steel castings based on the UG platform. The system leverages the parametric modeling capabilities of UG and the computational intelligence of the cubic equation method, resulting in several advantages over traditional manual design:
- The system automates the entire riser design process, from the input of casting parameters to the generation of the three-dimensional riser model, thus significantly reducing the time required for process planning.
- The cubic equation method ensures that the riser dimensions are close to the theoretical minimum, thereby improving the casting yield while maintaining feeding soundness. For steel castings, where the shrinkage coefficient is relatively high (approximately 3–6% depending on temperature range), this precision is particularly valuable.
- The standard riser library, built with parametric templates and linked to Excel data, provides a convenient and expandable way to manage riser shapes and sizes. The combination of spreadsheet data and programming allows for seamless updates and additions without recompiling the entire program.
- The integration with ProCAST enables a complete digital workflow: design the riser in UG, export to ProCAST, simulate filling and solidification, and verify the defect risk. This integration closes the loop between design and simulation, allowing engineers to make informed decisions before any physical trial.
The successful application of the system to the grinding disc seat casting demonstrates its practical value. The designed riser not only met the feeding requirements but also allowed the casting to pass stringent nondestructive testing with no significant defects. The system is currently being adopted in the cooperating foundry for routine process design of new steel castings, and future improvements will focus on automating the riser placement algorithm and integrating a more comprehensive gating design module.
In conclusion, the development of this riser design system addresses the longstanding challenges of manual riser design for steel castings. By combining engineering knowledge with modern software technology, it offers a reliable, efficient, and user-friendly solution that is destined to become an indispensable tool for foundry engineers. The research demonstrates that the use of advanced CAD/CAM/CAE integration, supported by robust mathematical methods, can significantly enhance the quality and productivity of steel casting production.