Generative Design and Surface Modelling: From Topology to Finished Geometry

Two Disciplines, One Workflow

There is a persistent confusion in engineering teams new to additive manufacturing: generative design and topology optimisation are treated as synonyms. They are not — and the distinction matters when you are trying to produce a printable, inspectable, cost-effective part.

Topology optimisation is a mathematical process. Given a design space, load cases, constraints, and a target volume fraction, it calculates where material is structurally efficient and where it is not. The output is a density field — a cloud of material presence probabilities that tells you what to keep and what to remove.

Generative design is an engineering workflow. It uses topology optimisation as its core engine but wraps it in manufacturing constraints, material selection logic, and automated geometry interpretation. The output is a manufacturable geometry — or several of them, for different manufacturing routes.

Surface modelling is what makes the topology result usable. Raw topology output is blocky, faceted, and numerically unstable at interfaces. Surface modelling — using T-splines, subdivision surfaces, or implicit field techniques — converts the organic topology result into smooth, printable, inspectable geometry.

The Topology Optimisation Process in Detail

A well-structured topology optimisation workflow has five phases:

Phase 1: Design Space Definition

The design space is the maximum envelope the part can occupy. This includes:

• The bounding volume of the original part
• Keep-in zones — interfaces, attachment points, assembly clearances
• Keep-out zones — adjacent components, cable routing, inspection access

# Pseudo-code: design space definition for a bracket
design_space = {
    "bounding_box": (120, 80, 45),   # mm, L×W×H
    "keep_in": [
        ("bolt_holes", [(10,10,0), (110,10,0), (10,70,0), (110,70,0)], dia=8),
        ("load_face",  (0, 0, 22.5),  area=(120, 80)),
    ],
    "keep_out": [
        ("cable_run",  (30, 20, 0),   size=(60, 40, 15)),
        ("inspection", (50, 35, 30),  size=(20, 10, 15)),
    ],
    "volume_fraction_target": 0.30,  # 30% of total design space
}

Phase 2: Load Case Definition

Multiple load cases must be defined — not just the peak load, but every significant loading scenario:

Running optimisation against a single load case is the most common mistake. Parts fail under lateral or torsional loads that were never included in the design.

Phase 3: Topology Optimisation Solve

Modern solvers (Altair OptiStruct, Autodesk Fusion Generative, nTopology) use the SIMP (Solid Isotropic Material with Penalisation) method to converge on an optimal material distribution. Convergence typically occurs in 50–200 iterations.

The output is a .stl or implicit field representing the density distribution — often described as "looking like bones." This is not coincidental: bone is a biological topology-optimised structure shaped by loading over millions of years.

Phase 4: Geometry Interpretation and Surface Modelling

This is where most teams underinvest. Raw topology output cannot be directly printed and inspected to GD&T tolerances. It must be interpreted into smooth, parametric geometry.

Three approaches:

1. Manual NURBS refit — highest quality, most labour. A skilled surface modeller uses the topology output as a reference and builds a clean NURBS surface model. Result: fully parameterised, inspectable, revision-friendly geometry.

2. T-spline fitting (Fusion 360, Rhino with T-Splines) — semi-automatic. Wraps a T-spline surface over the topology mesh. Fast but can introduce surface quality issues at complex intersections.

3. Implicit/field-driven geometry (nTopology, Ntopol) — newest approach. Represents geometry as a mathematical field rather than a surface mesh. Naturally produces smooth, additive-ready geometry and handles lattice infill natively.

# nTopology-style implicit field workflow (pseudo-code)
import ntopology as nt

# Load topology result
topo_field = nt.Field.from_stl("topology_result.stl")

# Smooth the field
smoothed = topo_field.smooth(iterations=5, strength=0.7)

# Convert to printable surface
surface = smoothed.isosurface(isovalue=0.5)

# Add minimum wall thickness constraint
thickened = surface.offset(min_thickness=1.5)  # mm

# Extract for printing
thickened.export("bracket_final.stl")

Phase 5: Validation

The final geometry must be validated by FEA using the actual part geometry — not the topology density field. This is a separate analysis step, often revealing that the interpreted surface has slightly different performance than the optimisation predicted.

Typical acceptable tolerance: within 10–15% of optimisation predictions. If outside this range, the geometry interpretation needs refinement.

Surface Modelling Techniques for Organic Geometries

Subdivision Surfaces

Subdivision surfaces (SubD) start from a coarse control cage and subdivide recursively to produce smooth, organic geometry. Tools: Rhino SubD, Blender, Fusion 360 Form environment.

Advantages:

• Naturally produces G2 continuity (curvature-continuous) surfaces
• Easy to manipulate globally and locally
• Converts cleanly to NURBS for manufacturing drawings

Disadvantages:

• No parametric history — changes are destructive
• Difficult to apply exact dimensional constraints

T-Splines / NURBS Hybrid

T-splines allow the T-junction topology that standard NURBS cannot represent — enabling a single surface to cover complex organic geometry without trimming or patching. This is the native format of Autodesk Fusion 360's Form environment.

Lattice and Triply Periodic Minimal Surfaces (TPMS)

For internal structure, topology optimisation gives way to lattice design. TPMS geometries — gyroid, Schwartz P, Diamond — provide excellent stiffness-to-weight ratios and are inherently additive-manufacturable.

# Gyroid TPMS implicit function
import numpy as np

def gyroid(x, y, z, period=5.0):
    """
    Gyroid TPMS: zero-crossing defines the surface.
    period: unit cell size in mm
    """
    p = 2 * np.pi / period
    return (
        np.sin(p * x) * np.cos(p * y) +
        np.sin(p * y) * np.cos(p * z) +
        np.sin(p * z) * np.cos(p * x)
    )

# Generate 3D field
resolution = 100
coords = np.linspace(0, 20, resolution)
X, Y, Z = np.meshgrid(coords, coords, coords)
G = gyroid(X, Y, Z, period=4.0)

# The surface is where G == 0
# Positive values = material, negative = void (or vice versa)
print(f"Volume fraction: {(G > 0).sum() / G.size * 100:.1f}%")

Gyroid infill at 20% volume fraction provides approximately 35% of solid material stiffness at 20% of the weight — better than any regular grid lattice pattern.

From Simulation to Print: The Complete Workflow

At Builders Generation, our generative design workflow runs:

1. Brief — load cases, interfaces, weight target, material options
2. Topology solve — Altair OptiStruct or nTopology
3. Geometry interpretation — NURBS or implicit surface modelling
4. FEA validation — confirm target structural performance
5. Printability review — support requirements, orientation, minimum features
6. Print — FFF in PA-CF, PC-CF, PEEK, or ULTEM depending on application
7. First article — dimensional inspection, mechanical test if required
8. Delivery — with full documentation package

The turnaround from brief to printed first article is typically 7–14 days for standard engineering polymers. For PEEK and ULTEM programs, 14–21 days including qualification documentation.

The geometry that topology optimisation suggests and the geometry that can be manufactured are converging. With CF-PEEK in a IDEX high-temperature chamber, we can now build the organic structures that finite element methods have always known were optimal.