Development of a CAD System for Sand Casting Process of Shell Parts and Rapid Mold-Making Experiments

In modern manufacturing, the reduction of sand casting defects remains a critical challenge for foundries. Traditional trial-and-error methods are time-consuming and costly. This article describes my work on developing a specialized CAD system for the sand casting process of shell-like parts, built upon the UG/NX platform. The system integrates parametric design, database management, and three-dimensional modeling to assist casting engineers in making reliable process decisions. I also conducted rapid prototyping experiments on a fire hydrant cover to validate the entire workflow from CAD model to physical pattern. Throughout the study, I paid special attention to how the system helps minimize sand casting defects such as shrinkage, porosity, gas holes, and sand inclusion.

The application of CAD technology in foundry engineering has evolved from simple two-dimensional drafting to intelligent three-dimensional process design. However, the secondary development of CAD software for specific casting processes is still lagging. To address this, I developed a casting process CAD system for shell-type parts using UG, Visual C++ 6.0, and Microsoft Access 2000. This system covers the main stages of sand casting process design, including process parameter determination, riser design, and gating system design. The system is designed to be modular, parameterized, and user-friendly for casting engineers. By embedding casting knowledge into the software, the system notably reduces the occurrence of sand casting defects in actual production.

In this article, I first discuss the overall system architecture and key enabling technologies. Then, I describe the implementation of the system in the UG environment, followed by detailed explanations of the design modules for process parameters, risers, and gating systems. A real application example on a fire hydrant cover is presented to demonstrate the effectiveness of the system. Finally, I report on rapid prototyping experiments that convert the CAD model into a physical casting pattern using the LOM technique, thereby completing the CAD/CAM/RPM integration pipeline.

1. Introduction and Background

Castings are fundamental components in many industrial sectors, and the sand casting process remains one of the most versatile and economical methods for producing metal parts. Nevertheless, sand casting defects such as shrinkage cavities, gas porosity, sand inclusions, and cold shuts are common issues that adversely affect product quality and increase production costs. Traditional process design depends heavily on the experience of foundry engineers and often requires multiple trial runs to achieve a defect-free casting. This iterative process is not only expensive but also slows down product development.

The rapid evolution of computer-aided design (CAD) has opened new opportunities to improve casting quality. Advanced 3D CAD systems allow engineers to visualize the casting geometry, compute key physical properties, and simulate the filling and solidification behavior. However, to truly minimize sand casting defects, a dedicated casting process CAD system is necessary—one that incorporates casting-specific rules, calculations, and design standards. Such a system should assist engineers in making sound decisions about process parameters, riser dimensions, gating system layouts, and mold design.

My research aims to develop a three-dimensional casting process CAD system for shell-type parts, which are widely used in valves, pumps, and fire-fighting equipment. The system is developed as a secondary application on the UG NX platform, taking advantage of its powerful solid modeling and assembly capabilities. By integrating parametric design, a database of casting parameters, and interactive user interfaces, the system streamlines the process from the original part model to a complete casting design with risers and gating channels. The ultimate goal is to reduce the occurrence of sand casting defects in real production.

2. System Development Platform and Overall Design

2.1 Selection of the Development Platform

When choosing a platform for secondary development, I considered several factors: the functionality of the base CAD system, the openness of its application programming interface (API), the availability of a broad user community, and the support for various hardware configurations. After careful evaluation, I selected UG (Unigraphics) as the host system because it is a robust CAD/CAE/CAM package with excellent solid modeling, freeform surface creation, and assembly management capabilities. Moreover, UG provides several development tools, including UG/Open API (the C language interface), UG/Open++ (the C++ interface), UG/Open MenuScript, and UG/Open UIStyler. These tools enable seamless integration of custom programs with the native UG environment.

The development environment consisted of UG NX 3.0, Microsoft Visual C++ 6.0, and Microsoft Access 2000. The database stores casting process parameters such as machining allowances, shrinkage rates, pattern taper angles, and riser dimensions. Using Visual C++ together with UG/Open API allowed me to create efficient algorithms for geometric calculations, while the database kept the system data-driven and easy to maintain.

