I began this work with a practical problem: shaft-type steel castings, especially heavy crankshafts, are difficult to design for sand mold casting because the designer must combine geometry, feeding, gating, solidification, and foundry experience in a single sequence. Manual design is slow, inconsistent, and highly dependent on individual experience. I therefore decided to build a computer-aided design system for shaft sand mold casting on top of a commercial three-dimensional CAD platform. The system was intended to support the complete sand mold casting design flow: three-dimensional solid modeling, material and unit definition, parting surface selection, process parameter assignment, gating system calculation, riser system calculation, and database queries for foundry parameters.
My central design choice was to use Pro/ENGINEER 2001 as the host CAD environment and C with Visual C++ 6.0 as the development language. I used Pro/TOOLKIT as the secondary development toolkit, MFC for dialog interfaces, DAO for database access, and Access-compatible database files for foundry data. This combination allowed me to create a sand mold casting CAD system that runs inside Pro/ENGINEER, uses the native solid model, and stores process knowledge in a structured database. The system is aimed at shaft sand mold casting, but the architecture can be extended to other casting families such as wheels, plates, and general prismatic parts.
1. Motivation for a Shaft Sand Mold Casting CAD System
Sand mold casting remains one of the most important manufacturing methods for large steel components. In sand mold casting, the mold is destroyed after each pour, so the process must be designed correctly the first time or the foundry pays a high cost in scrap, rework, and lost production time. Shafts and crankshafts are especially demanding because they contain thick journals, thin webs, abrupt section changes, and multiple thermal centers. These features create hot spots, shrinkage porosity, gas entrapment, and incomplete filling if the gating and riser systems are not properly designed.
I saw that a CAD system for sand mold casting should not merely draw a mold. It should encode the design logic used by foundry engineers. For a shaft sand mold casting, the system should help answer questions such as:
- What is the modulus of each section of the shaft?
- Where should the risers be placed?
- What is the required riser modulus for a sound sand mold casting?
- What pouring time gives a suitable steel rising speed in the mold cavity?
- What gating area ratios should be used for a top-gated, bottom-gated, or middle-gated sand mold casting?
- What machining allowance, shrinkage, draft angle, and fillet should be applied?
By embedding these questions into a CAD system, I could reduce the design cycle and make the sand mold casting process more repeatable. I also wanted the system to support later CAE simulation, because the output of a sand mold casting CAD system becomes the input for solidification and filling simulation.
2. Platform and Language Selection
Before writing code, I compared several commercial CAD platforms. The selection was not based only on modeling power. I considered secondary development capability, hardware requirements, database integration, user interface, cost, and compatibility with sand mold casting design. The comparison is summarized in Table 1.
| CAD platform | Strength | Weakness for this project | Secondary development support |
|---|---|---|---|
| AutoCAD | Widely used, strong two-dimensional drafting, low hardware demand | Weak true three-dimensional solid modeling and parameterization for complex shafts | Available, but less suitable for feature-based solid sand mold casting design |
| SolidWorks | Easy to use, good mid-range solid modeling, affordable | Less comprehensive for large assembly and advanced simulation integration | Available, but not as mature as Pro/TOOLKIT for this purpose |
| UG | Powerful CAD/CAM/CAE integration, strong machining | More complex to learn and heavier hardware requirements | Strong, but development overhead is higher |
| CATIA | Very strong surface and assembly capabilities | Cost and complexity are high for ordinary foundry use | Powerful, but not necessary for shaft sand mold casting |
| I-DEAS | Strong analysis and simulation heritage | Less common in small and medium foundries | Available, but integration path was less direct |
| Pro/ENGINEER | Parametric, feature-based, fully related solid modeling; strong secondary development toolkit | Non-Windows-native style in older versions, steeper learning curve | Pro/TOOLKIT provides direct database and menu access |
I chose Pro/ENGINEER 2001 because it had a mature parametric solid modeler, a fully related data structure, and a powerful secondary development toolkit. I also chose it because the CAD data could later be transferred to CAE simulation without rebuilding the geometry. For a shaft sand mold casting, this is important because the riser and gating components must be attached to the casting model and then exported for simulation.
For the programming language, I selected C and Visual C++ 6.0. Pro/TOOLKIT uses C calling conventions, and Visual C++ 6.0 provides an integrated development environment, MFC class libraries, DAO database classes, and a reliable compiler for Windows NT and Windows 2000. I could write the Pro/TOOLKIT application in C, and then use MFC dialogs for the user interface. Table 2 lists the selection criteria I used.
| Selection criterion | Requirement for shaft sand mold casting CAD | Result |
|---|---|---|
| System function | Feature-based solid modeling, assembly, parameter control | Pro/ENGINEER satisfies |
| Secondary development | Menu extension, dialog invocation, database access, model query | Pro/TOOLKIT satisfies |
| Programming environment | C/C++ compiler, MFC, DAO, DLL support | Visual C++ 6.0 satisfies |
| Hardware demand | Runs on ordinary engineering workstations | Acceptable for Pro/ENGINEER 2001 |
| Database integration | Store and query foundry process parameters | Access with DAO satisfies |
| Openness | Can export geometry for CAE and CAM | Pro/ENGINEER satisfies |
| User interface | Custom menus and dialogs inside the CAD environment | Satisfied through Pro/TOOLKIT and MFC |
3. Pro/ENGINEER Secondary Development Approach
I used Pro/TOOLKIT to extend Pro/ENGINEER. Pro/TOOLKIT provides an application programming interface that allows a C program to access Pro/ENGINEER objects and behavior. The naming convention follows a prefix-object-action pattern, so a function name begins with Pro, then the object, then the action. This made the API predictable once I understood the object model.
I considered synchronous and asynchronous modes. Asynchronous mode uses remote procedure calls and has lower interaction efficiency, so I rejected it for the main user workflow. Synchronous mode starts and stops under the control of the host application and communicates efficiently with Pro/ENGINEER. Within synchronous mode, I used two sub-modes:
| Mode | Behavior | Best use |
|---|---|---|
| DLL mode | Compiles Pro/TOOLKIT code into a dynamic link library that is loaded by Pro/ENGINEER | Final release and fast execution |
| Multiprocess mode | Compiles a separate executable that runs as a child process of Pro/ENGINEER | Debugging because Pro/ENGINEER does not need to restart each time |
During development, I used multiprocess mode. This saved a large amount of time because every small code change did not require restarting the entire CAD system. For release, I used DLL mode because it gives faster communication and a more integrated user experience. The registration file controlled the mode, the executable or DLL path, the text resource directory, startup behavior, and revision information.
I followed a general development sequence: write the Pro/TOOLKIT C application, create resource files, compile and link, register the application in Pro/ENGINEER, and run it from a custom menu. The basic framework can be generated in several ways. I compared the available methods in Table 4.
| Framework generation method | Description | Advantage | Disadvantage |
|---|---|---|---|
| MS-DOS command line | Use the provided makefile and nmake |
Simple and official | Less convenient for editing and debugging |
| Visual C++ console project | Create a Win32 console application and add Pro/TOOLKIT libraries manually | Uses Visual C++ IDE | Requires manual path and library configuration |
| MFC regular DLL using shared MFC | Create an MFC AppWizard DLL project and add Pro/TOOLKIT code | Allows direct use of MFC dialogs and classes | Requires careful registration and export handling |
I selected the MFC regular DLL method because it allowed me to use MFC dialogs directly. This was important for database forms, parameter input, and process selection. I added the Pro/TOOLKIT include paths and libraries, such as protoolkit.lib, prodev.lib, protk_dll.lib, and prodev_dll.lib, to the Visual C++ project. I then compiled the application and registered it inside Pro/ENGINEER.
Every synchronous Pro/TOOLKIT application must define two functions: user_initialize() and user_terminate(). The first is the initialization entry point. It registers menus, defines menu actions, and prepares the application for interaction. The second is the termination entry point. It cleans up when the application stops. I placed both in the main C++ source file and kept their names unchanged.
4. Menu and Interface Architecture
I designed the sand mold casting CAD system as a user-driven workflow inside Pro/ENGINEER. The main menu structure has three top-level groups: part type, casting type, and casting module. The part type group identifies whether the component is a shaft, wheel, plate, or another family. The casting type group selects sand mold casting, metal mold casting, or another process. The casting module group enters the detailed design functions for the selected family.
| Menu group | Purpose | Typical actions |
|---|---|---|
| Part type | Select or create a part family | Add, query, call, modify |
| Casting type | Select the casting process | Sand mold casting, metal mold casting, query, call |
| Casting module | Enter the detailed design module | Shaft, wheel, plate, and general modules |
| Material and units | Define material properties and units | Steel, density, shrinkage, unit conversion |
| Parting surface | Define the mold parting direction | Datum plane or section surface |
| Process parameters | Assign foundry allowances | Machining allowance, draft, fillet, shrinkage |
| Gating system | Design pouring channels | Pouring type, ingate number, area ratios |
| Riser system | Design feeding system | Feeding zone, modulus, riser type, riser size |
I created menu resource files with .mnu and .aux extensions. The .mnu file describes a complete menu, while the .aux file adds buttons to an existing Pro/ENGINEER menu. Because the main design work happens in Part mode, I added the casting menu to the Part menu bar. I used a three-line group format for each button: the internal button name, the on-line help text, and the alternate help text. The alternate help text allowed the interface to present short English prompts without changing the source code logic.
In the C code, I registered the menu file and the auxiliary file, then attached actions to the new buttons. A typical initialization sequence was:
ProMenuFileRegister("part", "part.mnu", &menu_id);
ProMenuAuxfileRegister("part", "part.aux", &menu_id);
ProMenubuttonActionSet("part", "CastCad", (ProMenubuttonAction)UserProCastCad, NULL, 0);
The custom action opened the main casting CAD dialog. From there, the user could move through the design sequence without leaving Pro/ENGINEER. This was important because the solid model, the process parameters, and the database queries all needed to remain connected. A separate application would have broken that connection.
5. Database Development for Sand Mold Casting
Sand mold casting design depends on many foundry parameters: machining allowance, shrinkage, draft angle, fillet radius, minimum rising speed, pouring weight rate, gating area ratios, riser modulus factors, and standard riser dimensions. I did not want these values hard-coded in the program because foundries vary in practice and standards change. I therefore built a database system that the CAD application can query and modify.
I selected Microsoft Access 2000 as the database platform because the data volume is moderate and Access is widely available in engineering offices. I used DAO through MFC to connect the database to the MFC dialogs. DAO provides objects such as CDaoDatabase, CDaoRecordset, CDaoTableDefInfo, and CDaoFieldInfo. I used these classes to open a database, run queries, display records in dialogs, and update records when the user changes a value.
| Database table | Key fields | Use in sand mold casting design |
|---|---|---|
| Machining allowance | Part dimension, surface type, allowance | Adds machining stock before casting |
| Shrinkage | Material, section size, shrinkage rate | Scales the pattern for solidification contraction |
| Draft angle | Surface height, draft angle | Allows pattern removal from the sand mold |
| Fillet radius | Section thickness, radius | Reduces hot spots and stress concentrations |
| Minimum rising speed | Casting height, wall thickness, speed | Checks filling stability in sand mold casting |
| Pouring weight rate | Nozzle diameter, ladle type, rate | Computes pouring time |
| Gating area ratio | Casting type, ratio set | Sets sprue, runner, and ingate areas |
| Riser standard size | Riser type, modulus, volume, weight | Selects standard risers |
| Riser factor | Riser type, feeding efficiency | Computes required riser modulus |
The interface between Pro/ENGINEER and the MFC dialogs was implemented through a DLL. The Pro/TOOLKIT executable used the spawn method to call the MFC application, and the MFC application exported functions that opened the dialogs. This arrangement allowed me to write the user interface in MFC while keeping the Pro/TOOLKIT logic in the CAD process. I also registered the database path in the resource file so the application could locate the Access file reliably.
For example, when the user selected a machining allowance query for the top surface of a shaft sand mold casting, the system opened a dialog with the relevant records. The user could accept a recommended value, modify it, add a new record, or delete an obsolete one. The same pattern was used for riser dimensions and gating area ratios. This made the sand mold casting CAD system a living tool rather than a fixed set of equations.
6. Shaft Sand Mold Casting Design Modules
I organized the shaft sand mold casting module into a sequence of sub-modules. The user starts with the three-dimensional solid model, defines material and units, selects a parting surface, assigns process parameters, designs the gating system, and designs the riser system. Each sub-module can query the database, perform calculations, and update the Pro/ENGINEER model.
6.1 Three-Dimensional Solid Modeling
The user can either create a new shaft model or call a similar shaft from the part family library. If a similar shaft exists, the user modifies its dimensions parametrically. If no similar shaft exists, the user builds the model directly in Pro/ENGINEER. For a crankshaft or stepped shaft, the main features are journals, webs, fillets, and end faces. I used parametric dimensions so that changes in journal diameter or web thickness propagate through the model.
The sand mold casting design then proceeds on the solid model. The system does not create a separate two-dimensional drawing first. This is a key advantage because the three-dimensional model can be used for volume calculation, modulus calculation, gating layout, riser placement, and later CAE simulation.
6.2 Material, Units, and Shrinkage
Before calculating the sand mold casting process, the user defines the material and units. I used a standard set of units: millimeter, tonne, and second. The material database stores density, thermal properties, and shrinkage characteristics. For steel castings, the shrinkage rate depends on carbon content, alloying elements, section size, and mold constraint. The system applies shrinkage by scaling the pattern geometry:
$$L_f = L_p (1 + s)$$
where Lf is the final pattern dimension, Lp is the part dimension, and s is the linear shrinkage rate. For a shaft sand mold casting, this scaling is applied to the pattern before gating and riser design.
6.3 Parting Surface
The parting surface determines the mold halves and the pouring position. For simple shafts, a datum plane through the axis may be sufficient. For crankshafts, the parting surface may be stepped or curved. I allowed the user to create a datum plane or a section surface. The system then uses that surface to define the mold split and to place the gating system. A good parting surface in sand mold casting reduces core complexity, improves pattern removal, and helps place the ingates at the lowest possible level when bottom gating is required.
6.4 Process Parameters
The process parameter module assigns machining allowance, draft angle, fillet radius, and shrinkage. These parameters are stored in the database and can be queried by material, section thickness, and surface type. Table 7 gives representative ranges I used.
| Parameter | Typical range for steel shaft sand mold casting | Design note |
|---|---|---|
| Machining allowance | 2 mm to 12 mm depending on surface and size | Larger on thick sections and rough surfaces |
| Draft angle | 0.5° to 2.0° | Depends on pattern height and sand strength |
| Fillet radius | 3 mm to 25 mm | Increases with section thickness |
| Shrinkage rate | 1.0% to 2.2% for steel | Depends on alloy and section restraint |
| Machining stock on hot spots | Additional 2 mm to 5 mm | Allows removal of surface defects |
6.5 Gating System Design
The gating system controls filling time, metal velocity, turbulence, and temperature distribution. For a steel shaft sand mold casting, I used the rising speed method as the main design check. The total pouring time is calculated from the total steel weight, the number of ladles, the number of nozzles per ladle, and the average pouring weight rate:
$$t = \frac{G}{N n v}$$
where t is the pouring time, G is the total weight of liquid steel, N is the number of ladles used simultaneously, n is the number of nozzles per ladle, and v is the average pouring weight rate. I then check the steel rising speed in the mold cavity:
$$v_L = \frac{C}{t}$$
where vL is the rising speed and C is the height of the casting in the pouring position. The rising speed must be high enough to prevent cold shuts, lap marks, and sand erosion, but not so high that turbulence and gas entrapment occur. The database stores minimum rising speed values as a function of casting height and section thickness.
After the pouring time and rising speed are acceptable, the system determines the gating area ratios. For steel sand mold casting, common ratios relate the sprue area, runner area, and ingate area. The user selects a gating type, such as top gating, bottom gating, or middle gating. The system then calculates the choke area and the remaining areas. Table 8 shows representative ratio sets I included.
| Gating type | Sprue : Runner : Ingate | Typical application in shaft sand mold casting |
|---|---|---|
| Top gating | 1.0 : 1.2 : 1.5 | Short shafts with low height and simple feeding |
| Bottom gating | 1.0 : 1.5 : 2.0 | Tall shafts where smooth upward filling is required |
| Middle gating | 1.0 : 1.3 : 1.8 | Crankshafts and stepped shafts with complex geometry |
| Step gating | 1.0 : 1.4 : 2.2 | Very tall or thick shafts needing controlled filling |
The gating design dialog lets the user enter the ladle nozzle diameter, the number of nozzles, the number of ingates, and the gating type. The system then calculates the pouring time, checks the rising speed, computes the choke area, and uses the area ratios to determine the runner and ingate areas. The user can adjust the result and query the database for standard channel shapes. Once accepted, the system creates the gating geometry in the Pro/ENGINEER model.
6.6 Riser System Design
The riser system must feed the slowest-solidifying regions of the shaft sand mold casting. I used the modulus method because it is practical for heavy steel castings and can be programmed cleanly. The modulus is defined as the volume-to-surface-area ratio:
$$M = \frac{V}{A}$$
where M is the modulus, V is the volume, and A is the heat-losing surface area. For a given casting, the solidification time is related to the modulus by Chvorinov’s rule:
$$t_s = B M^n$$
where ts is the solidification time, B is a mold constant, and n is an exponent typically close to 2 for many sand mold casting conditions. To ensure that the riser remains liquid longer than the casting section it feeds, the riser modulus must be larger than the casting modulus:
$$M_r = f M_c$$
where Mr is the required riser modulus, Mc is the casting modulus at the feeding location, and f is a riser factor. The factor depends on riser type and feeding efficiency. Table 9 shows typical factors I used.
| Riser type | Riser factor f | Notes for sand mold casting |
|---|---|---|
| Open riser | 1.2 | Easy to mold, but atmospheric pressure is not used |
| Blind riser | 1.3 | Better feeding efficiency, requires careful venting |
| Atmospheric riser | 1.1 to 1.2 | Good for heavy sections and long feeding distances |
| Side riser | 1.3 to 1.5 | Used when the top of the casting cannot be fed directly |
The system calculates the modulus of simple geometric elements using standard formulas. Table 10 lists the formulas I embedded.
| Geometry | Modulus formula | Use |
|---|---|---|
| Plate | $$M = \frac{abc}{2(ab+bc+ac)}$$ | Webs and flat sections |
| Cylinder | $$M = \frac{D H}{2(D+2H)}$$ | Journals and round sections |
| Sphere | $$M = \frac{D}{6}$$ | Nodular sections and hot spots |
| Long bar | $$M = \frac{ab}{2(a+b)}$$ | Arms and ribs |
| Composite section | $$M = \frac{\sum V_i}{\sum A_i}$$ | Complex shaft sections |
For a crankshaft, I divided the part into main journals, crankpins, webs, and fillets. Each element received a modulus. The elements with the largest modulus were identified as feeding zones. I then chose riser locations, riser types, and riser dimensions. The riser database contains standard riser geometries, volumes, weights, maximum feeding volumes, and maximum feeding weights. The user can query the database after calculating the required modulus. The system also checks the feeding distance to ensure that the riser can feed the entire hot spot.
7. Case Study: Heavy Crankshaft Sand Mold Casting
I tested the system on a heavy crankshaft produced in small batches. The material was a cast steel grade with specified tensile strength, yield strength, elongation, and reduction of area. The foundry required normalizing and tempering to a specified hardness range. The maximum diameter was about 1270 mm, and the maximum length was about 1720 mm. The crankshaft had three throws, with thick sections at the junctions between the crankpins and the main journals. These junctions are classic hot spots in sand mold casting, so riser design was critical.
| Production condition | Value |
|---|---|
| Production type | Small batch |
| Casting process | Sand mold casting |
| Material | Cast steel |
| Maximum diameter | Approximately 1270 mm |
| Maximum length | Approximately 1720 mm |
| Number of throws | Three |
| Main risk | Shrinkage porosity at thick junctions |
| Heat treatment | Normalizing and tempering |
I started by building the three-dimensional solid model in Pro/ENGINEER. The model included the journals, webs, crankpins, and fillets. I then selected sand mold casting as the casting type and entered the shaft module. The system defined the material, converted units, and applied shrinkage. I created a parting surface through the shaft axis and used it to orient the casting for pouring. The pouring position placed the thick journals in a favorable location for feeding.
Next, I designed the gating system. I selected a middle gating arrangement because the crankshaft has a large height and multiple thick sections. I entered the total steel weight, the number of ladles, the number of nozzles, and the nozzle diameter. The system calculated the pouring time using:
$$t = \frac{G}{N n v}$$
It then checked the rising speed using:
$$v_L = \frac{C}{t}$$
The calculated rising speed was compared with the database values for a heavy steel sand mold casting. After adjustment, the gating area ratios were set to a middle gating pattern. The system generated the sprue, runner, and ingates in the model. I inspected the layout to ensure that the ingates did not impinge directly on the mold walls or create turbulence.
I then designed the riser system. I divided the crankshaft into feeding zones. The two large throws had the largest modulus and were the most likely to suffer shrinkage. The smaller throw had a lower modulus and was closer to a thin section, so I assumed it could be fed by the adjacent sections. I calculated the casting modulus for the thick sections and applied the riser factor. For an open riser, the required modulus was:
$$M_r = 1.2 M_c$$
The calculated casting modulus for a large throw was approximately 10.02 cm. Therefore, the required riser modulus was approximately 12.02 cm. I queried the riser database and selected a standard riser with a modulus of 11.96 cm, a maximum feeding weight of 4340 kg, and a riser weight of about 2100 kg. The casting weight at the feeding location was about 4338 kg, so the selected riser could feed the section. The system placed the risers on the two large throws and generated the riser geometry.
| Design item | Calculated or selected value | Check |
|---|---|---|
| Casting modulus at large throw | 10.02 cm | Calculated from volume and surface area |
| Riser factor | 1.2 | Open riser |
| Required riser modulus | 12.02 cm | $$M_r = f M_c$$ |
| Selected standard riser modulus | 11.96 cm | Close to required value |
| Maximum feeding weight | 4340 kg | Greater than casting section weight |
| Casting section weight | 4338 kg | Accepted |
| Riser weight | About 2100 kg | Used for yield calculation |
After completing the gating and riser design, I calculated the process yield. The yield is the ratio of the casting weight to the total poured weight:
$$Y = \frac{W_c}{W_c + W_r + W_g} \times 100\%$$
where Wc is the casting weight, Wr is the riser weight, and Wg is the gating system weight. For this sand mold casting design, the yield was approximately 60%. This was considered acceptable for a heavy steel shaft sand mold casting with large risers. The result showed that the system could produce a practical feeding design without manual trial and error.
I exported the final model with gating and risers for solidification simulation. The simulation allowed me to check the thermal history, hot spot locations, and potential shrinkage porosity. If the simulation showed a defect, I could return to the sand mold casting CAD system, adjust the riser size or gating ratio, and regenerate the model. This feedback loop is one of the main benefits of integrating a sand mold casting CAD system with simulation.
8. Validation and Engineering Discussion
The case study confirmed several practical points. First, a shaft sand mold casting CAD system must be built around the solid model. Two-dimensional design cannot easily provide the volume, surface area, and modulus values needed for feeding calculations. Second, the database is not optional. Foundry practice varies with material, section size, and shop conditions, so the system must allow the user to query and update process parameters. Third, the menu and dialog interface must be integrated into the CAD environment. If the user has to switch to another program, the design flow breaks and errors increase.
I also found that multiprocess debugging saved time. In multiprocess mode, I could compile the Pro/TOOLKIT application and run it as a child process while Pro/ENGINEER remained open. This reduced the cycle time between code changes. For final release, DLL mode gave faster response and a more seamless appearance. The use of MFC dialogs made the database interface much easier to build than using only native Pro/ENGINEER dialogs.
The modulus method worked well for the heavy crankshaft. The main challenge was dividing the complex shaft into simple geometric elements. The system provided formulas for plates, cylinders, spheres, and long bars, and the user could combine them for composite sections. In future versions, I would automate the section division more fully by reading the solid model features and computing moduli directly from the Pro/ENGINEER geometry.
The gating design method also worked, but it required careful database support. The minimum rising speed depends on casting height, wall thickness, and steel grade. The pouring weight rate depends on nozzle diameter and ladle condition. If these values are inaccurate, the pouring time and gating areas will be inaccurate. I therefore designed the database so that a foundry can calibrate these values with its own measurements.
9. Lessons Learned from the Development
I learned that a sand mold casting CAD system is not just a calculator. It is a knowledge management system. The equations are important, but the real value comes from combining equations with standard data, graphical interaction, and a repeatable workflow. For shaft sand mold casting, the workflow should follow the actual sequence used by foundry engineers:
- Understand the part geometry and production requirements.
- Select the casting process and material.
- Define the parting surface and pouring position.
- Apply shrinkage, machining allowance, draft, and fillets.
- Design the gating system to fill the mold without turbulence.
- Design the riser system to feed the hot spots.
- Check the process yield and feeding distance.
- Simulate the filling and solidification process.
- Adjust the design based on simulation and foundry experience.
I also learned that the user interface must be forgiving. The user should be able to query a database, accept a default value, override it, and then see the result immediately in the model. The system should not force a single correct answer. Instead, it should provide a sound starting point and allow the user to apply foundry-specific knowledge.
Another lesson was that the resource files and registration file are as important as the C code. If the menu resource file is wrong, the menu will not appear. If the text resource file is wrong, the messages will be unclear. If the registration file is wrong, the application will not load. I spent considerable time testing these files and documenting their correct format. For anyone developing a sand mold casting CAD system on Pro/ENGINEER, I would recommend creating a small test application first to verify menu registration, dialog invocation, and database access before building the full system.
10. Conclusions
I developed a shaft sand mold casting CAD system based on Pro/ENGINEER 2001, Pro/TOOLKIT, Visual C++ 6.0, MFC, and DAO. The system extends Pro/ENGINEER with custom menus and dialogs, uses the native solid model for geometry, and stores foundry parameters in an Access-compatible database. It supports the main steps of sand mold casting design for shafts: three-dimensional modeling, material and unit definition, parting surface selection, process parameter assignment, gating system design, riser system design, and database queries.
The gating system uses the rising speed method and pouring time equation:
$$t = \frac{G}{N n v}$$
$$v_L = \frac{C}{t}$$
The riser system uses the modulus method:
$$M = \frac{V}{A}$$
$$M_r = f M_c$$
These equations are linked to databases for minimum rising speed, pouring weight rate, gating area ratios, riser factors, and standard riser dimensions. The case study on a heavy crankshaft sand mold casting showed that the system can calculate practical feeding and gating designs. The process yield reached about 60%, which is reasonable for a heavy steel sand mold casting with large risers.
The system reduces the time required for sand mold casting design, lowers the risk of shrinkage defects, and provides a structured way to preserve foundry knowledge. It also creates a solid model that can be used directly in CAE simulation. Because Pro/ENGINEER is widely used in industry, the system has a practical deployment path. Its menus and dialogs are integrated into the CAD environment, so engineers can work in a familiar interface while applying specialized sand mold casting design rules.
11. Future Work
I see several directions for further development. The system should be extended to include chills, cores, and pattern equipment design. It should also be linked more closely with CAPP and CAM so that the sand mold casting design can flow into process planning and mold machining. The current system is focused on shaft sand mold casting, but the same architecture can be generalized. One approach is to divide any part into basic elements such as rods, plates, and cylinders, design each element, and then assemble the results into a complete sand mold casting process. This would make the system useful for a wider range of castings.
The database should also be improved. A networked database would allow multiple engineers to share process data and update it in real time. The database could include more steel grades, section thicknesses, and foundry-specific calibration data. It could also store simulation results and actual production results so that the system learns from every job. Over time, this would make the sand mold casting CAD system more accurate and more valuable to the foundry.
Finally, I would like to automate more of the modulus calculation directly from the CAD model. Instead of manually dividing the shaft into sections, the system could identify hot spots from the geometry, compute local moduli, and propose riser locations automatically. The user would still make the final decision, but the system would reduce manual input and improve consistency. This would bring the sand mold casting CAD system closer to a knowledge-based engineering tool for foundry process design.
In summary, my work shows that a practical sand mold casting CAD system can be built on a commercial three-dimensional CAD platform with an open secondary development toolkit. By combining parametric solid modeling, custom menus, MFC dialogs, DAO databases, and foundry design formulas, the system supports the engineering logic of shaft sand mold casting and provides a foundation for further integration with simulation and manufacturing.