Siemens NX CAM Blank Stock Expressions: Template and UFUNC Setup

Overview: NX CAM Blank Stock Fundamentals

In Siemens NX (formerly Unigraphics NX) CAM, the term Blank Stock refers to the modeled workpiece geometry that represents the material available for a machining operation. Blank stock is fundamental to toolpath simulation, material-removal verification, and IPW (In-Process Workpiece) generation. NX evaluates the stock against the tool geometry to compute material that still has to be removed, to detect gouges, and to simulate the resulting workpiece state after each CUT level.

Two distinct methods exist for placing blank stock inside an NX CAM operation tree:

1. A template that contains a geometry group with the blank body, under which subsequent operations are organized.
2. A User Function (UFUNC), a programmatic routine—typically written in C++, TCL, or another NX-supported language—that generates the blank, the drawing, and the NC program automatically.

The first method is procedural and configuration-driven; the second is programmatic and rules-driven. The choice between them is governed by part variety, change frequency, engineering throughput targets, and integration depth with PLM.

Method 1: Template-Based Blank Stock Definition

The template approach builds a reusable CAM setup in which a geometry group carries the blank body. Operations underneath the geometry group inherit the blank definition. To build a template-based blank stock:

1. Open Manufacturing → Create Operation and select the parent geometry group.
2. From Geometry, choose Workpiece and select the blank body—either an explicit solid or a parameter-driven expression.
3. Set Stock parameters: Initial Stock, Final Stock, and any per-side allowances.
4. Define the Part Geometry and Check Geometry for collision verification.
5. Save the operation tree as a Template Part (*.prt) for reuse across new parts.

When the template is instantiated on a new part, the expression-driven blank body evaluates against the new part parameters. This approach is best when:

• The part family is small and well-defined.
• The blank geometry can be expressed with simple expressions (length, width, height, offsets).
• Fewer than ~50 unique parts per year require new CAM programs.
• Tool selection and stock allowances vary modestly between parts.

Method 2: UFUNC Programmed User Function

NX is a highly open system. User Functions (UFUNC) expose the NX Open API for C++, Java, TCL, and Python (depending on NX release). A UFUNC for blank stock can automate the entire chain:

1. Read the part dimensions from the model.
2. Compute blank geometry from the part + stock allowance + tool-dependent rules.
3. Generate the drawing automatically.
4. Post-process the toolpath to NC code.

An illustrative UFUNC skeleton for blank creation in NX Open (C++):

// Illustrative NX Open C++ UFUNC skeleton: parameterized blank stock.
// Verify exact class names against your NX Open API reference.
#include <NXOpen/Part.hxx>

Tag_t CreateBlankStock(Part *part,
                       double partLength,
                       double partWidth,
                       double partHeight,
                       double allowance)
{
    // Compute blank envelope from part + per-side allowance
    double blockLength = partLength + 2.0 * allowance;
    double blockWidth  = partWidth  + 2.0 * allowance;
    double blockHeight = partHeight + allowance;

    // Construct block feature using NX Open builders
    // ... API call(s) here, e.g. block-feature builder equivalent ...

    // Attach the resulting body as the operation Workpiece
    // ... API call to set Workpiece geometry ...

    return tag;
}

For TCL scripting inside NX, a lighter version is appropriate:

# NX Open TCL UFUNC: parameter-driven blank envelope
proc create_blank { part_length part_width part_height allowance } {
    set bl [expr {$part_length + 2 * $allowance}]
    set bw [expr {$part_width  + 2 * $allowance}]
    set bh [expr {$part_height + $allowance}]
    return [list $bl $bw $bh]
}

UFUNC programs can also wrap the entire CAM operation creation chain, including tool selection, level sequencing, and post-processing. This is the route chosen by automotive and aerospace suppliers that must sustain hundreds of unique part numbers per year.

Cost-Benefit Analysis: Template vs UFUNC

Field experience shows that a full UFUNC—covering part generation, drawing, blank creation, toolpath, and NC code—can cost on the order of €50,000 to develop, test, and commission. This includes API integration, rule validation, and exception handling.

Compare that against the engineering hours required to maintain equivalent capability via templates and setups. If a template-driven workflow requires ~5 hours per new part and the engineer burdened cost is ~€80/hour, then approximately 125 parts consume €50,000 in labor. Beyond that breakeven, the UFUNC has lower total cost over its lifetime.

The breakeven is a rough field-derived indicator. Actual breakeven depends on:

• Number of distinct part numbers per year.
• Frequency of engineering change orders.
• Complexity of stock rules (multi-axis, multi-setup, multi-fixture).
• Integration depth with PLM (Teamcenter), ERP, and shop-floor MES.

The original decision rule in shop-floor practice is straightforward: "Does it pay to invest €50,000 in a UFUNC for automatic part generation including drawing and NC program, or can I work for ~10 years with templates and setups before reaching the same cost?" This frames the question in workload terms rather than abstract ROI, and it forces the team to compare development effort against multi-year labor cost.

Tool-Dependent Parameters (NX5 and Later)

Prior to NX5, blank stock geometry and many CAM operation parameters were defined as fixed values per operation. Starting in NX5, several parameters became tool-dependent, meaning the operation can evaluate expressions that reference the active cutting tool.