2.2 Requirements Analysis

Before coding, I performed a thorough analysis of the traditional sand casting process design workflow. In conventional practice, a designer must read the part drawing, analyze the casting structure, choose the molding method, determine the parting line, select process parameters, design the gating system, design risers, and finally generate the process drawing. These tasks can be divided into several functional modules:

  • Product model input and preparation
  • System initialization and project management
  • Process parameter design (machining allowance, shrinkage, taper, minimum wall thickness, minimum casting holes)
  • Riser system design
  • Gating system design

In addition to these calculation and design functions, the system must allow users to interactively select faces, edges, and solid bodies on the three-dimensional model. It also needs to create new solid features, such as adding machining allowance to specific faces, filling holes, and creating riser bodies. The system should operate seamlessly inside the UG environment, so that users can switch between custom functions and native UG commands without interruption.

2.3 System Architecture

I adopted a modular architecture to keep the system flexible and extensible. The main system consists of five sub-modules: product model input, system initialization, process parameter design, riser design, and gating system design. The modules communicate through a shared database that stores design data and intermediate results. This modularity simplifies debugging and allows easy addition of new modules in the future, such as sand core design or cooling channel design. The overall structure is shown in the following conceptual diagram, which I used as a blueprint during development.

The above image illustrates typical sand casting defects that are commonly encountered in foundry practice. The system I developed aims to predict and avoid these defects by providing systematic design calculations and by following proven casting guidelines.

3. Key Technologies in the System

3.1 Parameterized Design

Parameterization is at the core of the system. By representing the geometric features of the part and the casting equipment with parameters, the system can quickly generate and modify three-dimensional models. For example, when adding machining allowance, the user selects a face, and the system computes the appropriate allowance value from the database. The system then offsets the selected face along its normal direction by the allowance value, effectively creating a new solid. This operation is driven entirely by the parameter value, which eliminates the need for manual re-drawing.

In the riser design module, parameterization enables the automatic creation of user-defined risers. The user inputs the riser diameter, height, neck width, and other dimensions. The program calls a sequence of modeling functions to construct the riser at a specified location. Since all dimensions are parameters, the user can rapidly iterate to find an optimal design that balances feeding efficiency with yield.

3.2 Development Tools and Integration

The system uses UG/Open API and UG/Open++ for three-dimensional geometry operations. UG/Open API provides low-level functions for creating and manipulating objects, while UG/Open++ offers a more object-oriented interface. I combined these two approaches to take advantage of both flexibility and code compatibility.

For the user interface, I used UG/Open UIStyler to build interactive dialog boxes. UIStyler offers a WYSIWYG editor with a rich set of controls, including real-valued input fields, integer input fields, radio buttons, checkboxes, list boxes, etc. The dialogs are saved as .dlg files, and the generated C code provides callback functions that I customized to perform the desired operations. The menus and toolbars were created using MenuScript, a script language that lets the developer modify the UG main menu structure. My custom menu adds a “Sand Casting Process” item that contains sub-items for loading models, designing risers, and designing gating systems, as illustrated in the system interface description.

3.3 Database and Data Access

I built a relational database using Microsoft Access 2000 to store the following categories of data:

Data Category Content
Process parameters Minimum casting wall thickness, minimum cast hole diameter, pattern taper, shrinkage rate, machining allowance
Riser standards Riser type, riser number, riser modulus, diameter, height, weight
Gating system Standard ingate sizes, runner sizes, sprue sizes, area ratios

To access the database, I used Data Access Objects (DAO) through Visual C++. The application first loads a database interface, then queries the relevant records when the user requests a value. The database can be updated easily by the foundry engineer to reflect new standard series or company-specific rules. This data-driven design is crucial for minimizing sand casting defects because it ensures that process parameters conform to established best practices.

4. Implementation in the UG Environment

4.1 Development Environment Setup

Setting up the development environment was the first practical step. In UG, I changed the default unit from inches to metric by editing the ugii_env.dat file, replacing the default English template with the metric template. I then created a user-defined development directory named ugapi containing two subfolders: application (for .dlg and bitmap files) and startup (for menu scripts and toolbar files). Finally, I set the Windows environment variable UGII_USER_DIR to point to this directory so that UG loads the custom menus at startup.

