Research and Development of a Dedicated Gating System for Steel Castings Based on UG

1. Introduction

1.1 Background and Significance

Steel castings are fundamental semi-finished products in the machinery manufacturing industry, serving as critical components across various sectors including energy, transportation, mining, and heavy equipment. The quality of steel castings is largely determined by the design of the pouring or gating system, which controls the flow of molten metal into the mold cavity. A well-designed gating system for steel castings ensures smooth, continuous filling, minimizes turbulence and oxidation, prevents slag entrapment, and helps establish favorable temperature gradients for directional solidification. Conversely, an improperly designed gating system frequently leads to defects such as sand inclusions, cold shuts, gas porosity, shrinkage cavities, and cracks—all of which compromise the integrity and service performance of steel castings.

Despite the critical importance of gating system design, traditional approaches relied heavily on manual drafting and empirical calculations. This methodology suffers from long design cycles, low efficiency, inconsistent drawing quality, and difficulties in modifying designs. The advent of computer-aided design (CAD) software, such as Unigraphics (UG), Pro/ENGINEER, CATIA, and SolidWorks, revolutionized mechanical drafting. These tools offer remarkable advantages in precision, speed, modifiability, and output quality. However, generic CAD platforms do not inherently incorporate domain-specific knowledge for casting process design. This is precisely where secondary development—customizing CAD software through programming interfaces—becomes valuable for creating specialized tools tailored to the steel castings industry.

This thesis addresses the practical needs of two manufacturing enterprises specializing in steel castings: a pump manufacturing company and a valve casting company. Both enterprises required efficient, standards-compliant CAD tools for designing gating systems for steel castings. The project involved developing three-dimensional parametric gating system modules based on the UG platform, using Microsoft Visual Studio 2010 as the development environment, and leveraging UG Open—the official secondary development toolkit of UG software.

1.2 Current Status of Casting Process CAD Research

Internationally, the development of CAD technology for casting processes began in the 1960s with the emergence of interactive computer graphics. Ivan Sutherland’s pioneering SKETCHPAD system at the Massachusetts Institute of Technology laid the foundation for interactive computer-aided design. During the 1970s and 1980s, the aerospace and automotive industries drove rapid advances in solid modeling and surface modeling technologies. Dassault Systèmes of France introduced CATIA, a powerful 3D surface modeling system, while SDRC developed I-DEAS, the first commercial solid modeling software. The 1980s and 1990s witnessed the proliferation of PC-based CAD systems, notably AutoCAD (1982) and Pro/ENGINEER (1988), the latter being the first system to implement parametric, feature-based solid modeling. The mid-1990s saw the emergence of SolidWorks and SolidEdge—both fully parametric 3D modeling packages.

In China, CAD research commenced in the 1970s, growing slowly at first due to limited computational infrastructure. Through the 1980s, more institutes and enterprises began to adopt and further develop CAD systems. Since then, numerous Chinese universities and research centers have developed CAD systems specifically for casting process design. Many such efforts have integrated empirical casting knowledge, standards, and computational methods within CAD platforms, substantially improving the design efficiency of gating systems and feeder systems for steel castings.

1.3 Development Trends in Casting CAD Technology

Modern casting CAD technology is evolving in four major directions:

• Integration (CAD/CAM/CAE): Seamless data flow among design, analysis, and manufacturing modules, enabling unified product development chains.
• Intelligence: Incorporating artificial intelligence, expert systems, and artificial neural networks to automate design reasoning, leveraging accumulated expert knowledge for complex decision-making.
• Concurrent Engineering: Supporting parallel consideration of downstream factors—such as manufacturability, assemblability, and maintainability—early in the design stage, thereby reducing iterations.
• Virtual Reality: Using immersive 3D environments for design verification and visualization, thereby reducing reliance on physical prototypes.

1.4 Research Content

The primary objectives of this research are to develop dedicated gating system modules for steel castings based on the UG platform:

• To develop a dedicated pump-type gating system module, comprising an automatic gating system and a manual gating system, primarily intended for steel castings.
• To develop a dedicated pump-valve-type gating system module, comprising a pipe–elbow gating system, a dual-in-gate gating system, and an extensible custom gating system.
• To classify gating systems according to their development characteristics and standard part features, propose reusable development templates, and provide methodological guidance for future gating system developments for steel castings.