This opened three practical use cases that previously required manual rework on each tool change:

1. Cut depths based on tool diameter.

   // Expression: cut depth as function of tool diameter
   cut_depth_rough  = tool_diameter * 0.5
   cut_depth_finish = tool_diameter * 0.2

2. Boundary Stock based on tool radius.

   // Expression: boundary stock offset, leaving finishing allowance
   boundary_stock = tool_radius + 0.1   // mm

3. Stock driven by a modeling parameter.

   // Expression: blank thickness from a model attribute
   blank_height = model_param("raw_stock_mm")

By expressing the blank stock and related operation values as functions of the tool table, the CAM programmer ensures that changing a tool in the library propagates automatically to all dependent values—no manual re-entry required.

Expression Examples for Blank Stock

The expressions that drive blank stock typically combine part dimensions, allowances, and tool geometry. The examples below show how a single stock model can be reused across multiple operations.

Expressions are evaluated by the NX Expression Engine at operation creation, at regeneration, and—when marked as live—at toolpath generation. Always mark blank stock expressions as live if the operation should react to tool changes.

Decision Flow: Template vs UFUNC

The decision logic is short enough to map visually:

Implementing UFUNC for Blank Stock Automation

UFUNC implementation steps:

1. Scope definition. List which part attributes the UFUNC reads (length, width, height, material, tolerance class).
2. API selection. Choose NX Open (C++/Java) for compiled performance, or TCL/Python for rapid prototyping.
3. Blank builder. Wrap the NX block-feature builder or generic curve/body construction.
4. Tool library hook. Read tool geometry from the active tool library; pass it into the expression engine.
5. Validation harness. Run against a sample of 10–20 parts; verify stock sizes, operation counts, and post output.
6. Exception handling. Handle missing tool, missing material, undersized stock, oversized blank.
7. PLM hook (optional). Release revision and metadata to Teamcenter for traceable history.

Beyond the blank builder itself, the UFUNC should expose hooks for:

• Tool selection—read tool diameter, length, number of flutes from the library.
• Level sequencing—emit ordered CUT levels with the corresponding expressions.
• Post-processing—output NC code via the active post-builder.
• Drawing generation—emit a fully dimensioned drawing automatically.

Verification and Commissioning

After the blank stock is created—either by template or UFUNC—verify with these checks:

1. Geometric containment. Confirm the part geometry lies fully inside the blank body. NX provides this via the Verify Geometry dialog under Machining → Verify.
2. Stock allowance on all sides. Toggle the display of the IPW after the first CUT level; confirm the visible allowance equals the expression value.
3. Tool-dependent evaluation. Swap the tool in the tool library; regenerate the operation. The boundary stock and cut depth expressions should re-evaluate to the new values.
4. Simulation. Run Tool Path Visualization with the 3D dynamic IPW enabled. Material removal should match the expected per-pass volume.
5. Post output sanity check. Generate the NC code; verify that the Z-approach and Z-retract points respect the blank top surface.
6. Cross-setup verification. For multi-setup parts, confirm that the blank defined in setup A correctly represents the as-machined state when setup B begins.

Common Pitfalls and Field-Proven Caveats

Integration with PLM and Shop Floor

Once the blank stock method is decided and validated, integrate it with the surrounding toolchain:

1. Teamcenter. Release the template or UFUNC artifacts as controlled revisions; track who changed the stock allowance rules and why.
2. CAM workflow. Bind template instantiation to a release state; UFUNCs to a build state.
3. DNC distribution. Verify the post-processed NC code references the same blank envelope as the simulation; any mismatch indicates a stale post-builder configuration.
4. MES feedback. Capture actual material removed at each setup; reconcile with the predicted IPW to refine allowance tables.

Best Practices and Field Notes

• Prefer live expressions for any value tied to a tool. Static values defeat the purpose of the NX5 tool-dependent machinery.
• Centralize allowance tables. A single CSV or part-attribute table should drive material-specific stock values; avoid hard-coding them inside operation parameters.
• Document the cost decision. When choosing template over UFUNC, document the expected part volume. Review the decision annually against actual throughput.
• Test on representative geometry. A UFUNC validated only on prismatic parts may fail on turned, 5-axis, or freeform parts. Cover the full geometry envelope before release.
• Keep UFUNC source under version control. Git or Teamcenter revision control for the C++/TCL/Python sources is mandatory once the UFUNC is the production path.
• Train CAM programmers on the expression syntax. Templates are forgiving; UFUNC-driven CAM requires precise understanding of model_param(), lookup(), and tool reference syntax.
• Lock the tool library. Disallow direct edits to the library outside the controlled release process; otherwise expressions silently drift.
• Audit regenerate time. If UFUNC-driven regeneration exceeds the project time budget, profile the expression engine and cache non-dependent values.

For teams standardized on Siemens tooling, the official documentation is the primary reference for current UFUNC syntax and operation semantics. Confirm behavior against the specific NX release in use before commissioning any of the patterns described above. See Siemens Software Support and Siemens Xcelerator documentation for the latest API references.

FAQ