Skip to Content

Process examples

Complete pricing equations for powder bed, FDM, large format FDM, SLA/DLP, metal LPBF, ceramics, CNC machining and vacuum casting, with the questions to answer before you build your own.

Phasio lets you define a pricing equation for any manufacturing process. This page works through complete process equations for the most common technologies. If your process isn't listed, use the AI prompt on the Pricing Guide to build one from scratch, or read Before you build first to think through your cost structure.

Each process section follows the same structure: why this process is unique → core methodology → numerical example → complete algorithm → when to use it.

ProcessKey metricPrimary cost driver
Powder bed (SLS and MJF)shrinkWrapVolumeVolume in chamber
FDM filament extrusionvolume, area, convexHullVolumePrint time
Large format FDMvolume, areaPrint time + material
SLA, DLP and LCMvolume, convexHullVolumeResin + machine time
Metal LPBF (SLM and DMLS)volume, convexHullVolumeMachine time (dominant)
Ceramics LCMvolumeMachine time (dominant), expensive material
CNC machiningminBoundingBoxVolume, volumeMachining time + stock
Vacuum castingvolumeMould amortisation + casting

Before you build

Before writing a single line of code, the quality of your equation depends entirely on how well you understand your own cost structure. This section is a thinking guide - not a checklist to tick off, but a set of questions that reveal where your pricing complexity actually lives.

The fastest path is the AI prompt in the Pricing Guide

It is designed to run exactly this interview for you - paste it into Claude or ChatGPT and it will ask the right questions, propose an equation, and iterate with you until it matches your real prices. Come back here if you want to think things through before that conversation.

1. What are your main cost drivers?

Start here. Most processes have one or two dominant costs - everything else is a rounding error until you get those right.

Cost typeAsk yourself
MaterialDo I sell material by weight, volume, or area? Is scrap/waste significant?
Machine timeDoes a longer or larger part actually take more time on my machine?
Setup / amortisationIs there a fixed cost per job (programming, fixturing, changeover) that I spread across quantity?
LabourIs there significant manual work per part, or is it largely unattended?
ConsumablesResin, powder refresh, solvents, tooling wear - are these a material cost per part?

If you're not sure, look at your last 10 jobs and ask: which line item on my cost sheet varies most part-to-part? That's your primary driver.

2. Do you have historical job data to calibrate against?

An equation built without calibration is a guess. Before going live, you need at least 3-5 real parts with known prices to validate against.

  • Pull your last 10-20 jobs for this process
  • For each: record the part dimensions, quantity, what you charged, and what it actually cost you
  • After writing your equation, run those parts through it and compare - the first mismatch tells you which cost driver you've modelled wrong

If you don't have historical data yet, start with conservative rates and a reviewRequired gate on everything until you've built enough confidence to open up auto-approval.

3. What does your minimum price look like?

  • What's the minimum you'd charge for a single part, regardless of how small it is?
  • Is there a minimum per material, per batch, or per post-process?
  • Is there a minimum order value for the whole cart?

All three can be set - minimum unit price in Level 1, minimum per material, per post-process, and order value in Level 3. Level 2 sees one part at a time, so a minimum per post-process across several parts needs Level 3, which reads specification.postProcessing[].price for every part.

4. Quantity: do you offer discounts, and what does the curve look like?

  • At what quantity does the unit price start to drop?
  • Does it drop smoothly or in steps? (Steps are easier to communicate, smooth curves better reflect real cost structure)
  • Is there a floor - a point where the discount stops?
  • Does your machine capacity affect this? (A process with 10 machines can take larger orders without surcharging; a single machine may need a lead time premium at high quantities)

5. What machines do you have, and how do you assign jobs to them?

  • List your machines, their build volumes (X × Y × Z mm), and their running cost per hour
  • How do you decide which machine a job goes to? Smallest that fits? Fastest available? Operator decision?
  • What happens when a part is too large for all machines? (This should trigger reviewRequired)

Machine selection logic is straightforward in the equation - but you need to know your machines before you can write it.

6. What material variables will your equation need?

This is a common reason equations misprice: the equation references material.variables['someKey'] but the material has no value for that key. Saving the equation does not check this. The equation reads undefined, the price becomes NaN, and Phasio stores a price of 0 with the review flag set.

Plan your material schema before you open the equation editor.

Keep material variables minimal

Only put values on the material that genuinely differ between materials - typically the raw material cost and density. Machine rates, setup costs, speed factors, and business rules should be hardcoded constants in the equation itself. Over-stuffing the material schema is one of the most common mistakes and makes equations hard to maintain.

A useful test: "Would I set this value differently for PA12 vs TPU vs Alumide?" If yes → material variable. If no → hardcode it.

The path in Phasio: Settings > Manufacturing > Processes > [your process] > Materials. Add the variable name under Material Schema, then set its value on each material under Pricing variables.

What belongs on the material:

KeyWhy it's per-material
materialDensityDetermines part weight - genuinely differs (PA12 ≠ TPU ≠ steel)
materialCostPerKgRaw material price varies per material
resinCostPerLiterResin price varies per resin type
costPerCm3Powder bed cost rate per volume varies per material
rawMaterialCostPerKgCNC stock cost varies by alloy / grade

7. What should trigger manual review?

Not every part should auto-price. Be explicit about your gates before building the equation:

TriggerExamples
SizePart exceeds machine build volume
GeometryOpen mesh (non-watertight), extremely thin walls, very high material removal ratio
MaterialMaterial not set up with the required variables
QuantityUnusually high quantity that might require a dedicated run or custom agreement
DurationEstimated print/machine time exceeds X hours
CustomerNew account, unapproved customer, flagged for manual pricing
PriceCalculated price falls below your cost floor (equation probably wrong)

8. What should operators be able to override per part line?

variable() exposes any value in the operator UI so your team can adjust it for each part line without touching the equation. Before building, decide:

  • Which values should be overridable? (support volume, print time, unit price, machine assignment)
  • Which values should be locked? (cost rates, margin - things only you should change)

As a rule: expose the outputs of cost calculations (print time, unit price) so operators can adjust the result. Lock the inputs (material costs) in material.variables where only admins can change them.

9. What lead times do you offer, and do they affect price?

  • What lead time tiers have you configured in Phasio? (Economy, Standard, Express...)
  • Does a faster lead time cost more? Does a slower one offer a discount?
  • Does the lead time surcharge taper at high quantities? (A 100-part rush is easier to absorb than a 1-part rush)

