5 Difficult Points in Complex-Shaped GRC Component Deepening Design: Surface Decomposition, Mould Data, Tolerance Transmission, and How to Solve Them

The gap between an architect's sketch and a GRC component arriving on site is closed by the deepening designer (深化设计师). For flat panels, the deepening work is straightforward. For complex-shaped GRC — double-curved surfaces, hollow carvings, varying cross-sections — the deepening process itself is one of the project's biggest risks. Five recurring difficulties cause 80% of the on-site rework. This article unpacks each one and gives the engineering fixes used by Guangdong Qinglong Construction's deepening team.

What Deepening Design Actually Does

Deepening design (深化设计) translates the architect's 3D model into manufacturing data:

• Surface decomposition — splitting a continuous architectural surface into individual GRC panels
• Mould data — generating the tool paths for CNC mould fabrication
• Connection node design — detailing how each panel attaches to the building structure
• Tolerance budget — allocating the allowable error across the manufacturing chain
• Installation simulation — verifying that the panels can be hoisted and placed without collision

For complex-shaped GRC, each of these steps is harder than the equivalent for flat panels. The five difficulties below are the ones that recur across projects.

Difficulty 1: Surface Decomposition

A curved architectural surface (e.g., a Zaha Hadid-style flowing wall) is mathematically continuous. A GRC panel is a finite, manufacturable object. Splitting the surface into panels is the first deepening decision, and it sets the project's mould count, joint pattern, and visual outcome.

Common failure mode: panels sized for visual aesthetics (large panels to minimise joints) but exceeding mould size limits, transport limits, or hoisting capacity. Result: moulds that can't be fabricated, panels that can't be transported, or installation that requires a crane that's not on site.

The fix: parametric surface decomposition with hard constraints. The deepening team's Rhino + Grasshopper model should run a constraint check on every candidate panel: mould size ≤2.5 m × 1.5 m (typical factory limit), per-piece weight ≤500 kg (typical hoisting limit), transport dimension ≤3 m × 2.4 m (typical truck limit). Any panel failing a constraint is split further. The visual joint pattern is a result of the constraint-driven split, not an input to it.

Qinglong's bench: a 600 m² flowing wall can typically be split into 80–120 panels using constraint-driven decomposition, with 95%+ of panels falling within standard transport and hoisting limits.

Difficulty 2: Mould Data Conversion

The architectural surface is a NURBS model. The mould is a physical object fabricated by CNC machining from a 3D model. The conversion from NURBS to mould-surface geometry is not automatic — it requires decisions about tessellation density, surface offset (for GRC panel thickness), and demoulding draft angle.

Common failure mode: the mould is fabricated to the architectural surface, but the demoulding draft is forgotten. The GRC panel cannot be removed from the mould without breaking. Result: scrap mould (RMB 20,000–80,000 lost) and 2–3 weeks delay.

The fix: a standardised mould data pipeline that adds (a) demoulding draft (typically 1°–2° depending on depth and surface complexity), (b) panel thickness offset (typically 12–25 mm), and (c) mould split lines (for mould fabrication in multiple pieces). The pipeline outputs both the mould CNC file and the demoulded panel shape for verification.

Difficulty 3: Tolerance Transmission

Every step in the manufacturing chain has a tolerance: mould CNC machining (±0.2–0.5 mm), GRC casting shrinkage (0.05%–0.15%), curing deformation (≤1 mm/m), installation positioning (±2–5 mm). These tolerances add up — a tolerance budget that ignores the chain produces panels that don't close on site.

Common failure mode: the architect specifies ±2 mm tolerance on the architectural surface. The deepening designer models the panels at ±2 mm. But the mould is CNC-machined at ±0.5 mm, the GRC cast introduces ±1 mm shrinkage variation, and the installation team positions at ±5 mm. The cumulative tolerance stack-up at the joint between two adjacent panels can be ±8 mm — and the joint is visible.

The fix: a tolerance budget allocated across the chain. Typical allocation for complex-shaped GRC aiming at a 5 mm visible joint:

• Mould CNC: ±0.3 mm (40% of budget)
• Casting + curing: ±1.0 mm (20%)
• Panel factory QC: ±0.5 mm (10%)
• Installation positioning: ±2.0 mm (40%) — total station and 3D scan
• Joint adjustment: ±1.5 mm on site (built into the joint design)

The budget is signed off at design freeze. Any change in one line (e.g., switching from CNC to hand-finished moulds) triggers a re-allocation.

Difficulty 4: Structural Interface

GRC panels connect to the building's primary structure via steel keels and brackets. The connection node design is the structural engineer's responsibility, but the deepening designer must provide the load path data: per-piece weight, centre of gravity, wind load area, seismic load factor, and connection tolerance.

Common failure mode: the connection node is detailed before the panel weight and CG are finalised. The node is over- or under-engineered, or the bracket position doesn't match the as-built panel. Result: on-site rework of the steel framing or compromise on the connection detail.

The fix: a load-data sheet issued by the deepening team before node design starts. Each panel has a documented weight, CG, and connection point set. The structural engineer designs the node against this data, not against a TBD (to-be-determined) assumption. Any panel redesign triggers a load-data revision and a node check.

Difficulty 5: Installation Simulation

Complex-shaped panels have to be hoisted into position through a 3D space crowded with already-installed panels, scaffold, and the building structure itself. The deepening designer must simulate the hoisting path and verify that no collision occurs.

Common failure mode: the panel is designed, fabricated, and delivered. On lift day, the crane operator discovers that the panel cannot be rotated into position without hitting the previously installed panel 3 m away. Result: a 2–6 week delay while the lifting sequence is reworked.

The fix: a 4D installation simulation (3D + time) run during deepening design. The simulation models the crane position, the lifting rigging, the panel's CG and rotation, and the previously installed components. The simulation outputs an installation sequence (which panel goes up first, second, third) that minimises collision risk. The sequence is signed off by the installation team before fabrication starts.

Qinglong's bench: the simulation typically reduces on-site hoisting delays by 60%–80% on complex-shaped GRC projects.

Tooling: The Deepening Design Stack

The five fixes above depend on a deepening design stack:

• Rhino + Grasshopper: surface decomposition, constraint-driven panel splitting
• RhinoCAM or Fusion 360: mould CNC toolpath generation
• Tekla or Revit: structural node and steel framing detailing
• Fuzor or Synchro: 4D installation simulation
• PolyWorks or Geomagic: 3D scan verification and as-built comparison

The stack is not exotic — all tools are mainstream in the industry. What matters is that the deepening team operates them as a single workflow, with a single source of truth (the parametric model) shared across all steps.

Bottom Line

The five deepening design difficulties — surface decomposition, mould data conversion, tolerance transmission, structural interface, and installation simulation — are recurring root causes of on-site rework. Each has a documented engineering fix. The deepest fix of all is treating deepening design as a parametric workflow, not a CAD drafting exercise. The model is the master; the drawings are derivatives.

Guangdong Qinglong Construction's deepening team runs the full parametric stack with single-source-of-truth models. Visit the official website for sample deepening drawings and tolerance budget templates.