In Microsoft Visual C++ 6.0, I installed the UG/Open AppWizard by copying the appropriate template files into the VC directory. If this is not done, one can also create an empty Win32 DLL project and manually add the libraries libufun.lib and libugopenint.lib to the linker settings. The include directories must be set to the UG/Open folder so that the required header files can be found.

4.2 User Interface Design

I used UIStyler to create a series of dialog boxes for various design tasks. For example, the process parameter dialog allows the user to select a casting alloy (e.g., gray cast iron), and the program automatically displays the recommended minimum wall thickness and minimum cast hole diameter. If the part contains holes smaller than the threshold, the user can invoke the “fill hole” function, which creates cylindrical bodies to plug these openings. This is an effective way to avoid sand casting defects such as misruns or hot tears caused by thin-walled holes.

The menu structure was defined in a MenuScript file named mold.men. This file inserts a “Sand Casting Process” menu before the Help menu. Under this menu, there are buttons for loading the part model, designing shell-type parts, designing axis-type parts, and designing disk-type parts. The actions point to dynamic link libraries (DLLs) that implement the corresponding functions. Because the menu script is loaded at UG startup, the integration is seamless.

4.3 Main Program Framework

The main entry point of a UG application is the ufsta() function, which is called when the DLL is loaded. In this function, I initialize the UG environment using UF_initialize(), then register the dialog callbacks using UF_MB_add_styler_actions(). After that, I call UF_terminate() to clean up. The following simplified code shows the pattern used:

extern void ufsta(char *param, int *retcode, int rlen)
{
    int error_code = 0;
    if ((error_code = UF_initialize()) != 0)
        return;
    if ((error_code = UF_MB_add_styler_actions(actions)) != 0)
    {
        char fail_message[133];
        UF_get_fail_message(error_code, fail_message);
        printf("%s\n", fail_message);
    }
    UF_terminate();
    return;
}

For the feature recognition functions, I used the UG/Open API calls such as UF_MODL_ask_edge_feats(), UF_MODL_ask_face_feats(), and UF_MODL_ask_face_edges(). These functions identify which features contain a selected face or edge. For interactive selection, I used UF_UI_select_with_class_dialog(), which returns a list of selected object tags. These tags are then passed to geometric analysis routines to compute volumes, areas, and other characteristics.

4.4 Database Connectivity

To bridge the CAD environment and the Access database, I wrote a DLL wrapper that exposes data access functions. The UG application can call these functions through the exported interface. A typical code snippet for a data query is:

// C++ code using DAO
CDaoDatabase db;
db.Open("C:\\ugapi\\casting.mdb");
CDaoRecordset rs(&db);
rs.Open(AFX_DAO_USE_DEFAULT_TYPE, "SELECT * FROM RiserStandard");
while (!rs.IsEOF()) { ... rs.MoveNext(); }

The database communication occurs inside callback functions for dialog buttons. For example, after computing the required riser modulus, the program queries the database for a standard riser with a modulus greater than or equal to the computed value. This information is then displayed to the user, and once confirmed, the program constructs the three-dimensional riser model automatically.

5. Development of the Casting Process CAD System

5.1 System Initialization

At the beginning of a new casting design, the system initializes a project that contains a dedicated database and a graphics directory. The user enters the part name, part number, material, designer, and date. Then the system copies the original part model into the project folder and loads it into the UG environment. Subsequent design operations reference this model, and all intermediate results are saved in the project database.

5.2 Determination of Process Parameters

Several critical process parameters must be determined correctly to avoid sand casting defects:

5.2.1 Minimum Wall Thickness and Minimum Cast Holes

The program traverses all cylindrical faces of the part to identify holes. For each hole, it computes the diameter and length. If the hole diameter is smaller than the recommended minimum cast hole diameter for the selected alloy, the system flags it as a hole that should not be cast. The user then selects the hole and the system creates a cylindrical fill body to block it. The recommended values are stored in the database.

5.2.2 Parting Surface