10. Do you have customer-specific pricing?

  • Are there accounts with negotiated rates on specific materials or processes?
  • Should these be visible as discounts, or baked silently into the unit price?

See Business logic for implementation patterns.

11. What post-processes attach to this process?

  • Which post-processes are available for this material/process combination?
  • Are any of them priced as a percentage of the part price, or independently?
  • Do any post-processes have minimum batch costs? (Dyeing, vapor smoothing, anodising often do)

Post-process pricing lives at Level 2 - but if the Level 1 equation needs to expose variables that Level 2 will read (e.g. print time for a UV curing step), decide that now and expose them via variable().

When you're ready

If you can answer most of the above, you have enough to build a working first equation. You don't need all the answers - use reviewRequired as a safety net for anything you're not confident about yet, and open up auto-approval as you gain confidence from real order data.

Go to the Pricing Guide and copy the AI prompt. Paste it into Claude or ChatGPT, answer its questions, and you'll have a working equation to paste into Phasio. The process sections below are there when you want to understand the methodology behind a specific process in depth.

Powder bed (SLS and MJF)

Why this process is unique

Powder bed processes (SLS, MJF, HSS) don't use support structures - the unfused powder supports the part during printing. This has two major pricing implications:

  1. Cost is driven by chamber volume occupied, not just part volume. A small dense part and a large hollow part with the same actual volume cost very differently.
  2. Build setup is expensive - depowdering, cake extraction, powder sieving, and material refresh are significant fixed costs per build. These must be amortised over all parts in the run.

The standard cost metric is shrinkWrapVolume - the tightest wrapping around the part including overhangs. It's the best proxy for how much of the chamber the part consumes.

Core methodology

Variable cost: shrinkWrapVolume × cost per cm³

Fixed cost: setup fee per build, divided by quantity ordered

Quantity discount: banded, reflecting better chamber utilisation and batch efficiency

Review gate: parts exceeding the chamber in any dimension

HP MJF 5200 Pro specifications (reference)

  • Build volume: 380 × 284 × 380 mm
  • Layer height: 0.08 mm
  • Typical cycle: 8-12 hours per full build

Numerical example

Part: 50 × 50 × 100 mm bracket, shrinkWrapVolume = 210,000 mm³ (part has overhangs)

InputValue
costPerCm3€0.18
setupCost€80
Quantity5

Calculation:

  • Volume cost: (210,000 / 1,000) × 0.18 = €37.80
  • Setup per part: 80 / 5 = €16.00
  • Subtotal: €53.80
  • Qty 5 discount (band from 5 units): ×0.97
  • Unit price: €52.19

At qty 50: setup = €1.60/part, discount 17% (×0.83) → unit price €32.70. The volume cost is now 96% of the cost before the discount.

Complete algorithm

const { material, shrinkWrapVolume, length, width, height } = specification
const { quantity } = requisition

// Machine chamber limits — adapt to your printer
const CHAMBER_LENGTH = 380
const CHAMBER_WIDTH  = 284
const CHAMBER_HEIGHT = 380

const costPerCm3 = material.variables['costPerCm3']
const setupCost  = material.variables['setupCost']

// Variable cost: shrink wrap volume × rate.
// shrinkWrapVolume can be null: fall back to the bounding box volume, which overestimates.
const volumeCm3  = (shrinkWrapVolume ?? width * height * length) / 1000
const volumeCost = round(volumeCm3 * costPerCm3, 2)

// Fixed cost: setup amortised over order quantity
const setupPerPart = round(setupCost / quantity, 2)

const baseCost = volumeCost + setupPerPart

// Quantity discount: smaller batches pay more per part
const getDiscount = createBands({ 5: 0.97, 10: 0.93, 25: 0.88, 50: 0.83, 100: 0.78 }, 1.0)
const unitPrice = variable('unitPrice', round(baseCost * getDiscount(quantity), 2))

// Review gate: part exceeds chamber dimensions
const oversized = length > CHAMBER_LENGTH || width > CHAMBER_WIDTH || height > CHAMBER_HEIGHT
done({ price: unitPrice, reviewRequired: oversized })

Material variables to create: costPerCm3, setupCost

When to use this

Use this model for any powder bed process: MJF, SLS, HSS, SAF. All share the same pricing structure.

Do not use for metal powder bed (LPBF) - print time dominates there and requires a time-based model.

You could also think of a packing algorithm to predict the usage of the build chamber at larger quantities.

FDM filament extrusion

Why this process is unique

FDM pricing is dominated by print time, not material cost. A structurally solid part uses similar material volume to the same part printed hollow, but they take very different amounts of machine time.

The key insight is to split the part into three regions that print at different speeds:

  • Shell (outer walls): slow, many direction changes
  • Infill: fast, long sweeping lines
  • Supports: medium speed, low density

Cost = material consumed + machine time × rate

Core methodology

Shell volume: Math.min(volume, area × nozzle × walls) - bounded so thin parts don't produce negative infill

Infill volume: (volume - shellVolume) × infillDensity

Support volume: estimated from the convex hull gap, exposed via variable() for override

Print time: each region's volume ÷ volumetric flow rate, summed and multiplied by overhead

Shell penalty: parts heavy in shell features print slower than their volume suggests

Numerical example

Part: 40 × 40 × 80mm post, 20% infill, volume = 30,000 mm³, area = 14,400 mm²

ParameterValue
Nozzle diameter0.4 mm
Layer height0.2 mm
Wall count3
Base speed60 mm/s
Wall speed factor0.5
Infill speed factor1.0
Machine rate€6/h (Small desktop FFF, the first machine the part fits)
materialCostPerKg€28, materialDensity = 1.24 g/cm³
convexHullVolume30,000 mm³ (no support)
minUnitPrice€5

Shell volume: min(30,000, 14,400 × 0.4 × 3) = min(30,000, 17,280) = 17,280 mm³

Infill volume: (30,000 − 17,280) × 0.20 = 2,544 mm³

Wall time: 17,280 / (0.4 × 0.2 × 60 × 0.5) = 17,280 / 2.4 = 7,200 s

Infill time: 2,544 / (0.4 × 0.2 × 60 × 1.0) = 2,544 / 4.8 = 530 s

Shell penalty: 1 + 0.5 × (17,280 / (17,280 + 2,544 + 1))² = 1.38

Print time: (7,200 + 530) × 1.3 × 1.38 / 3600 = 3.85 hours