2. Overall Design and Development Technologies

2.1 Gating System Process Design

The automatic gating system module follows a highly structured design workflow. Figure 1 conceptually illustrates this process. The steps are:

1. Extract part information: Obtain geometric data—dimensions, volume, weight, estimated total steel weight—from the 3D model of the steel casting.
2. Process design calculation: Using the weight–velocity calculation method, compute cross-sectional areas for each gating system element.
3. Build runner–gate layout: The system supports up to three tiers of runners and gates. Each tier undergoes identical operations: select runner–gate type, select filling position (top, parting, or bottom), load the runner–gate template wireframe, and then adjust dimensions, transform position, or delete.
4. Position sprues: Choose the number (1–3), height, and location of sprue tubes.
5. Create solid runner–gate geometry: Select cross-sectional shape (rectangular, trapezoidal, or round), define dimensions from the database or use recommended values, and generate the solid runner–gate system.
6. Add pouring cup to complete the assembly.
7. Modify and merge all components to finalize the gating system for steel castings.

The pipe–elbow gating system follows a different workflow:

1. Select standard part type (tee, cross, elbow, or pre-assembled component group).
2. Define placement point and placement plane; load and assemble the standard part.
3. Adjust size, position, or delete the standard part as required; compute the gating ratio (actual pouring speed ratio).
4. Continue assembling additional standard parts or merge to complete the gating system for steel castings.

2.2 Development Platform and Tools

The choice of development platform is critical. UG is an integrated CAD/CAM/CAE/PDM software system that provides a rich application development toolkit called UG/Open. This toolkit is comprised of four main components:

• UG/Open API: A collection of over 2,000 C-function prototypes that allow external programs to create, access, and modify UG objects. This is the primary tool used throughout this project because it provides low-level access to nearly all UG operations—model creation, assembly traversal, expression editing, and file management.
• UG/Open GRIP: A higher-level interpreted programming language for interactive graphics, useful for simpler tasks but less flexible than the API for complex applications.
• UG/Open MenuScript: Supports customization of UG menus and toolbars to launch user-developed programs.
• UG/Open UIStyler: Provides interactive tools for creating UG-style dialogs, which streamline user interaction.

Because of its complete coverage of UG functionality and its compatibility with the C/C++ language, UG/Open API was chosen for the implementation. The development environment included Microsoft Visual Studio 2010, with NX/Open C/C++ as the programming interface.

2.3 Key Development Technologies

2.3.1 Parametric Design Technology

Parametric design involves defining the dimensions and geometric relationships of standard parts in terms of named parameters (expressions). This allows the geometry to be regenerated automatically when parameter values are changed. In UG, expressions serve as the fundamental parametric mechanism. For steel castings gating system standard parts, I employed three parametric modeling approaches:

• Feature-based modeling: Used for parts with simple geometric features—extrusions, revolutions, holes, fillets, pockets—which is the most common approach in this work.
• Sketch-based modeling: For more complex parts, 2D sketch profiles are first drawn on reference planes with appropriate geometric and dimensional constraints; these profiles are then converted into 3D solids through extrude, revolve, or sweep operations.
• Assembly-based modeling: For pre-assembled components such as tee-plus-elbow combinations, geometric positional relationships between constituent parts are parameterized

2.3.2 Template Technology

Template technology is essentially a standard-part library technique. A template is a parameterized UG part file that incorporates standardized geometry and designated variable parameters. For steel castings gating systems, templates dramatically accelerate design—eliminating repetitive modeling of geometrically similar components and ensuring dimensional standardization. In this project, all standard parts were designed as UG part files using parametric features, with carefully chosen expression names to reduce conflicts.

2.3.3 Database Technology

Four methods are commonly used for building standard part libraries in 3D CAD software: spreadsheets, user-defined feature libraries, expressions, and programmatic control. For this project, a hybrid approach was adopted. The selection database for recommended cross-sectional dimensions, the coefficient tables required for process calculations, and the attribute data for standard parts were all stored as structured data files. This modular separation improves maintainability and facilitates future extension of the gating system library for steel castings.

2.3.4 Improved Functions for Common Operations

