Introduction
Process performance metrics are important to determine the performance
capability (of a process) in terms of customer requirements. Process performance
can be determined via the following ways:
 Via DPMO (Defect per Million Opportunity)
 Via PPM (Part per Million)
 Via Yield
 Via Ztransformation
This is the third of a four part series that determines Process Performance. For the first part (via DPMO), please see
Process Performance Determination in C#. For the second part (via PPM), please see
Process Performance Determination in C# Part 2.
Background
This article describes how to determine the process performance from Yield.
The Yield metric is a measure of proportion of good unit in
a process found by:
Yield = Number of Good units / number of unit processed (Equation 1)
However there are some connections between:
 Yield and DPO (see
here for explanation of DPO)
 Yield and DPU (see
here for explanation of DPU)
Connection between Yield and DPO is shown as follows:
Yield (from DPO) = 1 − DPO (Equation 2)
And connection between Yield and DPU (assume Poisson distribution) is shown
as follows:
Yield (from DPU) = exp(−DPU) (Equation 3)
Using the example in
part 1 and
part 2,
a process produces 40,000 pencils. Three types of defects can occur. The number of occurrences of each defect
type is:
 Blurred printing: 36
 Too long: 118
 Rolled ends: 11
Total number of defects: 165
From the example above, DPO = 0.0006875 (see part 1), and DPU = 0.004125 (see
part 2). Thus,
Yield = (40000  165) / 40000 = 0.995875
Yield (from DPO) = 1  0.0006875 = 0.999313
Yield (from DPU) = exp(0.004125) = 0.995883
If we know the number of good units and number of units processed, we can
calculate Yield using Equation 1. In the case where number of good parts cannot
be determined, but DPO is known, we can calculate Yield using Equation 2.
Rolled Throughput Yield (RTY)
The RTY metric represents the percentage of units of product passing defect
free through an entire process. It is determined by the multiplying firstpass
yields (FPY) from each subprocess of the total process as follows:
Yield (RTY) = Yield (subprocess 1) x Yield (subprocess 2) x ... x Yield (subprocess n)
(Equation 4)
The concept of the RTY is illustrated by the following example, which depicts
an overall process comprised of four subprocesses. Suppose the FPY of each
subprocess is 0.95. Then, the RTY is computed as:
RTY = 0.95 x 0.95 x 0.95 x 0.95 = 0.81 or 81%
Although individual subprocess yields are relatively high, the total process
yield has dropped significantly. A significant advantage of using the RTY metric
is that it provides a more complete view of the process. Subprocess yields that
run high aren’t likely to garner the attention necessary to drive improvement.
Often, it is only when the total process yield becomes visible does real action
occur.
The code shown in this article provides calculation of Yield (as proportion
of good units), Yield (from DPO) and Yield (from DPU). They can be seen as each
FPY in Equation 4.
Requirement
To run the code, you need to have the following:
 .NET Framework 2.0 and above
 Microsoft Visual Studio 2005 if you want to open the project files
included in the download project
 Nunit 2.4 if you want to run the unit tests included in the
download project
Using the Code
We envisage that the user will perform the following code to get the desired
results. This involves a simple 4steps process:
 Instantiate a
ProcessPerformanceFrYield
object
 Input
NumOfUnitProcessed
and NumOfGoodUnits
, or
 DPO, or
 DPU
 Invoke its
.Analyze()
method
 Retrieve results from its .Result object.