Material cost: (17,280 + 2,544 + 0 support) / 1,000 × 1.24 / 1,000 × 28 = €0.69

Machine cost: 3.85 × 6 = €23.10

Unit price (1 part, no discount): €23.79

Complete algorithm

const { material, width, height, length, volume, area, convexHullVolume, infill } = specification
const { quantity } = requisition

// --- Machine definitions ---
const MACHINES = [
  { name: 'Small desktop FFF',      bed: { l: 256, w: 256, h: 256 }, costPerHour: 6  },
  { name: 'Medium desktop FFF', bed: { l: 300, w: 300, h: 300 }, costPerHour: 7  },
  { name: 'Big desktop FFF',      bed: { l: 320, w: 320, h: 325 }, costPerHour: 9  },
]

function selectMachine() {
  return MACHINES.find(m =>
    length <= m.bed.l && width <= m.bed.w && height <= m.bed.h
  ) ?? MACHINES[MACHINES.length - 1]
}

// --- Constants ---
const NOZZLE_DIAMETER_MM  = 0.4
const NUMBER_OF_WALLS     = 3
const SUPPORT_INFILL      = 0.2
const PRINT_TIME_OVERHEAD = 1.3

// --- Geometry ---
// Layer height in mm. Do not read it from precision: precision.value is a price multiplier.
const layerHeight = 0.20
const partInfill  = infill?.value ?? 0.20

const shellVolume   = Math.min(volume, area * NOZZLE_DIAMETER_MM * NUMBER_OF_WALLS)
const infillVolume  = (volume - shellVolume) * partInfill
const hullGap       = (convexHullVolume ?? volume) - volume  // convexHullVolume can be null
const supportVolume = variable('supportVolume', round(hullGap * 0.10, 0))

// --- Material cost ---
const materialDensity   = material.variables['materialDensity']
const materialCostPerKg = material.variables['materialCostPerKg']
const mainWeight    = ((shellVolume + infillVolume) / 1000) * materialDensity / 1000
const supportWeight = ((supportVolume * SUPPORT_INFILL) / 1000) * materialDensity / 1000
const materialCost  = round((mainWeight + supportWeight) * materialCostPerKg, 2)

// --- Print time ---
const baseSpeed          = material.variables['baseSpeedNozzle']
const wallSpeedFactor    = material.variables['wallSpeedFactor']
const infillSpeedFactor  = material.variables['infillSpeedFactor']
const supportSpeedFactor = material.variables['supportSpeedFactor']

const wallTime    = shellVolume  / (NOZZLE_DIAMETER_MM * layerHeight * baseSpeed * wallSpeedFactor)
const infillTime  = infillVolume / (NOZZLE_DIAMETER_MM * layerHeight * baseSpeed * infillSpeedFactor)
const supportTime = (supportVolume * SUPPORT_INFILL) / (NOZZLE_DIAMETER_MM * layerHeight * baseSpeed * supportSpeedFactor)
const shellPenalty = 1 + 0.5 * Math.pow(shellVolume / (shellVolume + infillVolume + 1), 2)
const printTimeHours = variable('printTime', round(
  (wallTime + infillTime + supportTime) * PRINT_TIME_OVERHEAD * shellPenalty / 3600, 2
))

// --- Machine cost ---
// variable() only takes numbers, so expose the machine as its position in MACHINES.
// The operator can type another number to switch machine.
const machineNumber  = variable('Machine (1 = Small, 2 = Medium, 3 = Big)', MACHINES.indexOf(selectMachine()) + 1)
const machine        = MACHINES[machineNumber - 1] ?? selectMachine()
const machineCost    = round(printTimeHours * machine.costPerHour, 2)

// --- Pricing ---
const hardwareCost = variable('Hardware cost', 0)
const getDiscount  = createBands({ 10: 0.95, 50: 0.90, 100: 0.85, 250: 0.80 }, 1.0)
const baseCost     = (materialCost + machineCost + hardwareCost) * getDiscount(quantity)
const MIN_PRICE    = material.variables['minUnitPrice']
const unitPrice    = variable('unitPrice', Math.max(MIN_PRICE, round(baseCost, 2)))

// --- Review gate ---
const largest = MACHINES[MACHINES.length - 1].bed
const oversized = length > largest.l || width > largest.w || height > largest.h
done(unitPrice, printTimeHours, oversized)

Material variables: materialDensity, materialCostPerKg, baseSpeedNozzle, wallSpeedFactor, infillSpeedFactor, supportSpeedFactor, minUnitPrice

When to use this

All desktop and industrial FFF/FDM printers. Any extrusion process where print time is the main cost driver.

For very large parts (>500mm), use Large format FDM instead.

Large format FDM

Why this process is unique

Large format FDM (pellet extrusion, gantry systems, SCARA robots) differs from desktop FDM in three key ways:

  1. Nozzle diameter is much larger (2-10mm vs 0.4mm) - faster deposition, lower resolution
  2. Layer height is proportionally larger (1-5mm) - print times can still be long but fewer layers
  3. Material is sold by the kg or tonne (pellets), not by the spool - far cheaper per kg

The time-based FDM model still applies, but constants change significantly. Shell layer count is typically 2-3, infill is often 15-25%, and support fraction from the hull gap may need a higher estimate for complex geometries (sparse supports, large overhangs).

Core methodology

Same as standard FDM:

  • Shell + infill + support volume split
  • Print time = volume ÷ volumetric flow rate, summed by region
  • Machine cost = time × cost per hour
  • Material cost = mass × cost per kg

Key differences in the constants:

ParameterDesktop FDMLarge Format FDM
Nozzle diameter0.4 mm5-10 mm
Layer height0.1-0.3 mm2-5 mm
Wall speed factor0.4-0.60.5-0.7
Material cost per kg€20-80€3-20 (pellets)
Machine cost per hour€5-15€40-150

Numerical example

Part: 600 × 400 × 300 mm enclosure panel, volume = 4,800,000 mm³ (hollow walls)

ParameterValue
Nozzle diameter8 mm
Layer height4 mm
Wall count2
Base speed120 mm/s
Wall speed factor0.6
Infill (15%)0.15
Machine cost per hour€80
Material cost per kg€8 (ABS pellets), density 1.04 g/cm³

Shell volume: min(4.8M, area × 8 × 2) - area depends on geometry Print time estimate: ~6 hours (large nozzle deposits fast) Machine cost: 6 × 80 = €480 Material cost: ~5 kg × 8 = €40 Unit price: ~€520 + overhead

