Steel casting is one of the most critical manufacturing processes in the machinery industry. It provides near-net-shape metallic components with complex geometries, excellent mechanical properties, and reliable internal integrity. The quality of a steel casting is strongly influenced by the mould filling process, and the gating system is the key element that controls the flow of molten steel from the ladle into the mould cavity. A well-designed gating system must ensure smooth and continuous filling, prevent air entrainment, minimize turbulent flow, aid in slag separation, and establish a favourable temperature gradient for subsequent solidification. In my research, I focused on the development of dedicated gating systems for steel casting production, using the powerful CAD platform UG (Unigraphics NX) and its secondary development tools. The goal was to automate and parameterize the design of gating systems so that foundry engineers can create reliable steel casting feeding layouts in a fraction of the time previously required.
Before the advent of computer-aided design, gating systems for steel casting were drawn manually. This process was slow, error-prone, and relied heavily on the experience of the process engineer. Even with the introduction of general-purpose CAD software, the designer still had to create every runner, ingate, sprue, and pouring cup from scratch. This is not only tedious, but also requires extensive knowledge of casting standards and empirical rules. The most effective way to overcome this bottleneck is to use the API (Application Programming Interface) of a mature CAD system and build specialized, knowledge-based modules that encapsulate standard design rules. In this project, I developed two families of gating system modules for steel casting: a pump-type series and a pump-valve type series. Both series are based on UG and were written in C++ using the UG/Open API, with Microsoft Visual Studio 2010 as the development environment. The systems allow the user to load standard components, modify their dimensions, transform their positions, and assemble them into a complete gating layout, all while following national casting standards and the internal design codes of two collaborating foundry companies.
Looking back at the history of CAD development, the 1960s and 1970s marked the era of interactive computer graphics. Ivan Sutherland’s SKETCHPAD system laid the foundation for modern CAD. In the late 1970s, CATIA introduced excellent surface and solid modelling capabilities. In the 1980s, parametric modelling became popular with the release of Pro/Engineer, while AutoCAD made CAD affordable on personal computers. Later, SolidWorks and Solid Edge brought feature-based parametric modelling to a broad user base. Today, CAD systems are indispensable in foundry engineering, but commercial packages are usually generic. They do not know the specific rules of steel casting, such as how to calculate the choke area, how to select the number of ingates, or how to position a ceramic pipe elbow. Therefore, secondary development is the bridge between a generic CAD system and a domain-specific application.
In China, the research and application of casting process CAD started in the 1980s. Many universities and research institutes developed standalone programs for gating or riser design, but these programs were often disconnected from the actual geometric model. With the rise of 3D parametric CAD, efforts shifted toward embedding casting knowledge into CAD platforms. The trend now is toward integration, intelligence, and concurrent engineering. A modern steel casting CAD system should be integrated with numerical simulation, process planning, and manufacturing databases. It should also apply artificial intelligence techniques such as expert systems and neural networks to capture heuristic knowledge. In the future, virtual reality and cloud-based collaborative design will further enhance the efficiency of steel casting process development.
The main research content of my work can be summarized as follows. First, I studied the theoretical basis of gating system design for steel casting, including the flow of liquid metal, the calculation of choke areas, the selection of sprue, runner, and ingate areas, and the empirical formulas for filling time. Second, I developed a fully automated gating system module for a pump manufacturer. This module automatically computes the recommended sizes of all gating elements after the user inputs the casting information and the average wall thickness. It supports three runner shapes (I-type, cross-level type, and ring type), one to three tiers of ingates, and both top, middle, and bottom pouring configurations. Third, I developed a manual gating system module for cases where the user wants to draw the runner geometry manually and then sweep a selected cross-section along the runner curve. Fourth, for a steel valve casting company, I developed a pipe-and-bend gating system based on prefabricated ceramic components, and a double-ingate streamlined gating system. Finally, I added a customizable system that enables users to add their own standard components to the library and reuse them in future steel casting designs.
The remainder of this paper is organized as follows. Section 2 gives an overview of the system architecture and the key technologies used for the secondary development. Section 3 describes the design and calculation methods, including the theoretical formulas and the classification of gating system types. Section 4 presents the implementation details and the user interfaces of the developed modules. Section 5 concludes the paper and gives an outlook on future improvements.
2. Overall Design and Development Technologies
2.1 Gating System Process Design for Steel Casting
The design process of a gating system for steel casting can be quite complex. In the automatic gating system module, I adopted a step-by-step workflow to guide the user from initial casting information to a complete solid model. The workflow consists of the following steps:
1. Extract the casting information from the CAD model, such as bounding box, volume, mass, and estimated total metal weight. This step uses the function UF_MODL_ask_bounding_box to obtain the overall dimensions and the inherent mass properties of the solid body.
2. Perform the technological calculation of the casting. The user inputs the average wall thickness of the steel casting and selects whether to fix the tundish nozzle area. The system then calculates the filling time, pouring rate, nozzle flow rate, and the total cross-sectional areas of the sprue, runner, and ingates.
3. Create the runner and ingate line frame. The user chooses the pouring type (bottom, middle, or top), the runner geometry (I-type, cross-level type, or ring type), and the number of ingates. The system loads a parameterized sketch as a guiding line frame.
4. Place the sprue(s). The user can position one, two, or three sprues at the desired points on the runner line frame.
5. Form the solid runner and ingates. The user selects the cross-section shape for the ingates and the runner (e.g., trapezoid, ellipse, or rectangle), optionally using the recommended values automatically calculated in step 2. The system then sweeps the cross-section along the line frame to create the solid geometry.
6. Add the pouring cup and sprue well. The system combines all components into a single gating system solid using Boolean operations.
For the pipe-and-bend system, the workflow is different. This system is composed of prefabricated ceramic components such as straight pipes, three-way pipes, four-way pipes, and bends. The designer selects the type of component, positions it on a selected planar face, and then adjusts its orientation. The components are assembled one by one. Once the assembly is complete, all components are merged together using the boolean union operation. The process is as follows:
1. Select the desired type of pipe or bend (e.g., an equal tee, a reducing tee, a cross, or a 90-degree bend).
2. Choose the nominal diameter and the placement point/face.
3. Load the component from the standard part library.
4. Adjust the position and orientation if necessary.
5. Repeat steps 1–4 for all components.
6. Click “Calculate Gating Ratio” to verify the cross-sectional area ratios and then merge all components into one solid gating system.
2.2 Development Platform and Tools
UG is a feature-rich CAD/CAM/CAE/PDM system. For customization, Siemens provides a comprehensive suite of development tools called UG/Open. This suite consists of four main modules:
– UG/Open API: This is a C/C++ library containing more than 2000 functions that allow developers to create, edit, and query UG objects. It can also manipulate files, databases, and graphics. In this project, the majority of the code was implemented using UG/Open API.
– UG/Open GRIP: A programming language used for creating graphical interactive programs. It is older than the API and has its own syntax, but it can also be used to build simple automated routines.
– UG/Open MenuScript: A tool for creating custom menus and toolbars. I used it to create the main menu items for the steel casting gating system.
– UG/Open UIStyler: A tool for building dialog boxes with the native UG look-and-feel. All the dialog windows in my gating system were created using UIStyler.
I chose Microsoft Visual Studio 2010 as the IDE and compiled the application as a dynamic link library (DLL) that runs inside UG. The external interface allows the user to start the module from a custom menu. At runtime, the DLL calls various UG/Open API functions to implement the required functionality.
2.3 Key Technologies in the Development
Four technologies were essential to the successful development of the gating system for steel casting:
Parametric Design Technology. The standard gating components are all modelled with dimensions as parameters. For example, an ingate line frame has length, width, angle, and number of ingates as parameters. When the user changes a dimension, the model updates automatically. This is achieved by using UG expressions and the API functions UF_MODL_edit_exp and UF_MODL_update. In the base parts, I also used inter-part expressions to link geometry with the design table.
Template Technology. A standard part library was built by designing template parts for each family of gating components. The template parts are stored in a dedicated library folder. When the user invokes a load command, the system copies the template into the working part and renames the expressions with a unique prefix. This allows unlimited reuse of the same geometry without name conflicts. The template approach greatly reduces the number of stored files and makes the system easy to maintain.
Database Technology. The recommended cross-sectional areas and the dimensions of standard ceramic pipes were stored in an external database (Excel or a simple text file). The system reads the database to provide recommended values in dialogs. Users can also add new rows to the database to expand the library. Three database loading strategies were combined in the implementation: electronic spreadsheets, user-defined records, and expression-based relations.
Improved Transform and Expression Conflict Handling. In older versions of UG, transforming objects required a series of functions (uf5942 to uf5947) to construct a transformation matrix. This was slow and error-prone. In modern UG, the function UF_MODL_transform_entities can move a set of objects directly, which greatly reduces the code size and improves performance. In this system, I also solved the common problem of expression name conflicts. Different standard part families use different prefixes, and duplicate instances of the same family use suffixed names. This ensures that every expression remains unique in the working part.
3. Design and Development of the Gating System for Steel Casting
3.1 Theoretical Determination of Gating System Dimensions
For steel casting, the gating system must be designed to fill the mould quickly and quietly. The most widely used approach in Chinese foundry practice is the so-called “weight-velocity method”. This method first computes the filling time based on the weight and wall thickness of the casting, then calculates the required pouring velocity, and finally determines the choke area (normally the sprue orifice or the cross-section at the sprue well). The area distribution among the sprue, runner, and ingates is chosen according to a pre-selected ratio.
The fundamental formula for the choke area in the “small- orifice” model is derived from Torricelli’s law:
$$
A_c = \frac{G_L}{\rho_L \cdot t \cdot \mu \cdot \sqrt{2gH_p}}
$$
where \(A_c\) is the choke cross-sectional area in cm², \(G_L\) is the mass of liquid metal flowing through the choke in kg, \(\rho_L\) is the density of liquid steel in kg/cm³, \(t\) is the filling time in seconds, \(\mu\) is the flow-loss coefficient, \(g\) is gravitational acceleration, and \(H_p\) is the average static head pressure in cm.
For a gating system with three elements (pouring cup, sprue, and ingates), the pressure head in front of the ingates can be calculated as:
$$
h_p = \frac{H_p}{1 + k_2^2}
$$
where \(k_2\) is the ratio of the sprue cross-sectional area to the ingate cross-sectional area. For a four-element system (with runner added):
$$
h_p = \frac{H_p}{1 + k_1^2 + k_2^2}
$$
where \(k_1\) is the sprue-to-runner area ratio. The average static head itself depends on the pouring position, as shown in Table 1.
| Pouring position | Example | Static head formula |
|---|---|---|
| Bottom injection | Ingates at the bottom of the casting | \(H_p = H_c – \frac{h_c}{2}\) |
| Middle injection | Ingates at the middle height | \(H_p = H_c – \frac{h_c}{8}\) |
| Top injection | Ingates at the top of the casting | \(H_p = H_0\) |
In the weight-velocity method, the filling time for a steel casting is estimated from the total mass of steel \(G_L\) and the average wall thickness \(\delta\). For castings with \(G_L \le 15\) tons, I used the following empirical formula:
$$
t = S_1 \delta \sqrt[3]{G_L}
$$
where \(S_1\) is a coefficient that depends on the average wall thickness and the steel mass. For larger castings, the formula becomes:
$$
t = S_2 \sqrt{G_L}
$$
Values for \(S_1\) and \(S_2\) are given in Tables 2 and 3.
| Average wall thickness \(\delta\) (mm) | Steel mass \(G_L \le 25\) t | \(G_L = 25-40\) t | \(G_L = 40-60\) t | \(G_L > 60\) t |
|---|---|---|---|---|
| 1.0–6.0 | 1.3 | 1.2 | 1.1 | 1.0 |
| > 50.0 | 1.4 | 1.3 | 1.2 | 1.1 |
| Casting relative density \(\rho_{rel}\) (g/cm³) | Steel mass 1.0–2.0 t | 2.0–3.0 t | 3.0–4.0 t | 4.0–5.0 t | >5.0 t |
|---|---|---|---|---|---|
| 10.0–50.0 t | 1.2 | 1.3 | 1.4 | 1.5 | 1.6 |
| >50.0 t | 1.1 | 1.2 | 1.3 | 1.4 | 1.5 |
After the filling time is known, the average pouring rate is:
$$
v = \frac{G_L}{t}
$$
The tundish nozzle must supply about 1.3 times this rate to compensate for fluctuations:
$$
v_b = 1.3\,v
$$
The nozzle area can then be calculated from the efflux equation:
$$
v_b = \mu A_b \rho \sqrt{2gH_0}
$$
where \(A_b\) is the nozzle cross-sectional area, \(\rho\) is the density of liquid steel (taken as 7 kg/dm³), and \(H_0\) is the static head of steel in the ladle. In practice, this equation simplifies to:
$$
A_b = \frac{v_b}{0.248 \sqrt{H_0}}
$$
For a bottom-pour ladle, the area ratio of the gating system is usually selected as:
$$
A_b : A_s : A_r : A_g = 1.0 : (1.8\text{–}2.0) : (1.0\text{–}2.0) : (2.0\text{–}2.5)
$$
where \(A_b\), \(A_s\), \(A_r\), and \(A_g\) denote the areas of the nozzle, sprue, runner, and ingates, respectively.
Another approach for large steel castings is the steel rising speed method. The minimum acceptable rising speed of molten steel in the mould cavity depends on the casting weight and complexity. Typical values are listed in Table 4. The filling time is then computed by dividing the casting height by the rising speed. The nozzle diameter is selected according to the required pouring rate.
| Casting weight (t) | Complex shape | Medium shape | Simple shape |
|---|---|---|---|
| ≤5 | 25 | 20 | 15 |
| 5–15 | 20 | 15 | 10 |
| 15–35 | 16 | 12 | 8 |
| 35–65 | 14 | 10 | 6 |
| 65–100 | 12 | 8 | 5 |
| >100 | 10 | 7 | 4 |
3.2 Design Features of Dedicated Gating Systems
Based on the development experience, I classified gating systems along two axes: the representation of standard components (line-frame vs. solid) and the design process (step-by-step vs. direct-loading).
Line-frame systems use parameterized wireframe sketches as temporary guides. The user first loads the wireframe, chooses the cross-section type, and then creates the solid runner/ingates by sweeping. This approach minimizes the number of part files and is very flexible.
Solid systems use pre-built solid models of standard components (e.g., ceramic pipes, elbows, or a complete double-ingate runner). The components are either assembled together or loaded directly as a complete gating system. Solid systems are simpler to use when the part geometry is too complex to be represented by a simple swept wireframe.
Step-by-step design is essential when the final gating system is assembled from several discrete components that must be positioned in sequence. This is true for the automatic system and the pipe-and-bend system.
Direct-loading design is used when there exists a single standard part that already represents the whole gating system. The user only needs to specify one placement point and direction. The double-ingate streamlined system is a good candidate for this approach, because its complex curved runner cannot be split into simple line-frame components.
The choice of the design type is guided by the following considerations:
- The size and number of standard components. Fewer and smaller files are better.
- The total software size and the memory footprint.
- The development cycle. Solid components with complex surfaces take longer to build.
- User experience. The interface must be intuitive and reduce the number of steps.
- Code complexity and maintainability.
3.3 Development of the Pump-Type Gating System
The pump-type gating system is used for medium-sized steel castings commonly found in centrifugal pumps, such as impellers, casing halves, and support plates. It includes both an automatic system and a manual system.
For the automatic system, I chose the line-frame + step-by-step approach. The reason is that the automatic system supports three runner geometries (I-shape, cross-level shape, and ring shape). Each shape can have between one and twelve ingates, and there are three possible cross-section shapes for ingates and runners. If I had created a solid model for every possible combination, the number of standard parts would exceed 2200. In contrast, the line-frame approach requires only a handful of templates: eight I-shape frames, eight cross-level frames, twelve ring frames, three cross-section lines, one sprue guide line, one pouring cup curve, and one sprue-well curve. This reduces the part count to 34 templates and gives the user complete freedom to change dimensions afterwards.
In the automatic system, the structural calculation is performed in two dialogs. The first dialog extracts the casting information: material type, part density, process yield, and the selected solid body. The system computes the bounding box, volume, mass, and estimated liquid steel weight. The second dialog uses the casting weight and the average wall thickness to calculate the filling time, pouring velocity, nozzle diameter, and recommended areas for the sprue, runner, and ingates. The user may fix the nozzle area if a standard ladle nozzle must be used. The recommended values are stored in a small database, and the user can modify the database to match the actual workshop practice.
For the manual gating system, I allowed the user to draw the runner line manually using UG sketch tools. Then the user chooses a cross-section (trapezoid, ellipse, or rectangle) for the ingate and runner, and the system sweeps the section along the selected line to generate the solid body. The manual system is also based on the weight-velocity calculation so that the user can see the recommended areas while creating the cross-sections.
3.4 Development of the Pump-Valve Type Gating Systems
The pump-valve type gating systems are intended for large steel valve bodies and pipe fittings. Two distinct sub-systems were developed.
The first sub-system is the pipe-and-bend system. This system is used with prefabricated ceramic pipes. Ceramic components have excellent thermal shock resistance and can withstand high pouring temperatures. They are also easy to cut and join, which makes them ideal for steel casting gating systems. I chose the solid + step-by-step approach. The standard components include equal tees, reducing tees, crosses, and bends. Each component has fixed nominal sizes but can be parametrically modified after loading. The user selects the component type, specifies the insertion point and face, and the component is added to the assembly. Because many identical components may be used in the same gating system, each loaded part is assigned a unique attribute so that it can be selected later for modification or deletion. The attribute functions UF_ATTR_assign, UF_ATTR_find_attribute, and UF_ATTR_read_value were used to implement this bookkeeping.
The second sub-system is the double-ingate system, also called a streamlined gating system. This design has no sharp corners and minimizes the change in flow direction, which reduces turbulence and inclusions. The geometry is very complex: the runner consists of a swept solid with a varying cross-section, smooth bends, and special inlets. I selected the solid + direct-loading approach. A complete solid part was built in UG using advanced surface modelling operations such as curve mesh, bounded plane, and sewing. Once the part is loaded into the working part, the program automatically merges it with the casting using a Boolean union. The user only has to select the reference point and the direction. Because of the complexity, the part must be designed carefully to ensure that all dimensions are associative and can be edited without corrupting the surface patches.
The custom gating system is an extension of the previous two. It allows the user to take any solid part they have designed and add it to the custom library. The custom library is organized into two sections: “pipe-like” components (which are assembled together) and “double-ingate-like” components (which are loaded as a complete unit). The user can delete, rename, or modify the custom components. This makes the system opens to future expansion for new steel casting products.
4. Implementation and Application
4.1 User Interface and Main Menu
The main menu of the steel casting CAD system is added to the UG menu bar under the name “3D Casting Process CAD”. It contains the following items: “Extract Part Information”, “Casting Process Analysis”, “Automatic Gating System”, “Gating System Tools”, “Manual Gating System”, and “Pipe/Bend Gating System”. Each item opens a set of dialogs built with UIStyler. In the following sections, I describe the actual implementation steps using an example of a disc-shaped steel casting.
4.2 Automatic Gating System
The first step is to extract the part information. The user selects the steel casting solid model and chooses the material (e.g., carbon steel or alloy steel). The system displays the bounding box dimensions, the volume, the mass, and the estimated total liquid steel weight, as shown in the dialog. The recommended process yield is initially set to 65%, but the user can change it.
In the second step, the user enters the average wall thickness of the casting. A click on “Calculate” computes the filling time and the areas of all gating elements. The interface offers two options: “Fixed sprue orifice” or “Free sprue orifice”. In the first case, the user enters the orifice diameter and the system calculates the other areas accordingly. In the second case, the system calculates the optimum nozzle diameter from the casting parameters. The calculated areas are then matched to the nearest standard sizes in the database.
The third step is to lay out the runner system. After the casting and the gating areas are known, the user chooses the pouring type (bottom, middle, or top) and the runner form (I-shape, cross-level, or ring). For example, if a four-ingate ring runner is selected, the program loads a ring-shaped wireframe with four stubs. The wireframe has parameters for the radius, the angle between ingates, the length of the ingates, and the distance from the casting. If the wireframe is not in the desired position, the user can move it using the “Translate” function. The translation dialog allows both offset movements along X, Y, Z and point-to-point movement. The point-to-point operation uses a point constructor to select the source and target points.
The fourth step is to place the sprue. The user can specify the number of sprues (1, 2, or 3) and their height. By choosing a point on the runner wireframe, the sprue guide line is placed. The system verifies that the sprue does not intersect existing features.
The fifth step creates the solid runner and ingates. The user selects the cross-section type for the ingates (trapezoid, ellipse, or rectangle) and the cross-section type for the runner. If the user clicks “Use Recommended Values”, the system reads the areas from the calculation dialog and applies the corresponding dimensions. Otherwise, the user can type the dimensions manually. The system then sweeps the cross-sections along the wireframe curves. A “sprue well” is added at the bottom of the sprue. Finally, a pouring cup is created on top of the sprue. The last command merges all solid bodies into one gating system using a Boolean union. A demonstration of the completed automated gating system on a pump casing is shown in the figures in the original thesis (not repeated here).
4.3 Manual Gating System
The manual gating system is useful when the user needs a custom runner path that is not one of the standard shapes. The user first draws the runner center line as a sketch in UG. Then, from the manual gating system dialog, the user selects the wire curve as the guide line and clicks “Create Runner”. The section selection window becomes active. The user chooses the section shape and the dimensions. The system uses the function UF_MODL_create_sweep to create a swept solid along the selected guide line. This avoids the need to create a new standard part for every odd shape. The manual system also includes a “sprue stick” design function that creates a simply cylindrical sprue by specifying the diameter and height.
4.4 Pipe-and-Bend System
The first dialog of the pipe-and-bend system lists all available standard components: equal tee, reducing tee, cross, and bend. In addition, there are pre-assembled combinations, such as an equal tee with one bend, a reducing tee with two different bends, and a cross with a tee. Selecting one of these opens a sub-dialog where the user specifies the nominal size, the placement point, and the placement plane. After clicking “Load”, the component is imported into the working part and an attribute is assigned to it. The component list in the dialog shows an incremental number for each loaded component. This allows the user to select any component and then perform one of three operations: delete it, modify its dimensions, or re-position it.
The modification dialog displays a bit-mapped sketch of the component with all dimension labels. The user enters new values, and the system updates the expression values. For example, the length of a tee branch or the wall thickness of a bend can be changed from standard to non-standard if necessary.
The positioning dialog offers translation along X, Y, Z, point-to-point translation, and rotation about an axis. The rotation function uses UF_CSYS_map_point to map coordinates between the working coordinate system and the absolute coordinate system. After all components are assembled, the “Calculate Gating Ratio” dialog computes the actual area ratios and displays them next to the recommended values. The last step merges all components into one solid body. In practice, this system has been used to design gating for large steel valve bodies with multiple ingates.
4.5 Double-Ingate System
The double-ingate streamlined system is loaded from a single solid part. The user selects a placement point and a placement direction. The system imports the part and applies a transformation to align it with the requested location. If the position or orientation needs adjustment, the user can use the “Transform” dialog. The “Delete” button removes the loaded part. The “Calculate Yield” button computes the current process yield based on the known casting weight and the calculated gating weight. This system significantly reduces the design time for complex steel castings that require a smooth flow path.
4.6 Custom System
The custom system is divided into two tabs: “Pipe and Bend” and “Double-Ingate”. In the “Pipe and Bend” tab, the user can click “Add standard” to select a .prt file from the disk. The system copies the file into the custom library directory and adds its name to the list. The user can then delete or modify the custom part. When the custom part is selected and loaded, the system behaves exactly like the built-in pipe-and-bend system. The same logic applies to the “Double-Ingate” tab, except that the custom part is loaded as a complete gating system rather than as an individual component.
All the systems described above were tested on representative steel casting models. The computation time for the gating areas was negligible, and the solid generation took less than two seconds for typical components. The expression conflict handling mechanism proved to be robust even when the same standard component was loaded more than twenty times in one assembly. User feedback from the collaborating foundries indicated that the design time for a gating system was reduced from several hours to about ten minutes, a more than 90% reduction.
5. Conclusion and Outlook
In this research, I successfully developed a set of dedicated gating systems for steel casting based on the UG platform. The primary achievements are summarized below.
First, I implemented an automatic gating system module for pump-type steel castings. The module uses the weight-velocity method to calculate the cross-sectional areas of all gating elements. It supports three runner geometries (I-shape, cross-level, and ring), one to three tiers of ingates, and multiple ingate counts. The system allows the user to load parameterized line frames, adjust their dimensions and positions, create the actual solid runner and ingates, and finally merge all components into a single gating system body.
Second, I implemented a manual gating system that gives the user complete freedom to draw custom runner paths and then convert them into solid runners by sweeping a selected cross-section. This system is very useful for repairing or adjusting gating systems in existing casting moulds.
Third, I developed a pipe-and-bend gating system based on ceramic components. The system contains a library of standard pipes, tees, crosses, and elbows, and also supports pre-assembled combinations. The user can load, delete, modify, and position each component individually. This system has been adopted in the production of large steel valve castings.
Fourth, I developed a double-ingate streamlined gating system. This system loads a single complex solid part and places it in the mould cavity in one click. It greatly simplifies the design of high-quality steel castings that require smooth metal flow.
Fifth, I added a custom system that allows users to add their own designed components to the library. This ensures that the gating system is not closed but can evolve with the foundry’s design standards.
Finally, the development experience was generalized into a classification scheme for gating systems. The scheme distinguishes line-frame versus solid representation and step-by-step versus direct-loading design processes. This scheme can serve as a guideline for future development of other casting process modules, such as riser systems, chill systems, and filter placement tools.
There is still room for future improvement. A key direction is to increase the accuracy of the recommendation database by integrating it with real foundry data and numerical simulation results. Currently, the process yield is estimated empirically; using a feedback loop from casting simulation could make the system more precise. Another direction is to increase the level of automation. For example, the system could automatically detect the best position for sprues and ingates based on the geometric features of the steel casting. It could also suggest the optimal gating system type using an expert system. Finally, the system could be extended to support the design of pressurized or non-pressurized gating systems for other alloys beyond steel casting.
In conclusion, the dedicated gating system presented in this paper meets the requirements of the participating companies and significantly improves the efficiency of process design engineers. It demonstrates the power of combining a mature CAD platform with domain-specific knowledge and parameterization. With continued development, such systems will play an increasingly important role in the digitalization of steel casting production.