12,952,778 members (35,847 online)
Article
alternative version

#### Stats

12K views
12 bookmarked
Posted 15 Jun 2012

# Process Performance Determination in C# Part 3

, 11 Dec 2012 CPOL
 Rate this:
The program presented here provides a simple way to obtain process performance through Yield.

## 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 Z-transformation

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

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:

1. Yield and DPO (see here for explanation of DPO)
2. 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 first-pass yields (FPY) from each sub-process of the total process as follows:

```Yield (RTY) = Yield (sub-process 1) x Yield (sub-process 2) x ... x Yield (sub-process n)
(Equation 4)```

The concept of the RTY is illustrated by the following example, which depicts an overall process comprised of four sub-processes. Suppose the FPY of each sub-process 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 sub-process 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. Sub-process 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 4-steps process:

1. Instantiate a `ProcessPerformanceFrYield` object
2. Input
1. `NumOfUnitProcessed` and `NumOfGoodUnits`, or
2. DPO, or
3. DPU
3. Invoke its `.Analyze()` method
4. Retrieve results from its .Result object.

Here are some typical user’s code:

```//Yield (as proportion of good units)
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);

//Yield (from DPO)
ProcessPerformanceFrYield yFrDPO = new ProcessPerformanceFrYield();
yFrDPO.DPO = 0.0006875;
yFrDPO.Analyze();
Console.WriteLine("Yield (fr DPO) is: " + yFrDPO.Result.YieldFrDPO);

//Yield (from DPU)
ProcessPerformanceFrYield yFrDPU = new ProcessPerformanceFrYield();
yFrDPU.DPU = 0.004125;
yFrDPU.Analyze();
Console.WriteLine("Yield (fr DPU) is: " + yFrDPU.Result.YieldFrDPU);```

Two classes are implemented:

1. `ProcessPerformanceFrYieldResult`
2. `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:

```/// <summary>
/// Process Performance from Yield Result class
/// </summary>
public class ProcessPerformanceFrYieldResult
{
/// <summary>
/// Default constructor
/// </summary>
public ProcessPerformanceFrYieldResult() { }
/// <summary>
/// Non conforming percent
/// </summary>
public double NonConformingPercent;
/// <summary>
/// Yield in Percent
/// </summary>
public double YieldInPercent;
/// <summary>
/// Yield (not in Percent)
/// </summary>
public double Yield;
/// <summary>
/// Yield from DPU
/// </summary>
public double YieldFrDPU;
/// <summary>
/// Yield from DPO
/// </summary>
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` Non-conforming 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:

```/// <summary>
/// Determine Process Performance from Yield
/// </summary>
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;

/// <summary>
/// ProcessPerformanceFrYield Result
/// </summary>
public ProcessPerformanceFrYieldResult Result = new ProcessPerformanceFrYieldResult();

#region Constructors
/// <summary>
/// Process Preformance from Yield default constructor
/// </summary>
public ProcessPerformanceFrYield() { } // default empty constructor

#endregion //  Constructors

/// <summary>
/// Write only property: total number of units
/// </summary>
public int NumOfUnitProcessed
{
set { N = value; }
}

/// <summary>
/// Write only property: total number of good units
/// </summary>
public int NumOfGoodUnits
{
set { G = value; }
}

/// <summary>
/// Write only property: DPU (defects per unit)
/// </summary>
public double DPU
{
set { dpu = value; }
}

/// <summary>
/// Write only property: DPO (defects per opportunity)
/// </summary>
public double DPO
{
set { dpo = value; }
}```

Once the `ProcessPerformanceFrYield` object is instantiated, the user needs to set input values as follows:

```//Yield: proportion of good units
ProcessPerformanceFrYield y = new ProcessPerformanceFrYield();
y.NumOfUnitProcessed = 40000;
y.NumOfGoodUnits = 39835;

//Yield from DPO
ProcessPerformanceFrYield yFrDPO = new ProcessPerformanceFrYield();
yFrDPO.DPO = 0.0006875;

//Yield from DPU
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:

```/// <summary>
/// Calculate the Process Performance from Yield
/// </summary>
public void Analyze()
{
yield = (double)G / N;
yieldInPercent = (double)G / N * 100;
nonConformingInPercent = 100 - yieldInPercent;
//Result
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 sub-process) 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.

## Share

 Foundasoft.com Malaysia
Consultant

## You may also be interested in...

 Pro Pro

 -- There are no messages in this forum --
Web02 | 2.8.170525.1 | Last Updated 11 Dec 2012
Article Copyright 2012 by Sitt Chee Keen