Complete algorithm

const { material, width, height, length, volume, area, convexHullVolume, infill } = specification
const { quantity } = requisition

// Large format machine — adjust to your system
const MACHINE_BED_L = 2000
const MACHINE_BED_W = 1500
const MACHINE_BED_H = 1000

const NOZZLE_DIAMETER_MM  = material.variables['nozzleDiameterMm']  // e.g. 8
const NUMBER_OF_WALLS     = 2
const SUPPORT_INFILL      = 0.15
const PRINT_TIME_OVERHEAD = 1.25

// Layer height in mm. Do not read it from precision: precision.value is a price multiplier.
const layerHeight = 4.0
const partInfill  = infill?.value ?? 0.15

const shellVolume   = Math.min(volume, area * NOZZLE_DIAMETER_MM * NUMBER_OF_WALLS)
const infillVolume  = (volume - shellVolume) * partInfill
const hullGap       = (convexHullVolume ?? volume) - volume  // convexHullVolume can be null
const supportVolume = variable('supportVolume', round(hullGap * 0.15, 0))

const materialDensity   = material.variables['materialDensity']
const materialCostPerKg = material.variables['materialCostPerKg']
const totalVolumeMm3    = shellVolume + infillVolume + supportVolume * SUPPORT_INFILL
const massKg = (totalVolumeMm3 / 1_000_000) * materialDensity
const materialCost = round(massKg * materialCostPerKg, 2)

const baseSpeed          = material.variables['baseSpeedNozzle']
const wallSpeedFactor    = material.variables['wallSpeedFactor']
const infillSpeedFactor  = material.variables['infillSpeedFactor']
const supportSpeedFactor = material.variables['supportSpeedFactor']
const machineCostPerHour = material.variables['machineCostPerHour']

const wallTime    = shellVolume  / (NOZZLE_DIAMETER_MM * layerHeight * baseSpeed * wallSpeedFactor)
const infillTime  = infillVolume / (NOZZLE_DIAMETER_MM * layerHeight * baseSpeed * infillSpeedFactor)
const supportTime = (supportVolume * SUPPORT_INFILL) / (NOZZLE_DIAMETER_MM * layerHeight * baseSpeed * supportSpeedFactor)
const shellPenalty = 1 + 0.3 * Math.pow(shellVolume / (shellVolume + infillVolume + 1), 2)
const printTimeHours = variable('printTime', round(
  (wallTime + infillTime + supportTime) * PRINT_TIME_OVERHEAD * shellPenalty / 3600, 2
))

const machineCost = round(printTimeHours * machineCostPerHour, 2)
const baseCost    = materialCost + machineCost
const unitPrice   = variable('unitPrice', round(baseCost, 2))

const oversized = length > MACHINE_BED_L || width > MACHINE_BED_W || height > MACHINE_BED_H
done(unitPrice, printTimeHours, oversized)

Material variables: nozzleDiameterMm, materialDensity, materialCostPerKg, baseSpeedNozzle, wallSpeedFactor, infillSpeedFactor, supportSpeedFactor, machineCostPerHour

When to use this

Pellet extrusion systems printing parts larger than ~400mm. Parts are typically structural, prototypes, tooling, moulds, or formwork - where surface finish is secondary to speed and size.

SLA, DLP and LCM

Why this process is unique

Vat photopolymerisation (SLA, DLP, LCD, LCM) cures liquid resin layer by layer using UV light. Cost has two components:

  • Resin: sold by the litre, significantly more expensive than FDM filament
  • Machine time: layer count × time per layer × cost per hour

Supports are mandatory for most prints. They consume resin and add post-processing time (removal, sanding). Unlike FDM, supports in vat processes are separate structures added by the slicer - estimate from the convex hull gap.

SLA vs DLP - the critical pricing distinction

SLA and DLP cure resin fundamentally differently. This changes how time per layer behaves and has direct consequences for pricing.

SLADLP / MSLA / LCM
How it worksLaser traces the contour and fill of each layer point by pointUV projector or masked screen exposes the entire layer simultaneously
Time per layerScales with cross-sectional area - more to scan = longerFixed exposure time regardless of layer area or part count
Packing more partsEach additional part increases cross-section to scan, so each layer takes longerNearly free - same exposure time whether 1 or 10 parts fill the plate
timePerLayer in your equationCalibrate per typical part size, or calculate from areaSet as a fixed constant for your machine and resin

For SLA: print time grows with both layer count and the amount the laser has to trace per layer. Nesting more parts on the build plate can reduce per-part machine cost, but only up to a point - each added part increases the cross-section to scan, making every layer slower. On large or dense plates the benefit of nesting shrinks significantly.

For DLP / MSLA / LCM: the projector flashes the entire layer at once. Packing more parts onto the plate does not increase time per layer at all - nesting is almost always a win.

Warning

The algorithm below uses a fixed timePerLayer - correct for DLP/MSLA/LCM. For SLA, see Adapting for SLA.

Core methodology

Resin volume: actual part volume + estimated support volume + waste

Print time: numberOfLayers × timePerLayer. The part is usually oriented at an angle (45°) to minimise layer count and support contact area.

Orientation effect: at 45°, the effective print height = longest dimension × cos(45°) ≈ longest × 0.707

Numerical example

Part: 50 × 30 × 80mm bracket, volume = 30,000 mm³, convexHullVolume = 35,000 mm³, area = 12,000 mm²

ParameterValue
resinCostPerLiter€95
machineCostPerH€12
Layer height0.06 mm
Time per layer25 s

Resin volume:

  • Part: 30,000 mm³
  • Supports: (35,000 − 30,000) × 0.10 = 500 mm³
  • Waste: 12,000 mm² × 0.05 = 600 mm³
  • Total: 31,100 mm³ = 0.0311 L
  • Resin cost: 0.0311 × 95 = €2.95

Print time:

  • maxDim = 80mm, at 45°: height = 80 × 0.7071 = 56.57mm
  • Layers: ceil(56.57 / 0.06) = 943
  • Time: 943 × 25 / 3600 = 6.55 hours
  • Machine cost: 6.55 × 12 = €78.60

Unit price (1 part): €81.55

Complete algorithm

const { material, width, height, length, volume, area, convexHullVolume } = specification
const { quantity } = requisition

