4. Tolerance Stacks - Why you need Tolcap for a capable stack tolerance

Tolerance Stacks

This presentation is about tolerance stacks, or stack-ups, and particularly about statistical tolerancing. An earlier presentation explained why you need Tolcap for checking and setting the tolerances you put on drawings.
If Tolcap is good for individual tolerances, then hopefully you will see that Tolcap is, well, essential for tolerances in combination – in tolerance stacks.

Tolcap for Tolerance Stacks

Statistical tolerancing is almost always misapplied! We'll have a look shortly at why statistical tolerancing is invoked, and how it is usually applied with no consideration of any underlying assumptions. In fact there is a general lack of awareness that there are any underlying assumptions.

Tolerance stacks are not easy – the theory is essentially maths, and I apologise for that in advance, but the explanation will involve some maths, but it really isn't very advanced, and I will take it slowly.

Maths is necessary to be able to explain:

• the assumptions of statistical tolerancing;
• why Tolcap is vital, we think, for valid statistical tolerancing;
• and to show a straightforward method of calculating a sound statistical stack tolerance using Tolcap.

The Tolerance Stack Problem

First let's look at what we mean by a tolerance stack or stack-up.

We set tolerances for components, but it is often necessary to ensure the parts fit properly when they are assembled together:
The diagram represents an assembly -
three, let's call them, ‘blocks’ dimensioned d₁+/-t₁, d₂+/-t₂ and d₃+/-t₃
are fitted side by side into a ‘cradle’ dimensioned d₄+/-t₄.
Will they fit?

OK this example looks unrealistically simple, and your real designs will be more complex, but often they do essentially reduce to this problem statement.

Clearly we need d₄ to be somewhat greater than d₁ + d₂ + d₃ to allow for the blocks being larger than nominal size, but if the difference is too large, the assembly may be too ‘slack‘ when the blocks are smaller than nominal.

So what should we specify for d₄? And what should be the tolerance on that dimension?

Tolerance Stack Calculation

Well we always start with a worst case analysis, don’t we:
The assembly will always fit if the parts are in tolerance and:
if (d₄ – t₄) is greater than (d₁ + t₁ + d₂ + t₂ + d₃ + t₃),
or re-arranging that, and taking it to the limit were it will just work:
d₄ = (d₁ + d₂ + d₃ + t₁ + t₂ + t₃ + t₄)
note we add t₄ now it’s on this side of the equation.

More often than not when the dimensions are at the opposite ends of the tolerance band, the assembly would be unacceptably slack -
when all the dimensions come out on nominal, the gap is the sum of the tolerances,
and when d₄ is at maximum tolerance and the blocks on minimum, the gap is twice the sum of the tolerances.

At this point, someone will usually say – “Well let's use statistical tolerancing! We don't have to add up the individual tolerances: statistical tolerancing lets you ‘root-sum-square’ them!”
“What’s that?”
“Well you square them all, add the squares up and take the square root.”
So now d₄ = (d₁ + d₂ + d₃ + √(t₁² + t₂² + t₃² + t₄²) )
where the tick ( √ ) means ‘the square root of’.
This gives a smaller answer for d₄, so less ‘slack’ - but is it justified?

Statistical Tolerancing Justification (1)

We know that ‘root-sum-squaring’ numbers gives a smaller answer than just adding them up. Pythagoras knew that – we can see it is a shorter distance along the hypotenuse of a right angled triangle than going round the other two sides, but does this have any relevance to the situation we’re in here?

The basis of statistical tolerancing is - as I said - a mathematical theorem:
Suppose we were to make up a variable - let's call it ‘stack’:
- constructed by adding or subtracting a number of component variables that are all independent (and that means the value of one variable is not in any way related to any of the others);
- let’s further suppose that the probability of finding a particular value, for one of these component variables, obeys a ‘normal’ or ‘Gaussian’ distribution;
- and variable i has a mean Xbar_i and standard deviation σ_i.

Now it is a property of the normal distribution that if you do add or subtract variables that are independent and normally distributed (as we want to do to make up this variable ‘stack’), then the result follows a normal distribution.
Further, this variable ‘stack’ will have:

• a mean which is the sum of the component means
• and a standard deviation which is the root sum square of the component standard deviations.

The means will have to be added algebraically, that means added or subtracted as appropriate – but the sigma squareds are, of course, all positive so they just add up.

Statistical Tolerancing Justification (2)

So that is the theory. If we could travel forward in time:

• we could measure the dimensions of the components in the stack;
• assure ourselves they are indeed independent;
• check that they are normally distributed;
• and measure Xbar and σ, the mean and standard deviation, for each.

Then then we could properly calculate the stack tolerance
- and if our tolerances happen to be the same multiple of the sigma's for each component,
- and if the means all come out at the nominal dimension,
- then ‘root-sum-squaring’ the tolerances will work fine!

But how do we know?
If we don't know – there’s no justification for ‘root-sum-squaring’ – and how could we know! Well - we have Tolcap!...

** If your head hurts, this might be a good point to pause this presentation and walk round the office before continuing!

Statistical Tolerancing with Tolcap

OK, if you're ready, we'll continue to use the same example to explore and try to understand the traditional approach to statistical tolerancing and then we'll take a look at a method for calculating stack tolerances using Tolcap.

We will compare and explore how stack tolerances, which we’ll call t_stack, are calculated as a function of the component tolerances:
t_stack equals a function of the tolerances.
For example t_stack equals the root sum square of the tolerances – the square root of (t₁² + t₂² + t₃² + t₄²).

We’ll look at this and some others, but the algorithms or equations will be given and explained in the general case, but it is purely to compare approaches, we will take a rather artificial case where all the component tolerances happen to come out equal: so t₁ = t₂ = t₃ = t₄ = t . And for that let’s call the stack tolerance stack t*_stack.

Some Maths