The parting surface selection has a major influence on mold complexity and casting quality. I did not automate the parting surface selection, but I provided interactive tools to help the engineer visualize possible parting lines and draft directions. The system can calculate the minimum required draft angle based on the selected parting surface and the part geometry, thereby reducing the risk of damage to the mold and associated sand casting defects.

5.2.3 Pattern Taper

For every face perpendicular to the parting direction, a taper must be added. The program identifies all such faces by evaluating the face normal and the user-specified draft vector. The user is then guided to select the datum point and the amount of taper. The system modifies the three-dimensional geometry to add the draft, using either additive or subtractive material. The correct taper ensures clean mold release and prevents the tearing of sand, which is a common source of sand casting defects.

5.2.4 Casting Shrinkage

The linear shrinkage rate is used to scale the pattern relative to the casting. The system provides recommended shrinkage values for different alloys. For example, gray cast iron typically has a shrinkage rate of about 1%. The UG scaling operation can be uniform or non-uniform, allowing the engineer to adjust for complex casting geometries. Scaling the model by the appropriate factor compensates for liquid and solid contraction, directly reducing the likelihood of sand casting defects caused by dimensional errors.

5.2.5 Machining Allowance

The machining allowance is added to all surfaces that require subsequent machining. The program identifies candidate machining surfaces (planes, cylinders, cones) and requests the user to select them one by one. The basic dimension is the maximum of either the dimension of the selected face or its distance to the machining datum. The allowance is then retrieved from the database. The system supports two methods for adding material: extruding in a specified direction, or offsetting along the face normal. The resulting machining allowance is displayed in a distinct color, making it easy to inspect.

5.3 Riser Design Module

The riser design module is central to the prevention of shrinkage porosity, one of the most severe sand casting defects. The design follows the modulus method, which is based on Chvorinov’s rule. The modulus \(M\) of a solid body is defined as the ratio of its volume \(V\) to its cooling surface area \(S\):

$$M = \frac{V}{S}$$

For a casting body that is in contact with a mold, the effective heat transfer area must exclude the surfaces that are not exposed to the mold (i.e., the interface where a riser neck would be attached). Thus, the effective modulus for a casting section is:

$$M = \frac{V}{S – S_0}$$

where \(S_0\) is the non-riser cooling surface area (the area through which no heat is extracted because it is connected to a riser). To design a sound riser, the riser modulus should be larger than the modulus of the casting section it feeds, usually by 10% to 20%.

In the riser design dialog, I first divide the casting into several sections based on its geometric features. For each section, the user selects the solid body and indicates which faces are in contact with the riser. The system then computes the volume, total surface area, and non-dissipative surface area. Using the above formula, the modulus of the key section is determined. If the modulus is greater than the critical modulus for the chosen alloy and mold type, the system suggests the appropriate riser design method.

For the practical riser design of ductile iron or gray iron castings, one must distinguish between the direct practical riser, the pressure-control riser, and the no-riser method. The selection criteria are based on the mold stiffness and the modulus of the casting. The table below summarizes the selection guidelines.

Method Mold Strength Modulus (cm) Application
Direct practical riser Low strength > 0.48 Feeds liquid shrinkage
Pressure-control riser Low strength 0.48–2.5 Feeds liquid shrinkage and some solidification shrinkage
No-riser / small safety riser High strength > 2.5 Relies on graphite expansion

In my practice with the fire hydrant cover, the computed moduli of the two sections were 12.58 mm and 4.87 mm. Since both moduli exceeded the critical threshold, I selected the pressure-control riser method. The second section (with a modulus of 4.87 mm) was identified as the key section, and the riser was designed accordingly.

For the actual riser geometry, the system offers two options: standard risers and user-defined risers. Standard risers are stored in the database. These include top risers and blind side risers with fixed dimensions. If a standard riser is selected, the program searches the database for a match and provides the riser dimensions. If no standard riser satisfies the requirements, the engineer can use the user-defined riser dialog. This dialog calculates the riser modulus from the input dimensions, allowing the user to adjust the size until the modulus criterion is satisfied.