// Chamber limits
const CHAMBER_LENGTH = 220
const CHAMBER_WIDTH  = 125
const CHAMBER_HEIGHT = 200

const LAYER_HEIGHT_MM = 0.06

const resinCostPerLiter = material.variables['resinCostPerLiter']
const machineCostPerH   = material.variables['machineCostPerH']

// Resin volume: part + supports + waste
const supportVolumeMm3 = ((convexHullVolume ?? volume) - volume) * 0.10  // convexHullVolume can be null
const wasteVolumeMm3   = area * 0.05
const totalVolumeLiters = (volume + supportVolumeMm3 + wasteVolumeMm3) / 1_000_000
const materialCost = round(totalVolumeLiters * resinCostPerLiter, 2)

// Print time: parts are tilted 45° to minimise Z height
const maxDimension    = Math.max(width, height, length)
const heightAt45Deg   = maxDimension * Math.cos(45 * (Math.PI / 180))
const numberOfLayers  = Math.ceil(heightAt45Deg / LAYER_HEIGHT_MM)
const timePerLayer    = variable('timePerLayer', 25)  // seconds, override for different resins
const printTimeHours  = variable('printTime', round(numberOfLayers * timePerLayer / 3600, 2))
const machineCost     = round(printTimeHours * machineCostPerH, 2)

// Pricing
const getDiscount = createBands({ 5: 0.95, 10: 0.90, 20: 0.875, 40: 0.85, 80: 0.825 }, 1.0)
const baseCost    = (materialCost + machineCost) * getDiscount(quantity)
const unitPrice   = variable('unitPrice', round(baseCost, 2))

const oversized = length > CHAMBER_LENGTH || width > CHAMBER_WIDTH || height > CHAMBER_HEIGHT
done(unitPrice, printTimeHours, oversized)

Material variables: resinCostPerLiter, machineCostPerH

Adapting for SLA

For SLA, replace the fixed timePerLayer with one that scales with cross-sectional area. The laser scans at a fixed speed, so more area = more time.

Estimating average cross-section:

The ratio volume / minBoundingBoxVolume tells you what fraction of the bounding box is actually solid. Apply that fill ratio to the XY footprint of the bounding box and you get the average cross-section the laser has to trace per layer:

avgCrossSection = (length × width) × (volume / minBoundingBoxVolume)
               = volume / height

This simplifies neatly: average cross-sectional area = total volume ÷ effective print height. No surface area involved - surface area is the outer skin, not the per-layer slice.

// Add minBoundingBoxVolume to the destructure at the top of the main algorithm.
// Average cross-section: fill ratio applied to XY bounding footprint
// Equivalent to volume / heightAt45Deg — derived from bbox fill ratio
const fillRatio          = volume / (minBoundingBoxVolume ?? length * width * height)  // can be null
const avgCrossSectionMm2 = length * width * fillRatio  // = volume / height

// Laser scan speed in mm2/s — set as a material variable for your machine
const scanSpeedMm2PerSec = material.variables['scanSpeedMm2PerSec']  // e.g. 1000

const timePerLayerSLA = variable('timePerLayer', round(avgCrossSectionMm2 / scanSpeedMm2PerSec, 2))
const printTimeHours  = variable('printTime', round(numberOfLayers * timePerLayerSLA / 3600, 2))

For SLA you should also treat nesting conservatively: each additional part on the plate adds its cross-section to every shared layer, so packing many large parts can make the machine cost per part increase rather than decrease.

When to use this

All UV vat processes. For DLP / MSLA / LCM: use the main algorithm as-is with a fixed timePerLayer. For SLA: use the adapted version above with scanSpeedMm2PerSec as a material variable.

Metal LPBF (SLM and DMLS)

Why this process is unique

Laser Powder Bed Fusion (LPBF) - also called SLM, DMLS is expensive AM process to run. Cost is dominated almost entirely by machine time, not material.

Key characteristics:

  • Machine cost per hour: €80-250+ (inert gas consumption, laser wear, maintenance)
  • Layer heights: 0.02-0.06mm - far thinner than polymer processes
  • Print speeds: much slower than MJF or FDM per cm³
  • Supports are mandatory and made of metal - dense, slow to print, costly to remove
  • Heat treatment (stress relief, HIP) is typically mandatory post-process
  • Material is expensive: Ti-6Al-4V ~€300-500/kg, 316L ~€80-120/kg, Inconel ~€400+/kg

Despite high material costs, machine time typically accounts for 60-80% of a metal part's price.

Core methodology

Use a simplified time model based on build volume and laser scanning speed:

Print time = (layer count × area per layer) ÷ scan speed + overhead

Or, simpler and nearly as accurate for quoting:

Print time ≈ (shrinkWrapVolume + support volume) ÷ build rate

Where buildRate = mm³/hour of actual metal deposited (a material variable, calibrated per machine and material).

Numerical example

Part: 30 × 30 × 60 mm bracket, volume = 10,000 mm³, convexHullVolume = 13,000 mm³

ParameterValue
Material: 316L stainless steel
Density7.9 g/cm³
Material cost per kg€100
buildRateMm3PerHour5,000
machineCostPerHour€130
setupCost€150

Support volume: (13,000 − 10,000) × 0.40 = 1,200 mm³ (dense metal supports) Print volume: 10,000 + 1,200 = 11,200 mm³ Print time: 11,200 / 5,000 = 2.24 hours Machine cost: 2.24 × 130 = €291.20 Material mass: (10,000 / 1,000) × 7.9 / 1,000 = 79g = 0.079 kg Material cost: 0.079 × 100 = €7.90 Setup (1 part): €150 Total: €449.10 - machine time is 65% of cost

Complete algorithm

const { material, volume, convexHullVolume, length, width, height } = specification
const { quantity } = requisition

// Chamber limits — adjust to your machine (e.g. EOS M290 = 250×250×325mm)
const CHAMBER_LENGTH = 250
const CHAMBER_WIDTH  = 250
const CHAMBER_HEIGHT = 325

const buildRateMm3PerHour = material.variables['buildRateMm3PerHour']
const machineCostPerHour  = material.variables['machineCostPerHour']
const setupCost           = material.variables['setupCost']
const materialDensity     = material.variables['materialDensity']
const materialCostPerKg   = material.variables['materialCostPerKg']

// Support volume (metal supports are denser than FDM — use 35–45%)
const hullGap       = (convexHullVolume ?? volume) - volume  // convexHullVolume can be null
const supportVolume = variable('supportVolume', round(hullGap * 0.40, 0))