A significant improvement was made in transforming objects after loading. Previous implementations used the legacy uf5942 through uf5947 function series, which require obtaining the root feature, constructing a transformation matrix, and applying it—a tedious and error-prone process. Beginning with NX5, the UF_MODL_transform_entities() function allows the transformation of entire objects in a single call. This simplifies the code, reduces the number of program lines by a factor of several dozen, and markedly improves both speed and reliability.

Another key issue was expression name conflicts. Standard parts frequently share common expression names—L, W, H, D, R—which cause conflicts when multiple parts are loaded into the same working part. UG provides a suffix mechanism to disambiguate expressions. However, this mechanism can lead to downstream errors when dimensions are subsequently modified because the internal handling of expressions is sensitive to the exact naming. The author therefore developed a prefix-plus-suffix naming strategy:

• Each standard part family receives a unique prefix, which prevents conflicts among different families.
• Individual loaded instances of the same family receive a stored suffix, preventing conflicts among identical-family parts.

This approach substantially improves the robustness of dimension modification in multi-part assemblies for steel castings gating systems.

3. Design and Development of Gating Systems for Steel Castings

3.1 Structural Dimension Calculation Methods

The cross-sectional areas of the gating system elements must be calculated so that the flow rate, filling time, and flow pattern satisfy the requirements of the steel casting. For steel castings, the methods can be classified according to whether a ladle with a stopper rod or a teapot ladle is used. The author focused primarily on the stopper-rod ladle, which employs the weight–velocity calculation method or the liquid steel rising velocity method. In the following, G_L (kg) denotes the total weight of molten steel, t (s) the pouring time, ρ_L (kg/cm³) the density of liquid metal, μ the flow loss coefficient, H_p (cm) the average static pressure head, and g = 981 cm/s².

3.1.1 Flow-Resistance Area Design Method

For gating systems where the choke area is the smallest cross section (generally the sprue base or the ingate), the choke area is determined from the Torricelli orifice formula:

$$A_{\text{choke}}=\frac{G_L}{\mu \rho_L t \sqrt{2 g H_{p}}}$$

The average static pressure head appears in Table 1 for different casting positions.

Filling method	Bottom gating	Parting-line gating	Top gating
Schematic	(—)	(—)	(—)
Static pressure head Hp	$$H_0 – \frac{h_c}{2}$$	$$H_0 – 0.125 h_c$$	$$H_0$$

where H₀ is the vertical distance from the pouring basin (sprue top) to the lowest ingate, and h_c is the total height of the steel casting in the mold cavity. The flow coefficient μ typically ranges from 0.3 to 0.7 depending on mold conditions, metal characteristics, pouring temperature, and gating system configuration.

3.1.2 Cross-Sectional Area Ratio Design Method

For gating systems in steel castings, the ratio among cross-sectional areas—e.g., A_直 : A_横 : A_内—is typically prescribed based on experience. For a three-element system (sprue, runner, ingate), the hydrostatic pressure head at the ingate is given by:

$$h_{p} = \frac{k^2}{1+k^2} H_{p}$$

For a four-element system (sprue, runner, cross-runner, ingate), the corresponding expression is:

$$h_{p} = \frac{k_1^2}{1 + k_1^2 + k_2^2} H_{p}$$

where k₁ = A_直/A_横 and k₂ = A_直/A_内. Once h_p is known, the ingate area can be obtained from the orifice formula:

$$A_{\text{gate}}=\frac{G_L}{\mu \rho_L t \sqrt{2 g h_{p}}}$$

3.1.3 Weight–Velocity Calculation Method for Steel Castings

The weight–velocity method is the most widely used approach for gating system design of steel castings when a stopper-rod ladle is used. The process involves three main steps:

Step 1: Determine pouring time. Depending on the total weight of the steel casting:

For G_L ≤ 15 t:

$$t = S_1 \sqrt{G_L \delta}$$

For G_L > 15 t:

$$t = S_2 \sqrt{G_L}$$

Here, δ (mm) is the average wall thickness of the steel casting, and S₁ and S₂ are wall-thickness coefficients given in Tables 2 and 3, respectively.

Average wall thickness δ / mm	Steel weight GL / t
	< 25	25 – 40	40 – 60	> 60