The following slides will use some maths, so let's review some recurring mathematical manipulations here first:
As explained above, Σd_i means add up all the values (and don't forget they may be plus or minus). So in our example we were looking at dimensions and to calculate the nominal ‘gap’:
Σd_i = – d₁ – d₂ – d₃ + d₄

Remember that √Σσ_i² means:

• square all the standard deviation sigmas,
• add them all up
• and take the square root of the sum.

If there is a constant involved in one of our equations we can usually take that out to make thing simpler.

So if we are trying to do the root sum of ‘c’ sigma ‘i’ squared √Σ(cσ_i)², what we can do is take the sum of the sigma squareds and then multiple them by the ‘c’ squared afterwards, and then do the square root √Σc²σ_i² = √c²√Σσ_i²,
or even more simply just do root sum sigma squared and then multiple by the ‘c’ c√Σσ_i²
and that enables us to say, for example, that if we are doing ‘Design for Six Sigma’ and we set all our tolerances equal to six sigmas (t_i = 6σ_i),
then root sum sigma squared equals the root sum of ‘t’ squared all divided by six √Σσ_i² = (√Σt_i²)/6
or even root sum of 4.5 sigma squared is the root sum of the ‘t’ squared times 4.5 divided by 6
√ Σ(4.5σ_i)² = (√Σt_i²)x 4.5/6

And finally, for the purpose of the comparative example, note that for four equal tolerances:
t₁=t₂=t₃=t₄=t,
if you add them up sigma ‘t’ ‘i’ Σt_i is 4t but if you root sum of the squares √Σt_i² then you get just 2t*

Traditional Statistical Tolerancing (1)

When statistical tolerancing was conceived, a tolerance of just 3σ was considered entirely adequate!

Really?

Well back in the day a designers education would start, not with an engineering degree, but more likely with an apprenticeship in the factory where he was going to work, so he’d be reasonably familiar with the parts and what could be achieved.

If not he could always go down into the factory and have a look at a part with a dimension similar to the one he was considering and see if there was a control chart for it. Now on a control chart action limits are set plus or minus 3 sigma around the mean of the parts coming off the machine. So if he matched his tolerances to the control chart limits, he would first of all be achieving Cp = 1 and he would get 99.9% of his parts within tolerance which was considered okay. And he could quite justifiably root sum square his tolerances of his components for a stack tolerance.

Now this procedure was found to give an optimistic result, it’s worth noting, and in 1962 Arthur Bender Junior published a paper which proposed adding a 50 percent margin to the stack tolerance. Now that 50 percent margin is actually one and a half sigma, and were have we heard that before? Well it’s the offset we set in ‘Design for Six Sigma’, which is worthy of note.

‘Benderizing’ is still a mainline traditional approach. However these days as designers, we are probably not quite as familiar with the parts we’re designing as they used to be in days of old,and going to the factory may be difficult if the parts are being made offshore.

But we have Tolcap and while Tolcap predicts Cpk rather than σ, we can make use of Tolcap to analyse, starting with the traditional method, and then look at how it can be developed and improved into a process for actually setting stack tolerances.

A Six Sigma Stack Tolerance (1)

I’ve mentioned the 1.5 sigma shift – so let’s just see were that comes from:

‘Design for Six Sigma’ says to set the tolerance to six sigma to allow one and a half sigma for the ‘process shift’ i.e. for the mean in production not lining up with the nominal dimension.

Does this mean that the process shift for ever manufacturing process really is 1.5 sigma?
No, of course not, there’s no law of nature that would cause that.

It is actually derived from the cunning of the manufacturing people – the shift should be less than 1.5σ, but if necessary a shift any greater than that could easily be detected by a standard four-sample Xbar _R control chart.

A control chart can’t be too commonly needed, so this implies that 1.5 sigma is generally more than sufficient.

A Six Sigma Stack Tolerance (2)

The process shift recognises that the mean dimension of the parts is not necessarily equal to the nominal dimension on the drawing.

How does that come about?

Thinking real process shifts, for some processes such as turning, the shift will depend on how well the setter has set up the machine for the batch.

For processes such as moulding the process shift will, to a large extent, drift over time as the tool wears.

So the process shift thus includes at least an element which is not variable from part to part but fixed from batch to batch, or drifts very slowly over time.

So while it makes sense to root sum square the ‘random’ part to part element of the tolerances (provided they are independent and normal), it may be prudent to combine the process shifts worst case – and simply add them up rather than root sum square them.

A Six Sigma Stack Tolerance (3)

The empirical data in Tolcap reflects the reality of the various manufacturing processes. It confirms that 1.5σ is sufficient for the process shift - but not always necessary. The process shift in Tolcap may be as much as 1.5σ, but it will be smaller if that's appropriate to the process.

Now extracting the process shift from Tolcap tolerance is no simple matter - it varies across the maps, and the effect of the wizards. But let’s use Tolcap, taking the six sigma approach to derive our stack tolerance, but we’ll assume that the process shift in the tolerances is the full 1.5 sigma. We’ll see that this gives a reasonably conservatively large estimate for the process shift tolerance and we can always do a sensitivity analysis later to see by how much we might have overestimated.

Traditional Statistical Tolerancing (2)

So derive a stack tolerancing algorithm we will get our component tolerances from Tolcap. We will use Tolcap to find the tolerance we need to achieve a target process capability. We want sigma values for these tolerances.

So as we said we’ll start with the ‘Six Sigma’ approach and tolerances. So:

• Open Tolcap
• Select a process
• And select the Cpk tab rather than Tolerance
• Enter the nominal dimension
• Set Target Cpk to 1.5
• Apply the wizards and find what tolerance Tolcap gives
• Repeat that for each tolerance in the stack

A Six Sigma Stack Tolerance (4)

For each component tolerance obtained on this basis:

We assume we have a six sigma tolerance – so that the tolerance equals six sigma ( t_i = 6σ_i )
That’s made up of two elements:

• Process shift is 1.5σ_i which is a quarter of the tolerance.
• Part-to-part variation element is 4.5σ_i which is three quarters of the tolerance.

We can’t root-sum-square the process shift elements - we have to add them. But we can root-sum-square the part-to-part variation element.

So the tolerance stack ( t_stack ) comes down to:

The sum of the tolerances times a quarter plus three quarters of the root-sum-square of the tolerances ( t_stack = ( Σt_i x ¼ + √Σ(t_i/2) ² x ¾ ).

In the specific comparison case we made where all the tolerances are equal, and equal to t, the stack tolerance ( t^*_stack ) comes to:

The sum of the tolerances is 4t we divide that by 4.The root-sum-square of the tolerances is 2t we take ¾ of that. Add them together and we end up with 2.5t. ( t_stack = 4t/4 + 2t x ¾ = 2.5t )

The stack tolerance is 2.5 times it’s component tolerances.

A Six Sigma Stack Tolerance (5)

So here is at last is a method for finding a ‘Design for Six Sigma’ stack tolerance!

For each component set the target Cpk is 1.5 and thus find what we are calling 6 sigma tolerances from Tolcap.

Add one quarter of the sum of the component tolerances to three quarters of the root-sum-square of the tolerances.

Sensitivity Analysis (1)

But of course the analysis above assumed that we would get a ‘Design for Six Sigma’ 1.5σ process shift in the tolerances obtained from Tolcap.
If we knew the process shifts in Tolcap were smaller we would modify our calculation.

For example, suppose the data in Tolcap reflected only 0.5σ process shifts for all the components in the stack. Then a Cpk = 1.5 target tolerance will comprise 4.5σ for the short term variation plus only 0.5σ for the process shift: a five sigma tolerance where we expected a six sigma tolerance!

What is the effect of this?
Well the process shift at 0.5σ is now the tolerance divided by 10, and the part-to-part 4.5σ nine times the tolerance over 10.
So if you put that into our formula, t_stack would come to 0.1 of the sum of the tolerances plus 0.9 of the root-sum-square of the tolerances.

And we can compare this with our case where all the tolerances are equal, and then
t*_stack comes out to, when you’ve done the arithmetic, at 2.2 times the component tolerance – and that’s instead of the 2.5 times the tolerance we had when we assumed 1.5 sigma process shifts. Not a great error.

Sensitivity Analysis (2)

In fact we didn't know we had a five sigma tolerance, but we can have some confidence that our computation assuming t_i = 6σ_i is conservative, and the margin, is quite small, in t*_stack it would be 12%.

Let’s take that to the limit. If there were processes such that all the component process shifts were zero, then each t_i would be 4.5σ, and we would want to simply root-sum-square the tolerances.
In this case we would find the t*_stack is pretty straight forwardly twice the component tolerance ( 2t ).

The margin in the tolerance stack from our original calculation would be 20%.

But the assumption that none of the components requires any allowance in the tolerance for process shift looks unlikely in practice, so any over-estimate in the algorithm looks acceptably small.

A 5.5σ Stack Tolerance!

But wait a minute up until now I have been recommending you design using Tolcap’s default Cpk equals 1.33 tolerances.

We had better modify the algorithm for the stack tolerance.

So for the same process and dimension and method as in the ‘six sigma’ case, we still assume the process shifts are 1.5σ, and for Cpk = 1.33, our tolerance needs another 4σ for part to part variation:

So we are now apparently doing ‘Design for 5.5σ’!

So t_i is 5.5σ, 1.5σ_i is 3/11 t_i and 4σ is 8/11 of t_i

And then we work out our t_stack as before, but this time it’s 3/11 of the sum of the tolerances and 8/11 of the root-sum-square of the tolerances.

So we have a simple algorithm for tolerance stacks with a minimum Cpk is 1.5 or Cpk is 1.33 to match our component Cpk.

Using Tolcap

We hope this presentation has explained:

• the assumptions of statistical tolerancing,
• why Tolcap is vital for valid statistical tolerancing,
• and a straightforward method of calculating a sound statistical stack tolerance using Tolcap.

This method is for ‘six sigma’ tolerance, use Tolcap to set component tolerances at Cpk = 1.5, and then:
t_stack will be lets say three twelfths (one quarter) the sum of the tolerances plus nine twelfths (three quarters) of the root-sum-square of the tolerances.

But for the Tolcap ‘default’ Cpk = 1.33, use Tolcap to set component tolerances at Cpk = 1.33, and then t_stack is 3/11 of the sum of the tolerances plus 8/11 of the root-sum-square of the tolerances.

Thanks for listening

For more information, including our Blog and other articles telling you how to get the best out of Tolcap, do visit our website at

https://www.tolcap.com.

At the very least do have a look at the last video in this series which is a worked case study illustrating the ways of using Tolcap that I’ve been talking about in these videos.