// Print time based on build rate
const printVolume    = volume + supportVolume
const printTimeHours = variable('printTime', round(printVolume / buildRateMm3PerHour, 2))
const machineCost    = round(printTimeHours * machineCostPerHour, 2)

// Material cost (part only, not support — support is removed)
// volume in mm³. density in g/cm³. 1 cm³ = 1000 mm³
const massGrams      = (volume / 1000) * materialDensity
const materialCost   = round((massGrams / 1000) * materialCostPerKg, 2)

// Setup amortised (typically one part per build for LPBF unless batch run)
const setupPerPart = round(setupCost / quantity, 2)

const baseCost  = machineCost + materialCost + setupPerPart
const unitPrice = variable('unitPrice', round(baseCost, 2))

const oversized = length > CHAMBER_LENGTH || width > CHAMBER_WIDTH || height > CHAMBER_HEIGHT
// Also flag open mesh — geometry errors cause metal build failures
const reviewRequired = oversized || !revision.watertight
done(unitPrice, printTimeHours, reviewRequired)

Material variables: buildRateMm3PerHour, machineCostPerHour, setupCost, materialDensity, materialCostPerKg

When to use this

All laser powder bed fusion of metals: SLM, DMLS, LPBF, DMP. Works for steel, titanium, aluminium, Inconel, copper. Adjust buildRateMm3PerHour and machineCostPerHour per alloy and machine.

Ceramics LCM

Why this process is unique

Lithography-based Ceramic Manufacturing (LCM, developed by Lithoz) is vat photopolymerisation with ceramic-loaded slurry instead of standard resin. After printing, parts undergo debinding and sintering - burning off the polymer binder and fusing the ceramic particles.

Key pricing characteristics:

  • Material is expensive: zirconia slurry is €2,000-5,000+ per litre, but small parts use very little of it, so machine time usually dominates the price
  • Parts shrink: ~20% linear shrinkage during sintering. Geometry should be scaled up before printing, but this is the operator's concern, not the equation's.
  • Small parts: ceramic parts are typically small and intricate (dental, medical, industrial nozzles)
  • Print time similar to SLA: layer-based exposure, fixed time per layer
  • Sintering is a separate step: typically handled in post-process pricing, not Level 1

Core methodology

Same structure as SLA/DLP, but:

  • resinCostPerLiter is much higher (ceramic slurry price)
  • Support fraction from hull gap is smaller (ceramics parts often have fewer overhangs due to design constraints)
  • Machine cost is usually the largest part of the price

Numerical example

Part: 10 × 8 × 15 mm dental crown, volume = 300 mm³, convexHullVolume = 500 mm³

ParameterValue
slurryCostPerLiter€3,200
machineCostPerH€18
Layer height0.025 mm
Time per layer30 s

Resin volume: 300 mm³ + supports (500 − 300) × 0.05 = 310 mm³ = 0.00031 L

Material cost: 0.00031 × 3,200 = €0.99

Layers: tilted 45°, 15 × 0.7071 = 10.61 mm → ceil(10.61 / 0.025) = 425

Print time: 425 × 30 / 3600 = 3.54 hours

Machine cost: 3.54 × 18 = €63.72

Unit price (1 part): €64.71 - material is only 1.5% of cost at this scale

For larger parts (50mm+) material cost grows but machine time still dominates.

Complete algorithm

const { material, volume, area, convexHullVolume, length, width, height } = specification
const { quantity } = requisition

// Lithoz CeraFab S65 chamber: 76 × 43 × 150 mm
const CHAMBER_LENGTH = 76
const CHAMBER_WIDTH  = 43
const CHAMBER_HEIGHT = 150

const LAYER_HEIGHT_MM = 0.025

const slurryCostPerLiter = material.variables['slurryCostPerLiter']
const machineCostPerH    = material.variables['machineCostPerH']

// Material
const supportVolumeMm3 = ((convexHullVolume ?? volume) - volume) * 0.05  // fewer supports; hull can be null
const totalVolumeLiters = (volume + supportVolumeMm3) / 1_000_000
const materialCost = round(totalVolumeLiters * slurryCostPerLiter, 2)

// Print time
const maxDimension   = Math.max(width, height, length)
const heightAt45Deg  = maxDimension * Math.cos(45 * (Math.PI / 180))
const numberOfLayers = Math.ceil(heightAt45Deg / LAYER_HEIGHT_MM)
const timePerLayer   = variable('timePerLayer', 30)  // seconds
const printTimeHours = variable('printTime', round(numberOfLayers * timePerLayer / 3600, 2))
const machineCost    = round(printTimeHours * machineCostPerH, 2)

// Pricing
const getDiscount = createBands({ 5: 0.95, 20: 0.90, 50: 0.85 }, 1.0)
const baseCost  = (materialCost + machineCost) * getDiscount(quantity)
const unitPrice = variable('unitPrice', round(baseCost, 2))

const oversized = length > CHAMBER_LENGTH || width > CHAMBER_WIDTH || height > CHAMBER_HEIGHT
done(unitPrice, printTimeHours, oversized)

Material variables: slurryCostPerLiter, machineCostPerH

When to use this

LCM (Lithoz), ceramic DLP, or any slurry-based photopolymerisation. Typical applications: dental crowns, implants, industrial nozzles, filtration media, cutting tools.

CNC machining

This equation is a starting point, not a production-ready solution

CNC pricing depends heavily on your specific situation: your machine inventory, past job data, material contracts, surface finish requirements, and GD&T callouts (tolerances, datums, fits). A part with a tight positional tolerance or a mirror-polished bore costs fundamentally more to machine than the geometry alone suggests. Calibrate the rates in this equation against real jobs before relying on it for live quoting.

Feature recognition

For parts uploaded as an exact CAD model (B-rep), Phasio recognises holes, pockets, and machining setups. Your equation reads them from revision.machining (holeCount, pocketCount, holes[], pockets[], setups, finishing, warnings) and sheet metal bends from revision.bending. Both are null for mesh uploads. revision.machining is also null for a CAD file with no solid body and for a part too complex to analyse. Phasio does not recognise threads, chamfers, or rotational symmetry. The equation in this section uses only the volume fields, so it also works for mesh uploads. See the reference for every field.

Hole counting changed in the 2026-10-30 release: a chamfered through hole is counted once, and a bore interrupted by a cross hole now counts as a hole. If your equation uses holeCount or holes[], a part that is analysed again can be quoted at a different price.