1.0 – 6.0	1.3	1.2	1.1	1.0
> 6.0	1.4	1.3	1.2	1.1

Note: For simple steel castings with low technical requirements, S₁ may be increased by 0.1–0.2; for large thin-wall castings or those with stringent quality requirements, S₁ may be reduced by 0.1.

Relative density of steel casting ρ相 / g·cm⁻³	Wall-thickness coefficient S2
	< 1	1 – 2	2 – 3	3 – 4	4 – 5	> 5
Steel weight 10 – 50 t	1.2	1.3	1.4	1.5	1.6	1.7
Steel weight > 50 t	1.1	1.2	1.3	1.4	1.5	1.6

Step 2: Determine the pouring rate. The required pouring rate is:

$$v = \frac{G_L}{t}$$

Because the stopper-rod opening cannot be fully controlled, the actual pour rate through the nozzle is set to approximately 1.3 times the minimum required rate:

$$v_{\text{nozzle}} = 1.3 v$$

The nozzle flow rate can be expressed as:

$$v_{\text{nozzle}} = \mu A_{\text{nozzle}} \rho \sqrt{2 g H_{0}} = 0.248 A_{\text{nozzle}} \sqrt{H_{0}}$$

where A_nozzle (cm²) is the nozzle cross-sectional area, μ ≈ 0.8, ρ ≈ 7.0 kg/dm³, and H₀ (cm) is the effective static pressure height of liquid steel in the ladle. Once v_nozzle is known, A_nozzle is computed and converted to a nozzle diameter.

Step 3: Determine the gating system cross-sectional areas. For the stopper-rod ladle, an open gating system is typically recommended. The following cross-sectional area ratios are widely adopted:

$$A_{\text{直}} : \sum A_{\text{横}} : \sum A_{\text{内}} = 1.0 : (1.8 \sim 2.0) : (1.0 \sim 2.0) : (2.0 \sim 2.5)$$

where A_直, A_横, A_内 are the sprue, runner, and ingate total cross-sectional areas, respectively.

3.1.4 Steel Rising Velocity Validation

For large steel castings, it is essential to validate the liquid steel rising velocity within the mold cavity:

$$v_{L} = \frac{h_C}{t}$$

The minimum values of the rising velocity for steel castings are summarized in Table 4.

Casting weight / t	Complexity of steel casting
	≤ 5	5 – 15	15 – 35	35 – 65	65 – 100	> 100
Complex	25	20	16	14	12	10 mm/s
Medium	20	15	12	10	8	7 mm/s
Simple	15	10	8	6	5	4 mm/s

For typical pouring nozzle diameters, Table 5 lists the average steel pouring velocities.

Nozzle diameter / mm	30	35	40	45	50	55	60	70	80	100
Pouring velocity / kg·s⁻¹	10	20	27	42	55	72	90	120	150	195

3.2 Classification and Design Characteristics of Dedicated Gating Systems

For steel castings, I have developed two distinct design architectures, which can be combined to characterize any gating system:

• Wireframe vs. Solid: Wireframe systems contain only the skeleton (curves and profiles) of the gating system; cross-sectional shape is applied later to generate solids. Solid systems use standard parts that are already fully solid and ready for assembly.
• Incremental vs. Direct-load: Incremental systems require step-by-step loading of components; the complete gating system is only formed after several steps. Direct-load systems load a complete, fully assembled gating system in one operation.

These design types influence the number of standard parts, file sizes, design cycles, and user experience. For example, an analysis of the automatic gating system reveals why the wireframe–incremental approach was selected:

• The automatic gating system can have three types (工字型/万字型/环形), each allowing multiple ingates (up to 12), up to three tiers, and three cross-sectional shapes. If designed as complete solid templates, this would require 2,268 distinct standard parts, which is impractical.
• By using a separate runner–gate wireframe combined with a cross-section profile, only 34 templates are needed—far more compact.
• The wireframe–incremental approach also greatly reduces assembly operations (from 39 to a maximum of 6), making the system more efficient and less error-prone.

3.3 Standard Parts Design for Gating Systems

3.3.1 Automatic Gating System (Wireframe Type)

