Overview
In centrifugal turbomachinery, the volute is a spiral-shaped casing that collects high-velocity fluid exiting the impeller and converts it into high-pressure, low-velocity flow directed toward the outlet. The volute tongue (or cutoff splitter) is the sharp junction where the spiral scroll geometry meets the straight exit pipe.
This sharp junction causes flow separation and creates difficulties for CFD meshing and FEA simulations. A smooth, tangent fillet surface at this junction significantly improves simulation quality and represents realistic manufacturing geometry.
This project developed a parametric fillet generation algorithm that creates smooth, tangent fillet surfaces using Coons patches with constrained filling. The algorithm was implemented in C++ using the OpenCascade CAD kernel and integrated into a commercial turbomachinery design suite as a beta feature.
What is a Volute?
A volute consists of several geometric parts: the scroll (spiral casing), the exit pipe (which can be straight or curved), inlet and exit faces, and the tongue. The tongue geometry can be configured with various cross-section types — elliptic, Bézier, rectangular, twin Bézier, and more — each offering different flow characteristics.
The challenge was to develop a third tongue option: fillet. Unlike the existing "sharp" and "general" options, a fillet creates a truly smooth, tangent transition surface between the scroll and exit pipe — matching what other commercial software can produce.
Methods Explored
1) Tangent Curve Loft
The first approach involved extracting the intersection curve between the scroll and exit pipe, then generating tangent curves at multiple cross-sections along this intersection. Each tangent curve was constructed by projecting points onto both surfaces and interpolating through them.
Lofting through these tangent curves produced an approximately tangent surface. However, the boundary curves varied unpredictably, resulting in rough edges that didn't meet quality requirements for CAD export.
2) Scaling Method
The second approach identified fillet boundaries by scaling geometry. The exit pipe was scaled to find its intersection with the scroll (and vice versa), creating two smooth boundary curves. A lofting operation through the lower boundary, intersection wire, and upper boundary produced the fillet surface.
This method was developed in parallel as a fallback and produced valid CAD geometry that passed SolidWorks import diagnostics and could be meshed successfully. However, the fillet lacked the true tangent continuity of a traditional fillet.
3) Combined Method
This method combined the best of both approaches: boundary identification from the scaling method with tangent curve generation from the loft method. Instead of projecting onto an offset curve, points on the scaling-derived boundaries were used directly to create tangent curves.
The result was a much better-looking fillet with smooth boundaries. However, it still lacked a proper corner fillet — the region where the fillet wraps around the end of the tongue. Existing operations like lofting and revolving couldn't address this, leading to the discovery of constrained filling methods.
Final Approach: Constrained Filling
Coons Patches
The final approach used OpenCascade's GeomFill_ConstrainedFilling class, which constructs surfaces using Coons patches. A Coons patch takes four boundary curves and generates a smooth surface that interpolates between them, with optional tangency constraints to ensure the resulting surface is tangent to adjacent geometry.
Each fillet section was built from 3–4 boundary curves: the top and bottom boundaries (with tangency constraints to the scroll and exit pipe surfaces) and one or two side boundaries. Previous fillet sections were used as tangent surfaces for subsequent ones, ensuring C2 continuity across the entire fillet.
Boundary Identification
To identify fillet boundaries, a scaled intersection pipe was used. By intersecting this pipe with both the scroll and exit pipe surfaces, clean boundary curves were extracted that define where the fillet starts and ends on each surface.
These boundary curves were combined with tangent curves to form closed wires with 3 or 4 edges — the input required by the constrained filling algorithm.
Fillet Section Construction
The fillet was constructed as multiple sections, each defined by boundary curves extracted from the scroll and exit pipe geometry. Side fillets use 4-boundary Coons patches with tangency on the top and bottom curves. End (corner) fillets required special treatment.
For the circular arc tangent curves, OpenCascade's built-in analytic geometry solver was used to construct arcs with a user-defined radius that are tangent to both the scroll and exit pipe section curves — replacing the earlier arbitrary tangent curves with a properly parametrized construction.
Circular Arc Tangent Curves
At each cross-section plane, the scroll and exit pipe intersection curves lie on the same 2D plane. OpenCascade's analytic solver constructs a circular arc with user-defined radius R that is tangent to both curves.
The solver naturally produces two solutions; the correct one is selected by filtering based on distance from the main intersection curve. This approach replaced earlier ad-hoc tangent curve generation with a clean, parametrized construction.
Surface Cutting & Shell Construction
After building the fillet surfaces, the scroll and exit pipe faces were cut along the fillet boundaries to make room for the new geometry. This was done using surface cutting rather than Boolean operations — a significantly faster approach that avoids the tolerance issues common with Boolean operations in CAD kernels.
All cut faces, unmodified volute faces, and fillet faces were then sewn together into a watertight shell and converted to a solid. Geometric analysis confirmed the correct topology: one shell, one solid — a valid configuration for simulation.
Debugging & Challenges
Degenerate Corner Fillets
Coons patches are mathematically defined for surfaces with 4 boundaries. When the constrained filling API was given 3 boundaries, it collapsed one boundary into a point — creating a degenerate geometry. This was visible in ISO curve grid inspections: the corner fillet showed a converging pattern where the fourth boundary collapsed.
The solution was to avoid constrained filling for corner fillets entirely, using a regular filling algorithm without tangency constraints instead. Since most fluid flow hits the front of the fillet rather than the corners, this had minimal impact on simulation accuracy.
Self-Intersecting Surfaces
For smaller fillet radii, the filling algorithm produced self-intersecting surfaces — the generated surface crossed over itself. ISO curve grid inspection revealed the cause: the default surface degree was too low (degree 3) to faithfully represent the high curvature of the fillet.
After testing, degree 8 was found to be the sweet spot. Increasing the surface degree eliminated self-intersections for all tested cases, passing SolidWorks import diagnostics and enabling successful meshing with higher quality than the scaling method fallback.
Tolerance & Face Construction
A persistent challenge was achieving the required geometric tolerance of 1 × 10⁻⁷ units for sewing faces into a watertight shell. The filled surfaces didn't follow boundary curves with sufficient precision when using the default face construction method.
The breakthrough was using an alternative face construction approach: instead of letting the face generator use the surface's natural boundaries, the original boundary curves were explicitly provided alongside the surface. This produced faces with the necessary tolerances that could be sewn together successfully.
Software Architecture
Multi-Stage Build Pipeline
The fillet builder is implemented as a single C++ class spanning roughly 7,700 lines with over 100 methods, organized around a clear multi-stage pipeline. The build() entry point orchestrates seven sequential phases:
- Section analysis — classify the geometry around the tongue, identify corner vs. mid sections, and validate topological prerequisites
- Arc generation — construct guiding arcs, supporting arcs, connecting arcs, and sub-arcs that define the tangent curves between the scroll and exit pipe
- Point assignment — distribute boundary sample points across fillet sections and their individual fill sub-sections
- Boundary generation — build the four boundary curves for each Coons-style surface patch
- Fill boundary preparation — attach tangency constraints, convert free boundaries to surface-bound constraints, and handle degenerate cases
- Constrained filling — generate the actual B-spline surfaces via degree-8 constrained filling
- Face sewing — cut existing volute faces, construct new faces from the filled surfaces, and sew everything into a watertight shell
Each phase is self-contained with its own validation, making the system debuggable at any intermediate stage.
Hierarchical Data Model
The fillet geometry is represented by a three-level hierarchy. At the top level, the tongue is decomposed into fillet sections — logical groups corresponding to distinct regions around the scroll–pipe intersection. Each fillet section contains multiple fill sections — individual surface patches classified into four types: free sections (interior patches with minimal constraints), end sections (at the trailing edge of the fillet), corner sections (where the scroll wraps around the pipe), and middle sections (at the front of the tongue). This classification drives which filling strategy is applied to each patch.
Connecting these sections are fillet arcs — circular arcs parameterized by a UV coordinate along the intersection, storing the arc geometry, tangent edges, boundary points, and center location. The arc generation itself is a multi-pass process: guiding arcs are built first (using 2D tangent circle solving on the scroll surface), then supporting arcs, then connecting arcs that bridge between fillet sections.
Key Engineering Decisions
UV-space interpolation over 3D projection: The intermediate sample points along boundaries are interpolated in the UV parameter space of the scroll surface rather than projected in 3D. This avoids the ambiguity of 3D projection onto a doubly-curved surface and ensures smooth parametric distributions even near regions of high curvature.
Adaptive fill section count: The number of fill sections per fillet section is not fixed — it adapts based on the fillet radius and local geometric complexity. Smaller radii demand finer subdivision to prevent self-intersections, while larger radii can use fewer sections for efficiency.
Multiple fallback strategies: The arc generation code implements several fallback paths. If the primary 2D tangent circle solver fails (common near degenerate tongue geometries), the algorithm falls back to projection- based methods, then to simplified arc approximations. This layered approach was essential for achieving the 85%+ success rate across diverse volute configurations.
Tangency disabled between adjacent sections: Early iterations enforced C1 tangency between neighboring fill sections, but this produced meshing artifacts — the surface oscillated to satisfy conflicting tangent constraints. The final implementation uses only positional continuity between sections, with tangency enforced only at the scroll and exit pipe boundaries where it matters for flow simulation.
Integration into Existing Codebase
The fillet builder was developed to integrate with an existing volute generation system — itself a ~2,000-line class supporting symmetric, asymmetric, and rectangular volutes. The integration required carefully managing the access to the parent volute's topological entities (faces, edges, wires) and ensuring that the fillet modifications preserved the surrounding geometry.
The cutting and sewing phase was particularly sensitive: the existing scroll and exit pipe faces had to be split precisely along the fillet boundary, with the original faces removed and replaced by the trimmed versions plus the new fillet faces. This involved building intersection curves between the fillet surfaces and the existing geometry, projecting them into the correct parameter spaces, and performing topological operations (splitting wires, constructing new faces from edges) that had to remain consistent with the sewing tolerances.
The final implementation processes a typical fillet in 1–2 seconds, including all seven pipeline stages and the final sewing pass. After a team code review, it was merged into the main repository as a beta feature for the product's next release cycle.
Parametrization
Fillet Radius
The primary parameter controlling the fillet shape is the fillet radius — the radius of the circular arcs used as tangent curves between the scroll and exit pipe. A larger radius creates a more gradual, sweeping transition while a smaller radius produces a tighter fillet closer to the original sharp edge.
Intersection Cut Length
The second parameter is the intersection cut percentage — the amount of the scroll–exit pipe intersection that is trimmed away and replaced by the fillet. Increasing this parameter extends the fillet along the tongue but reduces the effective fillet radius. Together, these two parameters give designers precise control over the fillet geometry.
Results
Validation Results
The algorithm was tested across 20 different volute configurations with varying parametrizations, cross-section types, and exit pipe geometries (including curved pipes). It was also rewritten to support exit pipes with any number of faces — a requirement discovered during testing with complex geometries.
| Validation Step | Success | Failure | Mixed |
|---|---|---|---|
| Build Volute Successfully | 17 | 2 | 1 |
| CAD Import (SolidWorks) | 16 | 3 | 1 |
| Building a Solid | 15 | 2 | 3 |
| Meshing (NetGen) | 10 | 4 | 4 |
The entire fillet building process takes approximately 1–2 seconds on average, despite the complexity of the operations involved. After code review and presentation to the development team, it was merged into the main repository as a beta feature.
Test Case: Before and After
The fillet was tested across a wide variety of volute configurations. This example shows a test case with an aspect ratio of 1.5, demonstrating the smooth transition from the sharp tongue (left) to the filleted tongue (right). The fillet maintains tangency to both the scroll and exit pipe surfaces while providing a clean, meshable geometry.
Curved Exit Pipe Support
The algorithm was generalized to support curved exit pipes — where the pipe follows a curvilinear path rather than a straight one. This required handling exit pipes with multiple faces and rewriting the fillet builder to support an arbitrary number of face–scroll intersections. The image shows a successfully filleted volute with a curved exit pipe.