Milling vs. turning

This equation prices milling by default, but turning (lathe) can be switched on programmatically based on geometry. A cylindrical part has two cross-sectional dimensions that are approximately equal - if width ≈ height, the part is likely rotationally symmetric and turning pricing applies.

// Detect likely turned parts: cross-section is roughly circular
const crossSectionRatio = Math.min(width, height) / Math.max(width, height)
const isLikelyCylindrical = crossSectionRatio > 0.85

Once a part is flagged as cylindrical, the stock and pricing logic changes:

  • Raw stock: a bar rather than a block - Math.PI * Math.pow(Math.max(width, height) / 2, 2) * length
  • Machining: dominated by turning speed, number of diameter steps, and facing passes rather than three-phase milling
  • Complexity: driven by how many diameter changes, undercuts, and threading operations are visible in the geometry

We've had good results pricing turned parts using this geometry-based switching approach. The key is using the cylindrical detection as a gate: parts that pass it get turning logic, everything else gets the milling model below.

Rotational symmetry is not detected

Phasio does not detect rotational symmetry or threads, so this check still infers a turned part from the bounding box. Hole and pocket data is available in revision.machining for exact CAD models.

Why this process is unique

CNC is subtractive: you start from a block of raw stock and remove everything that isn't the part. Unlike additive processes, cost is not primarily about part volume - it's about how much you remove, and how hard that removal is.

Not all material removal is equal. Roughing through open space is fast. Working close to the finished surface requires smaller tools, slower feeds, and more passes. This suggests splitting the removed volume into three phases based on geometric complexity:

PhaseVolume removedNature of work
CoarseBlock − convex hullBulk removal, large tooling, high MRR
MediumConvex hull − shrink wrapIntermediate features, recesses, overhangs
FineShrink wrap − part volumeSurface finish, detailed features, toleranced geometry

The convex hull is the coarse outer envelope of the part - all concave features are filled in. The shrink wrap follows the surface more tightly, capturing recesses but not sharp internal corners. Together they give you three geometrically-grounded milling volumes from fields Phasio already computes.

Factors geometry alone cannot capture - these require calibration or manual review:

  • GD&T callouts: tight tolerances, datum schemes, press fits, true position
  • Surface finish: Ra requirements, polishing, hard anodise, plating
  • Multi-axis setups: 5-axis simultaneous, turn-mill, multiple fixturings
  • Hard alloys: Inconel, titanium, hardened steel all reduce MRR significantly

Core methodology

Step 1 - Stock selection: filter your available block sizes to those that fit the part in any orientation, then pick the smallest. This determines raw material cost and the coarse milling volume.

Step 2 - Three milling phases: each phase uses a different cost-per-mm³ reflecting its MRR.

Why cost-per-mm³ rather than MRR × hourly rate

The equation uses direct cost-per-mm³ rates rather than MRR × hourly rate. The two are equivalent - e.g. 500 mm³/s at €72/hr = €0.00004/mm³. Volume rates are easier to calibrate from real job data.

Step 3 - Adjustments: precision multiplier (GD&T/tolerance level), quantity curve, minimum price floor.

Review gate: if the part doesn't fit any block, the equation calls done(0). A price of 0 sets reviewRequired automatically, so the customer cannot see the price or check out until you click Approve for Purchase on the quote. The equation also sets the review flag when convexHullVolume or shrinkWrapVolume is null, because the milling phases cannot be split without them.

Numerical example

Part: 70 × 35 × 35mm bracket, volume = 15,000 mm³, convexHullVolume = 25,000 mm³, shrinkWrapVolume = 18,000 mm³

Smallest fitting block: 75 × 75 × 75mm = 421,875 mm³

PhaseVolumeRateCost
Coarse421,875 − 25,000 = 396,875 mm³€0.00004/mm³€15.88
Medium25,000 − 18,000 = 7,000 mm³€0.0003/mm³€2.10
Fine18,000 − 15,000 = 3,000 mm³€0.001/mm³€3.00
Total€20.98

With a precision multiplier of 1.0 and quantity of 1 (multiplier 3× at single unit): €62.93. This is above the equation's default floor of €50 (Min price per part). Set the floor to match your cost base.

Complete algorithm

const { material, width, height, length, volume, convexHullVolume, shrinkWrapVolume, precision } = specification
const { quantity } = requisition

// Define your available raw stock sizes [x, y, z] in mm
// Add or remove blocks to match what your workshop actually carries
const blockSizes: [number, number, number][] = [
  [25,  25,  25],
  [50,  50,  50],
  [75,  75,  75],
  [100, 100, 100],
  [150, 125, 125],
  [150, 150, 150],
  [200, 200, 200],
]

// Check if a part fits a block in any orientation (sorts both ascending)
function canFit(spec: [number, number, number], block: [number, number, number]): boolean {
  const s = [...spec].sort((a, b) => a - b)
  const b = [...block].sort((a, b) => a - b)
  return s.every((d, i) => d <= b[i])
}

function blockVolume(b: [number, number, number]): number {
  return b[0] * b[1] * b[2]
}

// Find the smallest block the part fits in
function findBlock(): [number, number, number] | null {
  const fits = blockSizes.filter(b => canFit([width, height, length], b))
  if (fits.length === 0) return null
  return fits.reduce((smallest, b) => blockVolume(b) < blockVolume(smallest) ? b : smallest)
}

const bestBlock = findBlock()

// Cost rates per mm3 for each milling phase
// Calibrate these from your real job data
const coarseRate   = variable('Coarse cost per mm3', 0.00004)  // bulk removal
const mediumRate   = variable('Medium cost per mm3', 0.0003)   // intermediate features
const fineRate     = variable('Fine cost per mm3',   0.001)    // finishing and toleranced surfaces
const minPrice     = variable('Min price per part',  50)       // floor - adjust to your cost base

// Quantity multiplier: interpolates smoothly between tiers
// At qty=1 price is 3x the base; converges to 1x at qty=1000
function getQuantityMultiplier(qty: number): number {
  const tiers: [number, number][] = [
    [1,    3.0],
    [10,   2.3],
    [100,  1.9],
    [250,  1.6],
    [500,  1.4],
    [750,  1.1],
    [1000, 1.0],
  ]
  if (qty <= 1)    return tiers[0][1]
  if (qty >= 1000) return tiers[tiers.length - 1][1]
  for (let i = 0; i < tiers.length - 1; i++) {
    const [lo, loM] = tiers[i]
    const [hi, hiM] = tiers[i + 1]
    if (qty >= lo && qty <= hi) {
      const t = (qty - lo) / (hi - lo)
      return loM + (hiM - loM) * t  // linear interpolation
    }
  }
  return tiers[0][1]
}