Figure 2 illustrates the standard parts for the automatic gating system—left to right: a runner–gate wireframe (e.g., an annular ring with four trapezoidal ingates), a cross-section profile, and a sprue guide line. The runner–gate wireframe is fully parametric; the ingate angles, radii, lengths, and position angles can be adjusted arbitrarily. Characteristic design principles include:

• Wise use of reference planes and axes.
• Straightforward and dimensionally well-constrained sketches.
• Parameter names that are concise, readable, and contain system identifiers to prevent cross-system conflicts.
• Wherever possible, use the minimum number of features to keep file sizes small.

3.3.2 Pipe–Elbow Gating System (Solid Assembly Type)

This system relies on ceramic composite pipe fittings (tees, crosses, elbows) commonly used in steel castings production. The standard parts are dimensioned based on available ceramic tube sizes. The assembly process requires sequential steps, hence the solid–incremental classification. Attribute identification is crucial since multiple identical standard parts may be assembled in the same working part.

3.3.3 Dual-In-Gate Gating System (Solid Direct-Load Type)

The dual-in-gate gating system for steel castings features a complex, streamlined runner design that minimizes flow separation and undesirable turbulence. The runner geometry involves both planar and spatial sweep surfaces, stitch operations, patch faces, and complex fillet networks. Because of the high degree of integration among the components, this system is necessarily developed as a single solid template loaded in one step—solid–direct-load classification.

3.3.4 Custom Gating System

To allow future expansion, a custom gating system was developed. This module supports two modes: one for assembling user-designed standard pipe fittings (similar to pipe–elbow), and another for directly loading user-designed complete solid gating systems. This makes the module extensible for new steel castings process designs without modifying the core code.

4. Function Implementation and Application

4.1 Dedicated Pump-Type Gating System Implementation

4.1.1 Automatic Gating System

The menu structure of the 3D Casting Process CAD system is shown in Figure 3. Key menus include Extract Part Information, Casting Process Analysis, Automatic Gating System, and Manual Gating System.

To demonstrate the workflow, consider a disk-shaped steel casting imported into UG. Clicking Extract Part Information opens a dialog to select material, set the process yield, and pick the casting solid. The system automatically derives the bounding box dimensions (using UF_MODL_ask_bounding_box), volume, mass, and estimated total pouring weight. The interface is shown in Figure 4.

Next, the average wall thickness of the steel casting is entered in the process design dialog. The system calculates pouring time, pouring rate, nozzle flow rate, and the recommended cross-sectional areas for the sprue, runner, and ingate using the weight–velocity method equations described in Section 3.1. In addition, the user may select to fix the nozzle aperture—in which case the other areas are computed backward from it—or to keep it free, in which case the nozzle diameter is optimized. The calculation interface is shown in Figure 5.

After the casting process (including risers, chillers, and other elements) is designed, the user proceeds to the gating system layout. The design process for a bottom-gated, single-tier annular gating system for steel castings is as follows:

1. Lay out the runner–gate wireframe. Select the runner type (工字型, 万字型, or 环形), the number of ingates (1–12), the filling location (top, parting, bottom), and enter initial dimensions. The system loads the wireframe template at its default position.
2. Adjust the wireframe. The Adjust Size panel allows the user to modify any parameter—length, width, inner/outer diameter, angle—by editing the displayed value. The Position panel allows translation along the coordinate axes or point-to-point displacement.
3. Set the sprue. In the Sprue Setting panel, the user chooses the number of sprues (1, 2, or 3), specifies the sprue height, and clicks on the desired position in the graphics window to place the sprue guide line.
4. Generate solid runners and ingates. In the Cross-Section Selection dialog (Figure 10), the user selects the cross-sectional shape (rectangular, trapezoidal, or round) for the runner and ingate, sets the alignment mode, specifies the nominal dimensions, and optionally selects the recommended values from the database. The sprue diameter is also specified.
5. Place a pouring cup. Enter the pouring cup height and click to form the pouring cup.
6. Merge all parts. The complete gating system for steel castings is then formed by unioning the runners, ingates, sprue, pouring cup, and sprue well, as illustrated in the resulting model.

Key operations implemented through UG/Open API include:

• UF_PART_import() for loading templates;
• UF_OBJ_delete_object() and UF_OBJ_delete_array_of_objects() for deletion;
• UF_MODL_transform_entities() for translation and rotation;
• UF_EVAL_initialize(), UF_EVAL_evaluate(), and UF_EVAL_free() for curve evaluation during assembly;
• UF_ATTR_assign(), UF_ATTR_find_attribute(), and UF_ATTR_read_value() for object attribute management.

4.1.2 Manual Gating System

Although the automatic gating system covers most standard configurations, flexibility for non-standard layouts is necessary. The manual gating system module addresses this need. Its initial interface (Figure 12) again offers a cross-sectional area calculator based on the weight–velocity method, along with controls for the main gating system elements. The user creates runner–gate wireframe curves directly in UG (using sketch tools, reference planes, etc.), then clicks Create Runner, Create Gate, or Create Sprue to select the guide curve(s) and generate the solid elements by sweeping the chosen cross-section along the curve. After the solids are generated, their dimensions and positions can be further adjusted. This manual workflow makes it possible to design arbitrarily shaped gating systems for steel castings while still leveraging the computational engine and the unification of cross-section shapes.

4.1.3 Functional Comparison with the Previous Approach

The new implementation reduces the number of transformation functions and the amount of code significantly compared with legacy code, while improving reliability. Table 6 summarizes the improvements at a high level.

Function	Previous method	New method
Transformation	uf5942–uf5947 series requiring matrix setup	UF_MODL_transform_entities()
Deletion	Single object per call	Batch deletion via UF_OBJ_delete_array_of_objects()
Expression conflict	Suffix-only	Prefix + suffix naming

4.2 Dedicated Pump-Valve-Type Gating System Implementation

4.2.1 Pipe–Elbow Gating System

The pipe–elbow gating system is used extensively for steel castings valves and pumps due to the availability of ceramic tube parts. The main interface is shown in Figure 4-16. It is divided into two groups: single parts (tee, cross, elbow, reducing cross) and pre-assembled parts (e.g., tee plus one or two elbows, cross plus two elbows, cross plus tee). The “Calculate Gating Ratio” option computes the ratio of the total ingate area to sprue area and reports the value as a quantitative indicator of the gating system’s flow behavior.

As an example, the loading process for a standard tee is as follows:

1. Choose the tee size from the dropdown list.
2. Select the placement point (using the point constructor).
3. Select the placement plane (using an existing planar face or reference plane).
4. Click Load to import the standard part and place it at the specified position.

Since the same tee type may be loaded multiple times, a list box tracks all loaded instances. Each loaded part receives a unique identification attribute (via UF_ATTR_assign). The user can select any entry in the list—this highlights the corresponding part in the graphics window—and then adjust its size, translate it, rotate it, or delete it entirely. The size adjustment interface (Figure 4-18) displays a bitmap indicating which parameter is which, making the dialog self-explanatory. The displacement interface (Figure 4-19) supports two forms of translation: incremental or point-to-point, and rotation with an axis-angle definition.

The pipe–elbow system is particularly suitable for large steel castings where the gating system may consist of dozens of ceramic parts. The time saved compared with manual modeling is considerable, and the automation of standard part library management greatly reduces errors.

4.2.2 Dual-In-Gate Gating System

The dual-in-gate gating system for steel castings is a streamlined, low-turbulence design. Its standard part is a complex solid model comprising the sprue, a runner that curves and tapers in space, and two diverging ingates. Loading the dual-in-gate system is very simple:

1. Select the standard part size (there are several standard sizes).
2. Use the point constructor to define the placement point.
3. Select the placement vector (usually a straight edge or an axis) and the horizontal alignment.
4. Click Load.

The system automatically positions the entire gating system and checks the placement validity by investigating the selected geometry. After loading, the user can adjust dimensions, transform position, delete the part, or compute the current process yield (casting weight divided by the total poured weight). The standard part itself is designed with careful attention to parametric design principles. The runner cross-section is formed by sweeping along a multi-section curve network; later the ingate region is attached using sewing and patch operations.

4.2.3 Custom Gating System

The custom gating system provides extensibility. The initial interface (Figure 4-23) offers two categories: pipe-like custom parts and direct-load custom parts. Each category supports two operations:

• Set Standard Parts: Allows the user to browse for a UG part file, import it into the standard part database, and register it as an available standard part. Existing registered custom parts can also be removed or renamed.
• Add Standard Parts: Allows the user to select a standard part from the custom library, define the placement point and plane, load it into the current working part, and further adjust, delete, or query its process yield.

This modular approach ensures the system can adapt to new proprietary gating system configurations for steel castings without additional programming.

4.3 Application Workflow for Steel Castings Production

To verify the developed modules, I applied them to representative steel casting models. The overall workflow for using the system in a production environment is as follows:

1. Import the 3D solid model of the steel casting (e.g., a pump casing or valve body).
2. Extract the casting information—density (selected from material database), dimensions, volume, mass, and total steel weight required.
3. Determine the process parameters—average wall thickness, whether the nozzle area is fixed—and compute the cross-sectional areas of the sprue, runner, and ingate.
4. Place the risers, feeders, and chills as required by the foundry practice; the riser system is independent of the gating system module.
5. Design the gating system:
   • For standard configurations, select the automatic gating system.
   • For non-standard layouts, use the manual gating system or the custom gating system with user-defined parts.
   • For pump-valve castings, select either the pipe–elbow assembly route or the dual-in-gate direct load route.
6. Inspect the final gating system—verify that all connections are properly aligned, dimensions are updated, and the system intersects the casting only at the intended ingate locations.
7. Save the gating system, optionally convert it to a 2D drawing, and release to the foundry.

4.3.1 Automatic Gating System Application

For a disk-shaped steel casting (outer diameter approximately 900 mm, height approximately 250 mm), a single-tier annular gating system with four trapezoidal ingates was selected. The automatic gating system is operated as follows:

• Load the casting model and extract parameters:

Using S₁ = 1.25 (default), the pouring time is:

$$t = 1.25 \sqrt{709.6 \times 22} = 1.25 \times 124.9 \approx 156.1 \ \text{s}$$

The pouring rate is:

$$v = \frac{709.6}{156.1} \approx 4.55 \ \text{kg/s}$$

The required nozzle flow rate is:

$$v_{\text{nozzle}} = 1.3 \times 4.55 = 5.91 \ \text{kg/s}$$

With an effective ladle head H₀ of 600 mm, the nozzle area becomes:

$$A_{\text{nozzle}} = \frac{5.91}{0.248 \times \sqrt{60}} = \frac{5.91}{1.921} \approx 3.08 \ \text{cm}^2 \Rightarrow d_{\text{nozzle}} \approx 19.8 \ \text{mm}$$

With a cross-sectional area ratio of 1.0 : 1.9 : 1.4 : 2.2 for sprue : runner : ingate, the total gate area is:

$$A_{\text{gate}} = \frac{2.2}{1.0} \times 3.08 = 6.77 \ \text{cm}^2$$

Distributed over four ingates, each ingate area is ≈ 1.69 cm². The system, shown in Figures 4-10 and 4-11, was generated directly. In the final step, a pouring cup was added and all bodies were merged.

4.3.2 Pipe–Elbow Gating System Application

For a pump valve body steel casting of approximately 750 kg, a bottom-gating arrangement with six ceramic elbows and three tees was chosen. The assembly process is as follows:

1. Load the end elbow (90° direction change) onto the pouring basin outlet.
2. Load a straight tube segment to reach the sprue location.
3. Load a concentric reducer (not shown) to step down from the sprue diameter to the runner diameter.
4. Load a 45° elbow to redirect the flow into the horizontal runner plane.
5. Load a tee to split the flow into two runners.
6. At each runner end, load a 90° elbow to connect to the ingates.

Because each component is a standard part from the library, the total assembly time was under 10 minutes. The “Calculate Gating Ratio” function reported a value of 2.05, which lies within the recommended range for open systems. This configuration was subsequently approved by the foundry engineer.

4.3.3 Dual-In-Gate Gating System Application

For a valve body steel casting of 320 kg with a complex parting line, a dual-in-gate system was selected to ensure smooth filling. The standard part was loaded in one step by picking the sprue top center, the vertical axis (against a reference line) and the ingate plane. The system automatically aligned the two ingates with the mold parting surface. The user then adjusted the sprue height from 220 mm to 180 mm and re-verified that the minimum distance to the nearest sand core was 15 mm. The final model is presented in the corresponding figure. This example demonstrates that even highly complex, streamlined gating systems for steel castings can be implemented without manual surface modeling, thanks to the direct-load standard part approach.