Once the riser dimensions are confirmed, the system creates the three-dimensional riser model. For simple top risers, a parameterized program builds a cylindrical or tapered body. For blind side risers with complex shapes, the system loads a pre-built model from a graphical library. This library approach avoids excessive programming code and speeds up the design process. After creating the riser, I used the UG assembly function to position it at the desired location on the casting. The final assembly of the casting with riser system clearly shows how the risers are attached to the casting to provide liquid metal feed and to suppress sand casting defects.

5.4 Gating System Design Module

The gating system is another critical element in controlling metal flow and avoiding sand casting defects such as cold shuts, erosion, and gas entrapment. I implemented the gating design calculation based on the well-known Bernoulli equation for liquid flow. The cross-sectional area of the choke (minimum section) is calculated using:

$$F = \frac{G}{\rho \mu T \sqrt{2 g H_p}}$$

where \(F\) is the cross-sectional area of the choke (in cm²), \(G\) is the total weight of liquid metal poured (kg), \(\rho\) is the density of the liquid metal, \(\mu\) is the flow coefficient, \(T\) is the pouring time (s), \(g\) is the gravitational acceleration, and \(H_p\) is the effective pouring head height (cm).

In the system, the total weight \(G\) is determined from the sum of the casting weight, the riser weight, and the gating system weight. Since my system uses three-dimensional models, I can directly compute the casting volume and the riser volume. The pouring time \(T\) depends on the alloy and the pouring weight. For gray cast iron, the system uses the following empirical table:

Pouring Weight \(G\) (kg) Pouring Time \(T\) (s)
< 12 6–8
15 8
20 8
25 8
30 8
35 8
40 10
50 12

For ductile iron, the pouring time is calculated using the empirical formula:

$$T = 2.25 \sqrt{G}$$

The flow coefficient \(\mu\) depends on the number and shape of the gating components. Typical values used in this system are:

  • 0.76 for a two-component system (sprue and pouring cup only)
  • 0.58 for a three-component system (sprue, runner)
  • 0.48 for a complete system (sprue, runner, ingate)

The effective head \(H_p\) is determined from the sprue height and the location of the ingates:

$$H_p = H_0 – \frac{P^2}{2 C}$$

Here, \(H_0\) is the static head above the ingate, \(P\) is the height of the casting above the ingate, and \(C\) is the total height of the casting.

Once the choke area is known, the areas of the other gating components are computed using the specified area ratios. For a semi-closed system, the typical area ratios are \(F_{\text{ingate}} : F_{\text{runner}} : F_{\text{sprue}} = 3 : 8 : 4\). For an open system, the ratios might be \(1 : 0.7 : 0.4 : 0.7\). The interface asks the user to choose the system type and enter the ratios, and then it calculates each component area.

After the area calculation, the user proceeds to the design of each individual component. The ingate design dialog shows the user interfaces for standard ingate shapes. The system contains a database of standard ingate series based on the company’s production experience. The user selects a cross-section type (e.g., flat trapezoid, high trapezoid), and the system searches for the closest standard ingate that provides the required cross-sectional area. Once the dimensions are confirmed, the program creates the three-dimensional geometry. For curved ingates, the user can draw a spline path and the system sweeps the cross-section along the path.

Similarly, the runner and sprue design modules use the same philosophy. The system calculates the required section dimensions and creates the components in the assembly. The sprue design module also includes functions for creating the sprue well and the choke element. A complete gating system assembly is shown in the application example.

6. Application Example: Fire Hydrant Cover

6.1 Production Conditions and Technical Requirements

To validate the system, I used a fire hydrant cover that was produced in a foundry. The part is used to protect the top valve of a fire hydrant. Its material is gray cast iron HT100. The main dimensions are 238 mm × 238 mm × 140 mm, and the casting weight is approximately 5 kg. The casting is required to be free from shrinkage cavities, porosity, sand holes, slag inclusions, and other sand casting defects. The pouring temperature is controlled at 1400–1450 °C.

6.2 Three-Dimensional Modeling and Process Design

