Optimal Chips: N/A
The Die Per Wafer (DPW) calculator is a computational tool designed to address key challenges in semiconductor manufacturing. By factoring in critical parameters such as wafer diameter, chip dimensions, edge exclusions, and inter-die spacing, the calculator provides accurate estimates of maximum chip yield per wafer. This tool is particularly valuable for semiconductor engineers and designers, offering a practical solution for optimising wafer utilisation and reducing production waste.
Behind the scenes, the DPW calculator employs multiple algorithms to map and optimise die placement on a wafer. The Geometric symmetry approach uses geometric alignment techniques, ensuring uniform die placement while minimizing waste. By managing edge exclusions, grid shifts, and symmetrical constraints, this method provides a precise and predictable solution suitable for standard manufacturing scenarios.
For more complex and dynamic needs, the DPW calculator incorporates a Greedy + Simulated Annealing (SA) algorithm. The greedy phase generates an initial solution by filling the wafer with as many dies as possible while adhering to spacing and exclusion rules. Simulated Annealing then iteratively refines the solution, exploring alternative configurations and optimising for maximum yield. This approach is particularly effective in scenarios with irregular constraints or high demands for die density. The solution, however, is more unstable and is not guaranteed to perform better than the simpler geometrical solution.
function calculateSymmetrical() {
initialize wafer parameters:
waferDiameter, chipWidth, chipHeight, spacing, edgeExclusion
generate grid shift options:
shifts = [ {xShift: 0, yShift: 0}, {xShift: spacing/2, yShift: spacing/2} ]
bestDpw = 0
bestPositions = []
for each shift in shifts:
initialize dpw = 0
initialize positions = []
for each row:
for each column:
calculate (x, y) based on chip size and shift
if (x, y) lies inside wafer usable radius:
check overlap with edge exclusions
if valid:
add (x, y) to positions
dpw++
if dpw > bestDpw:
bestDpw = dpw
bestPositions = positions
return {bestDpw, bestPositions}
}
function greedySimulatedAnnealing() {
initialize wafer parameters:
waferDiameter, chipWidth, chipHeight, spacing, edgeExclusion
initialize temperature = 1.0
initialize coolingRate = 0.9
initialize maxIterations = 250
radius = calculate usable radius of wafer
chipWidthWithSpacing = chipWidth + spacing
chipHeightWithSpacing = chipHeight + spacing
currentSolution = greedy placement:
generateInitialSolution(radius, chipWidthWithSpacing, chipHeightWithSpacing)
bestSolution = copy(currentSolution)
bestDpw = evaluateSolution(currentSolution, radius)
for iteration from 1 to maxIterations:
newSolution = perturb currentSolution:
randomly move one chip to a nearby valid position
ensure no overlaps or spacing violations
newDpw = evaluateSolution(newSolution, radius)
if newDpw > bestDpw:
bestSolution = copy(newSolution)
bestDpw = newDpw
currentSolution = copy(newSolution)
else:
calculate acceptance probability:
delta = newDpw - bestDpw
probability = exp(delta / temperature)
if random() < probability:
accept newSolution as currentSolution
reduce temperature:
temperature = temperature * coolingRate
return {bestDpw, bestSolution}
}
function generateInitialSolution(radius, chipWidthWithSpacing, chipHeightWithSpacing) {
initialize positions = []
for each row:
for each column:
calculate (x, y) for the chip
if (x, y) lies inside wafer usable radius and satisfies spacing:
add (x, y) to positions
return positions
}
function perturbSolution(solution, chipWidthWithSpacing, chipHeightWithSpacing) {
copy solution to newSolution
randomly select one chip in newSolution
randomly move the chip within spacing constraints
ensure no overlap or invalid positions
return newSolution
}
function evaluateSolution(solution, radius) {
count chips in solution that lie inside the usable wafer radius
return count
}