Here are some typical user’s code:
ProcessPerformanceFrYield y = new ProcessPerformanceFrYield();
y.NumOfUnitProcessed = 40000;
y.NumOfGoodUnits = 39835;
y.Analyze();
Console.WriteLine("Yield is: " + y.Result.Yield);
Console.WriteLine("Yield in % is: " + y.Result.YieldInPercent);
Console.WriteLine("Non conforming in % is: " + y.Result.NonConformingPercent);
ProcessPerformanceFrYield yFrDPO = new ProcessPerformanceFrYield();
yFrDPO.DPO = 0.0006875;
yFrDPO.Analyze();
Console.WriteLine("Yield (fr DPO) is: " + yFrDPO.Result.YieldFrDPO);
ProcessPerformanceFrYield yFrDPU = new ProcessPerformanceFrYield();
yFrDPU.DPU = 0.004125;
yFrDPU.Analyze();
Console.WriteLine("Yield (fr DPU) is: " + yFrDPU.Result.YieldFrDPU);
Two classes are implemented:
ProcessPerformanceFrYieldResult
ProcessPerformanceFrYield
ProcessPerformanceFrYieldResult
is a class from which a result object derives,
which holds the analysis results. In our implementation, the .Result
member
variable is defined as follows:
public class ProcessPerformanceFrYieldResult
{
public ProcessPerformanceFrYieldResult() { }
public double NonConformingPercent;
public double YieldInPercent;
public double Yield;
public double YieldFrDPU;
public double YieldFrDPO;
}
The following table lists the available results, assuming that the ProcessPerformanceFrYield
object name you use are y (for Yield as proportion of good units), yFrDPO (for
Yield fr DPO) and yFrDPU (for Yield fr DPU):
Result for Yield as
proportion of good units 
Result stored in variable 
Yield 
y.Result.Yield 
Yield in % 
y.Result.YieldInPercent 
Nonconforming in % 
y.Result.NonConformingPercent 
Result for Yield from
DPO 

Yield (fr DPO) 
yFrDPO.Result.YieldFrDPO 
Result for Yield from
DPU 

Yield (fr DPU) 
yFrDPU.Result.YieldFrDPU 
ProcessPerformanceFrYield Class
The ProcessPerformanceFrYield
class does the analysis (calculation), and it is
implemented as follows:
public class ProcessPerformanceFrYield
{
private int N = 0;
private int G = 0;
private double dpu = 0;
private double dpo = 0;
private double yield = 0;
private double yieldInPercent = 0;
private double nonConformingInPercent = 0;
public ProcessPerformanceFrYieldResult Result = new ProcessPerformanceFrYieldResult();
#region Constructors
public ProcessPerformanceFrYield() { }
#endregion
public int NumOfUnitProcessed
{
set { N = value; }
}
public int NumOfGoodUnits
{
set { G = value; }
}
public double DPU
{
set { dpu = value; }
}
public double DPO
{
set { dpo = value; }
}
Once the ProcessPerformanceFrYield
object is instantiated, the user needs to
set input values as follows:
ProcessPerformanceFrYield y = new ProcessPerformanceFrYield();
y.NumOfUnitProcessed = 40000;
y.NumOfGoodUnits = 39835;
ProcessPerformanceFrYield yFrDPO = new ProcessPerformanceFrYield();
yFrDPO.DPO = 0.0006875;
ProcessPerformanceFrYield yFrDPU = new ProcessPerformanceFrYield();
yFrDPU.DPU = 0.004125;
Then the .Analyze()
method is called to perform the analysis. Subsequently,
the user can retrieve the analysis results from the .Result
object in the
ProcessPerformanceFrYield
object.
The Analyze()
method is implemented as follows:
public void Analyze()
{
yield = (double)G / N;
yieldInPercent = (double)G / N * 100;
nonConformingInPercent = 100  yieldInPercent;
Result.Yield = yield;
Result.YieldInPercent = yieldInPercent;
Result.NonConformingPercent = nonConformingInPercent;
Result.YieldFrDPU = Math.Exp(1 * dpu);
Result.YieldFrDPO = 1  dpo;
}
Conclusion
The program presented here provides a simple way to obtain process
performance through Yield. Among all four process performance metrics mentioned
in Introduction in this page, Yield is the most
commonly used performance metric as it is understood by technical and non
technical personnel. I personally feel the difference between Yield (in a
subprocess) and RTY (Rolled Throughput Yield) should be clarify for better
communication in term of "yield". Hope you enjoy reading this.
History
 15 June 2012: Initial post.