I started the design by launching UG NX 3.0 and selecting “Sand Casting Process” from the custom menu, then choosing “Shell Part” to load the part model. The system imported the solid model and displayed it in the graphics window. Next, I performed the process parameter design. The system identified the holes in the part and prompted me to fill those that were smaller than the minimum cast hole. After filling the holes, I defined the parting direction and parting surface. The system automatically analyzed the faces perpendicular to the parting direction, and I added the necessary pattern tapers. Then I applied the casting shrinkage of 1% using the UG scale function. Finally, I selected the top and side faces that required machining, and the system added the machining allowance with an offset dimension. The resulting casting model is shown in the following figure as a solid with the added features.

6.3 Riser Design for the Fire Hydrant Cover

I divided the casting into two major segments based on the geometry. The first segment had a volume of 209732 mm³ and a surface area of 166659 mm², giving a modulus of 12.58 mm. The second segment had a volume of 517825 mm³ and a surface area of 106162 mm², giving a modulus of 4.87 mm. Since both moduli are greater than 4.8 mm, I chose the pressure-control riser method. The second segment was the critical segment with a modulus of 4.87 mm. Using the riser design module, I selected a standard top riser from the database and confirmed its dimensions. The system then created the three-dimensional riser model. After that, I used the assembly commands to position the riser at the desired location on the casting. The assembly of the casting with the riser system is shown in the design. The riser was sized such that its modulus was sufficiently larger than the critical segment’s modulus, ensuring that solidification would proceed from the casting to the riser, thus preventing shrinkage-related sand casting defects.

6.4 Gating System Design

For this example, I selected a single-cavity mold with horizontal parting. The total weight of poured metal includes the casting, riser, and gating system. The system computed the casting volume and the riser volume, and I estimated the gating weight based on the preliminary layout. The pouring time was determined from the table for gray cast iron, and the flow coefficient was set to 0.48. The effective head was computed based on the sprue height and the ingate position. The resulting choke area was calculated as 3.21 cm². I then selected the semi-closed gating system with area ratios \(F_{\text{ingate}} : F_{\text{runner}} : F_{\text{sprue}} = 3 : 8 : 4\). This gave the runner area and sprue area accordingly.

After calculating the areas, I used the ingate design dialog to select a standard trapezoidal ingate whose size matched the required area. The system created the ingate solid model and positioned it. The sprue and runner were designed similarly. The complete gating system assembly is shown with the casting. The entire process is carried out within the UG environment, making it easy to check interferences and visualize the flow path.

6.5 Actual Production Validation

To verify the process design, the foundry produced a sample casting according to the designed mold. The resulting casting was inspected and found to be free from the critical sand casting defects. No shrinkage cavities or porosity were observed. The dimensional accuracy met the requirements. This successful validation confirms that the developed CAD system is both practical and reliable for shell-type sand castings.

7. Rapid Prototyping Experiment for the Casting Pattern

7.1 Rationale for Rapid Prototyping

In traditional sand casting, making a wooden matchplate or pattern is time-consuming and depends on skilled pattern makers. Rapid prototyping (RP) technology can directly build a physical pattern from the CAD model, significantly speeding up the product development cycle. The rapid pattern can then be used to create sand molds, allowing immediate pouring of trial castings. This approach also helps to identify and correct sand casting defects early in the design stage, before committing to expensive production tooling.

7.2 RPM Principles and Equipment Selection

Rapid Prototyping and Manufacturing (RPM) is based on the principle of layered manufacturing. A three-dimensional CAD model is sliced into thin cross-sections. A laser or deposition head selectively processes these layers one by one, building up the final geometry. Common RPM techniques include Stereolithography (SLA), Laminated Object Manufacturing (LOM), Selective Laser Sintering (SLS), and Fused Deposition Modeling (FDM). A comparison of these methods is given below:

Method Speed Accuracy Cost Complexity Part Size Material
SLA Fast High High Moderate Small-medium Photopolymer
LOM Fast Moderately high Low Simple Medium-large Paper, foil, plastic
SLS Slow Low Medium Complex Small-medium Wax, plastic, metal, ceramic powders
FDM Slow Low Low Moderate Small-medium Wax, plastic, low-melting metal