4.4 Summary of Achieved Benefits

The developed gating system modules offer a variety of benefits for steel castings production:

• Efficiency: Design time for a complete gating system is reduced from several hours to less than 15 minutes for typical cases.
• Consistency: All dimensions are calculated using consistent algorithms from established standards, reducing the variability caused by individual designer experience.
• Flexibility: The manual and custom modules allow adaptation to non-standard gating systems while preserving the parametric, database-backed infrastructure.
• Reliability: The improved transformation and deletion functions, combined with the prefix–suffix expression naming strategy, significantly reduce runtime errors during assembly operations.
• Extensibility: The custom gating system and the database-driven standard part library enable straightforward expansion to new company-specific or process-specific designs.

5. Conclusions and Outlook

5.1 Conclusions

In this research, I have developed two dedicated gating system modules for steel castings based on the UG platform, applying parametric design principles, template technology, and database technology. The following conclusions can be drawn:

1. The automatic gating system implements the weight–velocity calculation method to determine sprue, runner, and ingate areas for steel castings. It supports three types of runner–gate layouts (工字型, 万字型, and 环形) with 1–8 or 1–12 ingates, up to three-tier systems, and three gating positions. The manual gating system complements it by enabling the creation of custom wireframe geometries. Both modules enable loading, adjustment (dimension, translation, rotation), deletion, and cross-section modification.
2. The pipe–elbow gating system provides a library of standard ceramic pipe fittings (tees, crosses, elbows, and pre-assembled groups) that can be assembled step-by-step to form complete gating systems for steel castings. Standard parts are equipped with unique attribute identifiers, allowing easy selection, size updating, and deletion. The dual-in-gate gating system provides a single-step load of a complex streamlined gating system, which greatly reduces design effort and enables consistent quality. The custom gating system provides extensibility by allowing user-defined parts to be added to the library and then used in the same workflow.
3. By comparing the design of the two gating system families, I have proposed a classification scheme (wireframe vs. solid and incremental vs. direct-load) that serves as a practical guideline for future development of gating systems for steel castings. The classification helps developers choose the most suitable architecture based on the number of standard parts, the file size limit, the development period, the complexity of code, and the user experience.
4. The improved code—particularly the use of UF_MODL_transform_entities(), batch deletion, and the prefix–suffix expression naming strategy—reduces the code volume dramatically and improves runtime reliability when multiple standard parts are assembled in a single working part.

5.2 Future Work

Although the developed system significantly improves design efficiency, several areas merit further enhancement:

Improvement of parameter accuracy: The accuracy of the calculated cross-sectional areas depends on the accuracy of the input parameters—especially the process yield. The process yield is currently estimated from empirical formulas. A verification mechanism, such as simulation-based solidification analysis, could be integrated to automatically correct the estimated yield values. Higher accuracy in these parameters would permit the system to become even more automated, as users would rarely need to override the recommended values.

Deepening automation: In the future, the gating system module could be integrated with casting process simulation software (e.g., ProCAST, MAGMASOFT). The simulation results—filling time, flow velocity, and solidification temperature gradient—could feed back into the design module, and the system could automatically iterate the design to achieve optimal filling performance for steel castings. Furthermore, automatic generation of the gating system layout based on the casting geometry (e.g., using a rule-based algorithm) would be possible by extracting more geometric and topological information from the part model.

Moving toward knowledge-based engineering: The current modules use algorithms and databases extensively, but a more advanced expert system that captures the empirical knowledge of veteran foundry engineers—including rules for runner orientation, avoiding direct metal impingement on cores, and adjusting for specific steel grades—would bring the system closer to full intelligence.

Extending to other alloy systems: The methodology developed here is not limited to steel castings; with minor modifications to the coefficient tables and additional validation, the same architecture could be adapted for aluminum, copper-base, and ductile iron castings, broadening the impact of this work.

In summary, the dedicated gating system developed in this thesis meets both the casting standards and the specific needs of the partner enterprises. It dramatically improves the efficiency of process engineers and shortens the process design cycle, thereby offering significant practical value and promising prospects for wider application in the steel castings industry.