if (bestBlock) {
  const rawBlockVolume = blockVolume(bestBlock)

  // convexHullVolume and shrinkWrapVolume can be null. Fall back so the phases
  // stay non-negative, and flag the part for review below.
  const missingVolumes = convexHullVolume === null || shrinkWrapVolume === null
  const wrapVolume     = shrinkWrapVolume ?? volume
  const hullVolume     = convexHullVolume ?? wrapVolume

  // Three milling phases
  const coarseVolume = rawBlockVolume - hullVolume  // bulk removal
  const mediumVolume = hullVolume     - wrapVolume  // intermediate features
  const fineVolume   = wrapVolume     - volume      // finishing

  const machiningCost = (coarseVolume * coarseRate)
                      + (mediumVolume * mediumRate)
                      + (fineVolume   * fineRate)

  // Precision multiplier: configure your precision settings in Phasio to return
  // a value >= 1 (e.g. Standard = 1.0, Fine = 1.5, Ultra = 2.0)
  const precisionMultiplier = precision?.value ?? 1

  const qtyMultiplier = variable('Quantity multiplier', round(getQuantityMultiplier(quantity), 3))

  const calculated = round(machiningCost * precisionMultiplier * qtyMultiplier, 2)
  const finalPrice = variable('Final price', calculated < minPrice ? minPrice : calculated)

  done({ price: finalPrice, reviewRequired: missingVolumes })
} else {
  // Part doesn't fit any block - done(0) triggers reviewRequired automatically
  done(0)
}

Material variables: none required - all rates are exposed via variable() so the operator can override them per part line. Move rates to material.variables if they differ per material.

When to use this

3-axis and 5-axis CNC milling. Adjust the three cost rates to reflect your machine's actual MRR and hourly rate for each phase. Harder materials (Inconel, titanium) need lower MRRs - increase mediumRate and fineRate accordingly. Softer materials (aluminium, plastics) can use higher MRRs and lower rates.

Vacuum casting

Why this process is unique

Vacuum casting produces polyurethane parts from a silicone mould. The mould is made from a master pattern (typically SLA-printed). Cost has two distinct components that behave very differently with quantity:

  1. Mould cost: a one-time charge (or amortised over the mould's lifespan). Each silicone mould typically lasts 15-25 shots before degrading.
  2. Casting cost per part: polyurethane material + operator time + mixing, curing, and demoulding.

At low quantities (1-5), mould amortisation dominates. At high quantities (20+), you need a second mould and the per-part cost levels out.

Typical applications: functional prototypes, enclosures, medical devices, over-moulded parts.

Core methodology

Mould cost per part: mouldCost / min(quantity, mouldLifespan)

If quantity > mouldLifespan: additional moulds are needed. Each mouldLifespan parts uses one mould.

Casting cost: material volume × PU cost/litre + fixed operator time per cast

Numerical example

Part: 100 × 60 × 30mm housing, volume = 50,000 mm³

ParameterValue
mouldCost€600
mouldLifespan20 shots
castingCostPerPart€18 (PU material + labour)
Quantity5

Mould per part: 600 / 5 = €120

Casting cost: €18

Unit price: €138

At qty 20: mould = 600/20 = €30. Unit price = €48.

At qty 40: two moulds needed. Mould = 2 × 600 / 40 = €30. Same unit price. (Correctly handled by the formula below.)

Complete algorithm

const { material, volume, length, width, height } = specification
const { quantity } = requisition

const mouldCost         = material.variables['mouldCost']
const mouldLifespan     = material.variables['mouldLifespan']  // shots per mould
const castingCostPerPart = material.variables['castingCostPerPart']

// How many moulds are needed?
const numberOfMoulds = Math.ceil(quantity / mouldLifespan)
const totalMouldCost  = numberOfMoulds * mouldCost
const mouldPerPart    = round(totalMouldCost / quantity, 2)

const baseCost  = mouldPerPart + castingCostPerPart
const unitPrice = variable('unitPrice', round(baseCost, 2))

// Flag parts that need master pattern creation (charged separately as setup)
const largePartFlag = Math.max(length, width, height) > 400
done({ price: unitPrice, reviewRequired: largePartFlag })

Note: If you charge separately for the master pattern (SLA print), add that as a Level 3 line item or a separate process quote.

Material variables: mouldCost, mouldLifespan, castingCostPerPart

When to use this

Any silicone-moulded polyurethane casting process. Works for single-component and two-component PU. For injection moulding (steel tooling), the same structure applies but mouldCost is €5,000-200,000 and mouldLifespan is 10,000-100,000+.

Last updated on

On this page

Before you build1. What are your main cost drivers?2. Do you have historical job data to calibrate against?3. What does your minimum price look like?4. Quantity: do you offer discounts, and what does the curve look like?5. What machines do you have, and how do you assign jobs to them?6. What material variables will your equation need?7. What should trigger manual review?8. What should operators be able to override per part line?9. What lead times do you offer, and do they affect price?10. Do you have customer-specific pricing?11. What post-processes attach to this process?When you're readyPowder bed (SLS and MJF)Why this process is uniqueCore methodologyHP MJF 5200 Pro specifications (reference)Numerical exampleComplete algorithmWhen to use thisFDM filament extrusionWhy this process is uniqueCore methodologyNumerical exampleComplete algorithmWhen to use thisLarge format FDMWhy this process is uniqueCore methodologyNumerical exampleComplete algorithmWhen to use thisSLA, DLP and LCMWhy this process is uniqueSLA vs DLP - the critical pricing distinctionCore methodologyNumerical exampleComplete algorithmAdapting for SLAWhen to use thisMetal LPBF (SLM and DMLS)Why this process is uniqueCore methodologyNumerical exampleComplete algorithmWhen to use thisCeramics LCMWhy this process is uniqueCore methodologyNumerical exampleComplete algorithmWhen to use thisCNC machiningMilling vs. turningWhy this process is uniqueCore methodologyNumerical exampleComplete algorithmWhen to use thisVacuum castingWhy this process is uniqueCore methodologyNumerical exampleComplete algorithmWhen to use this