Given that the fire hydrant cover is a relatively simple shell part but requires good accuracy, I selected the LOM method. LOM uses paper coated with a heat-activated adhesive, which is inexpensive and provides adequate dimensional accuracy (about ±0.1 mm per 100 mm). The equipment used was the HRP-III rapid prototyping machine, manufactured by Wuhan Binhu Mechatronics Co., Ltd.

7.3 Process Study for the Model

The manufacturing workflow for the LOM pattern is shown in the following steps:

  1. Construct the three-dimensional CAD model of the casting pattern (including shrinkage allowance).
  2. Convert the model into the STL file format, which approximates the surfaces with triangles. In UG, this is done via the “File → Export → Rapid Prototyping” command.
  3. Slice the STL model into thin layers with a thickness of 0.1–0.2 mm.
  4. Feed the paper material into the LOM machine. A laser cuts the contour of each layer and also cuts cross-hatch grids in non-material areas to ease removal.
  5. After all layers are cut and bonded, the block is removed from the machine.
  6. Post-process the prototype: remove the excess material, sand the surfaces, apply adhesive to harden the paper, and finally coat with a protective paint.

The physical pattern created by this process is shown in the figures. The finished sample matches the CAD model closely. I measured the critical dimensions of the pattern and compared them with the original model dimensions. The results are summarized below.

Parameter Model Dimension (mm) Pattern Dimension (mm) Deviation (%)
Width W1 238 238.3 0.13%
Width W2 76 76.1 0.13%
Height h 140 140.2 0.14%

All deviations are below 0.2%, which is acceptable for sand casting patterns. The rapid prototyping experiment demonstrated that a complex casting pattern can be produced directly from the CAD model without any manual mock-up. This integration of CAD with RPM greatly accelerates the process of achieving a defect-free casting by allowing rapid iteration on the pattern geometry and the gating/riser design. The ability to produce a physical pattern quickly also facilitates inspection of the intended shape and helps in early identification of potential sand casting defects.

8. Conclusion and Outlook

In this project, I successfully developed a three-dimensional CAD system for the sand casting process of shell parts. The system is built on the UG platform using UG/Open API, UG/Open++, VC++ 6.0, and Microsoft Access 2000. It covers the essential steps of casting process design: system initialization, process parameter determination, riser design, and gating system design. The modular architecture makes the system flexible and easy to extend. The user interface is designed for casting engineers, using familiar terminology and logical workflows. The integration with the UG environment is seamless, allowing users to leverage the full power of the underlying CAD system.

The system’s main advantage is its ability to reduce sand casting defects through structured calculations and knowledge-based guidance. By applying the modulus method for riser sizing, the section-area method for gating design, and strict adherence to standard parameter tables, the system ensures that the final process design is robust and reliable. The application example of the fire hydrant cover proved that the system can handle real production parts. The actual casting was sound and free from shrinkage and gas defects.

I also explored the integration of CAD with rapid prototyping. The LOM technique was used to produce a physical pattern of the fire hydrant cover directly from the CAD model. The pattern dimensions deviated by less than 0.2%, which is suitable for sand casting. This experiment demonstrated a viable workflow for rapid mold making, connecting CAD, casting process design, and physical pattern fabrication. By combining these technologies, foundries can significantly shorten the product development cycle and improve quality without compromising on cost.

There are several directions for future work. First, the CAD system should be extended with modules for sand core design, chill design, and automatic process drawing generation. Second, the system should be linked with casting solidification simulation tools to predict sand casting defects such as shrinkage and porosity more accurately. Third, the database should be migrated to a network-based platform to facilitate data sharing and collaborative design. Finally, the rapid prototyping process could be improved by using higher-accuracy machines or alternative materials that are more resistant to high-temperature sand molding.

In conclusion, this study has provided a practical and integrated tool for the sand casting industry. The developed system reduces reliance on trial-and-error methods, promotes standardized process design, and directly contributes to the reduction of sand casting defects. With continuous improvement and further integration of simulation and manufacturing technologies, this system can become a valuable component of intelligent foundry manufacturing.

Scroll to Top