This page contains a listing of available variables for Machine Runtime pricing and sample pricing scripts for different technologies.

For a general overview of how Pricing Scripts work, read General Rules for Pricing Scripts.

Machine cost is calculated by multiplying the time it takes to print out a model by the hourly machine use rate. The hourly rate depends on many factors such as printer price, maintenance cost, depreciation period, and so on. The formula for calculating the machine time will be different for different technologies, as various factors impact the printing time in a way that is usually technology-dependent.

General Format for Machine Hourly Rate Calculation

The basic format that we recommend for your Javascript pricing code is:

let priceOfMachine = 200000;         // $ or €
let usefulLife = 7;                  // years
let maintenance = 40000;             // $ or €
let powerConsumption = 10000;        // $/year or €/year
let roomCost = 4000;                 // $/year/m^2 or year €/year/m^2

let space = 10;                      // $/year or €/year
let spareParts = 2000;               // $/year or €/year
let gasUsage = 0;                    // $/year or €/year
let workingHoursPerYear = 3500;      // h/year

// Don't change the following lines
let hourlyRate = ((priceOfMachine + maintenance)/usefulLife + powerConsumption +
roomCost*space + spareParts + gasUsage)/workingHoursPerYear;

Sample Machine Time Pricing Scripts

FDM Machine Time Formula

Fused deposition modeling (FDM) is one of the most widely used additive manufacturing processes for fabricating prototypes and functional parts in common plastic engineering.

Three factors have the largest impact on the printing time in the case of FDM: model's volume, surface area (related to the amount of material used to print the walls, which usually take more time to print than the infill) and support. Furthermore, we assume that, when printing larger quantities of models, the total machine time will be simply a sum of unit printing times of each of the models in the building chamber, as the height of the model should influence the time in a negligible way.

let lineWidth = 0.1;              // mm
let layerHeight = 0.1;            // mm
let speed = 45;                   // mm/s
let infill = 0.2;                 // number in [0,1]
let wallThickness = 2;            // mm
let supportInfill = 0.2;          // number in [0,1]

let volumeFactor = 0.0010747;     // number, describes importance of model's volume
let areaFactor = 0.04317783;      // number, describes importance of model's surface area
let supportFactor = 0.0003774;    // number, describes importance of support volume

// Don't change the following lines
let exponent;
if( model.volume < 3000){
        exponent = 0.55;
} else {
        exponent = 0.88;
        }

let volumePart = volumeFactor*(0.818182 - lineWidth)*(Math.pow(layerHeight, (-1.07)) +
0.232)*(Math.pow(speed, (-1.08)))*(Math.pow(infill*100, (1.02)))*model.volume;

let areaPart = areaFactor*(1.578431 - lineWidth)*(Math.pow(layerHeight, (-0.98)) + 0.341)*
(Math.pow(wallThickness, exponent) + 0.002)*(Math.pow(speed, (-0.84)) +
0.003)*model.area;

let supportPart =  supportFactor*supportInfill*support.volume;

let time = volumePart + areaPart + supportPart; // time in minutes

let machineTime = time/60;                      // time in hours

SLS Material Pricing based on Machine Runtime

Two factors will have an impact on the machine time: the model's volume that needs to be sintered, and the model's height, as consecutive layers will require the machine to lower the powder bed and put new material on the platform. Furthermore, in the case of more than one model being placed on the platform, the total machine time will not be simply a sum of unit printing times, as adding new parts of lower or the same height as the tallest model will not change the time related to preparation of all layers required to print all parts.

//Material variables
let materialCost = 60;             // euro/kg
let density = 1.02;                // g/cm^3
let margin = 1;                    // total price is multiplied with margin

//Machine time variables
let scanningSpeed = 45;            // mm/s
let laserDiameter = 0.1;           // mm
let layerHeight = 0.2;             // mm
let layerPreparationTime = 10;     // sec
let machineRate = 50;              // euro/hour

// Material cost calculation
let material = model.volume * materialCost * density * 0.000001;

// Don't change the following lines
// Machine runtime cost calculation in hour
let numberOfLayers = model.h/layerHeight;
let machineTime = (model.volume/(scanningSpeed*laserDiameter*layerHeight) +
layerPreparationTime*numberOfLayers/item.quantity)/3600;

let machine = machineTime * machineRate;
//Total price: material price plus machine runtime cost
let price = margin * (material + machine);

price;

DMLS/SLM Material Pricing based on Machine Runtime

DMLS/SLM is a process very similar to SLS with one important difference: despite the fact that the technology utilises a laser-sintered powder, which for plastic materials serves as a support structure, all metal-printed parts need to have support structures attached, playing various roles in the process.

Therefore, three factors will have an impact on the machine time: model's volume, height and support. In full analogy to the SLS, the total machine time will not be the sum of unit printing times due to the fact that the height is taken into account when computing the machine time.

//Material variables
let materialCost = 180;             //euro/kg
let density = 4.43;                 //g/cm^3

//Machine time variables
let scanningSpeed = 40;              // mm/s
let supportScanningSpeed = 40;       // mm/s
let laserDiameter = 0.1;             // mm
let layerHeight = 0.1;               // mm
let layerPreparationTime = 10;       // sec
let supportInfill = 0.2;             // number in [0,1]
let hourlyRate = 35;                 //euro/hour

// Material price calculation
let materialVolume = model.volume + support.volume * supportInfill;
let material = density * materialVolume * materialCost / 1000000;

// Machine runtime cost calculation in hour
let numberOfLayers = model.h/layerHeight;
let machineTime = ((model.volume)/(scanningSpeed*laserDiameter*layerHeight) +
support.volume*supportInfill/(supportScanningSpeed*laserDiameter*layerHeight) +
layerPreparationTime*numberOfLayers/item.quantity)/3600;

let machine = hourlyRate * machineTime;
let price = machine + material;

// Last line must contain final price
price;

MJF Material Pricing based on Machine Runtime

This process is similar to SLS, the main difference being the heat source. SLS uses a laser to scan and sinter each cross-section, while in MJF an ink (fusing agent) is dispensed on the powder that promotes the absorption of infrared light. An infrared energy source then passes over the building platform and fuses the inked areas. In SLS each cross section is fused point-by-point, while in MJF fusing happens in a line-wise fashion.

Due to this fusing, it is actually unimportant how many models are placed in the building chamber; the only factor that should matter is the height of the tallest model, as it determines the overall number of layers.

//Material variables
let materialCost = 60;           // euro/kg
let density = 1.02;              // g/cm^3
let margin = 1;                  // total price is multiplied with margin

//Machine time variables
let singleLayerPrintTime = 15;   // sec
let layerHeight = 0.2;           // mm
let machineRate = 50;            // euro/hour

// Material cost calculation
let material = model.volume * materialCost * density * 0.000001;

// Don't change the following lines
// Machine runtime cost calculation
let numberOfLayers = model.h/layerHeight;
let machineTime = (singleLayerPrintTime * numberOfLayers/item.quantity) / 3600;
let machine = machineTime * machineRate;

//Total price: material price plus machine runtime cost
let price = margin * (material + machine);

price;

CLIP Material Pricing based on Machine Runtime

//Material variables
let materialCost = 60;             // euro/kg
let density = 1.02;                // g/cm^3
let margin = 1;                    // total price is multiplied with margin

//Machine time variables
let maxXYSurface = 1000;        // xy surface of the printer in mm^2
let timePerHeight = 10;         // h/mm model's height
let machineRate = 50;              // euro/hour

// Material cost calculation
let material = model.volume * materialCost * density * 0.000001;

// Don't change the following lines
// Machine runtime cost calculation in hour
let machineTime = (model.h*timePerHeight)*((model.w*model.d)/maxXYSurface);

let machine = machineTime * machineRate;
//Total price: material price plus machine runtime cost
let price = margin * (material + machine);

price;