“The best design is the simplest one that works.”
— Albert
Einstein —The design of experiments is one aspect of engineering work. In order to understand more about the product and process one can use SPC, historical data, … But sometimes it is not enough especially dealing with a complex dynamic system. One has turn to DOE to find optimal operating setting and working environment of a system. We will look at the DOE method and its application in injection molding.
There is a different in academic study and practical manufacturing environment in finding optimal operating parameters when it comes to DOE. The general problems are the technical know-how to do the experiment scatter in the text book and quite often did not show clearly or the pieces that need explain missing altogether, making engineering practitioner harder to connect the dots. We will follow the DOE research papers' style and format including detail calculations (generally left out in research paper).
The tools we are going to use include excel, python. Usually one start with excel spreadsheet to collect experimental data and can finish the analysis in excel, Minitab, or other statistical software package. We will do thing a little different by using python for ANOVA calculation after import data from excel in the process.
Python is a flexible programming language. It has quite a few syntax constructs that resemble mathematical expression (set, tuple, comprehension, …) Also, it can process one statement or more in an interactive environment to test the ideas immediately.
To manipulate the data, we will import from excel, or csv files into python DataFrame format. One can also use dictionary syntax format to put data into pandas library DataFrame. We will show you both methods.
First let’s define the DOE - Design of experiments. Simply put, it is a way to interpret the high and low output averages of each factor in relation with others and the trend of the averages. This understanding helps to gain a better controlling of a system. The fundamental, practical definition is preferred over the theoretical text book explanations for a nuts-and-bolts engineering practitioner.
Always try to understand the task in both practical (more emphasized) and theoretical (less emphasized) in engineering practice. Most of the time, it helps to carry the day. The best way to solve the problem is to break down the fundamental to its elementary basic steps.
Assuming you already figure out the fill time, injection speed, and other important parameters of a part using scientific molding technique. Also, the process window/range has been established (High and Low values of the Factors – one can find out by making the shots to find the factor limits that the part still acceptable).
The next step would be looking for the relationship between critical inputs (based on historical data, group brainstorm, experiences) and the nominal output dimension requirements. DOE is one good way to explain these cause-and-effect relationships.
When dealing with polymers, specific volume in relation with temperature and pressure is generally linear by looking at the PVT diagram. Base on this fact, we can develop process capability by analyze variation in part dimensions with respect to pressure, temperature and other related factors in the experiment.
Factors/inputs to consider – Mold Temperature, Cooling Time,
and holding pressure.
Responses/outputs – one critical Length of the part.
There is going to be (Levels)**(Factors) = 2**3 = 8 runs or eight treatments/trials set-up. The L8 orthogonal array method was used for the design of experiment.
In the experiment the y-output response is modeled as a polynomial function at different x-input levels of the factor, and the result is a response curve. With more variables or factors a response surface map is established.
Since, it is a first order linear function. Contour graph will be easier to develop in injection molding DOE because of the linear relationship and the interaction between factors typical at a minimum.
Representation of the multiple linear regression respond surface model:
y
= 𝛽0 + 𝛽1*x1
+ 𝛽2*x2
+ ⋯+ 𝛽k*xk + 𝜀
Adding an interaction term to the first-order model in two variables:
y = 𝛽0 + 𝛽1*x1 + 𝛽2*x2 + (𝛽12*x1*x2) + 𝜖
When the interaction factors are negligible, so with two variables:
y = 𝛽0 + 𝛽1*x1
+ 𝛽2*x2
+ 𝜀
For example, relationship between Length, Pressure, and Temperature:
Length
= 𝛽1*Press
+ 𝛽2*Temp
+ 𝛽0 + 𝜀
(𝛽1, 𝛽2, 𝛽0, 𝜀 are some constants)
ax + by + cz = d
Point-Normal Form equation for a plane in 3-D space:
a(x - x0) + b(y - y0) + c(z - z0) = 0
If we vary Length at different values, this become an equation of a line which is of more interest for contour plotting. Basically we move the line up or down in y by changing the C constant:
Standard form Ax + By = C
Slope-intercept y = mx + b
Point-slope y – y1 = m(x – x1)
Example: A*Pressure + B*Temperature = Length(C)
Later in the experiment we will group lines together to get a contour graph. Always try to develop contour plot whenever possible, especially when it is a first order polynomial function. Because, we can understand more about the system and make prediction or fine tuning the process a lot better (by using the linear equations and process window limits – High and Low of factor values). With second order one may need to use a software package to do the RSM modeling.
Also, do not distract or get lost in all the statistical calculation. Remember we already have the basic information i.e. the output level averages from each factor and the moving trend (from response graph). The magnitude or different between high and low averages of each response/output indicate how big a dial one can adjust to make system more responsive. Bigger dial range means better control of the output from the input, which is what one looking for.
ANOVA is just to give the detail confirmation from the response graph indication, using variance from different sources to calculate some useful numbers such as the percent influence of each factors.
The experiment model assumes linearity between input and output base on PVT diagram of polymer. If the response ranges too small or narrow i.e. insignificant factor(s), that means we may not possibly apply the linear equations. The linear model may not apply here. The process window will define the range of factor values we can use for the equations in predicting the outcome or finding optimal input values.
Generally, the interactions between factors are low. They usually are dropped when values are small. Below are the calculation methods:
[Temp_High at (Ave_Time_High - Ave_Time_Low) - Temp_Low
at (Ave_Time_High - Ave_Time_Low)]/2
[Time_High at (Ave_Pres_High - Ave_Pres_Low) - Time_Low
at (Ave_Pres_High - Ave_Pres_Low)]/2
[Temp_High at (Ave_Pres_High - Ave_Pres_Low) - Temp_Low
at (Ave_Pres_High - Ave_Pres_Low)]/2
The above calculation use main factors only (not using Temp*Time, ...... columns). It is easier to take the different of Length level averages, after sorting interaction columns high and low as show in python program.
Experimental Layout and Results:
-------------------------------------------------
| Runs | moldTemp | coolTime | holdPress | Length | Temp*Time | Time*Press | Temp*Press |
| 1 | 2 | 2 | 2 | 40.85 | 2 | 2 | 2 |
| 2 | 2 | 2 | 1 | 40.42 | 2 | 1 | 1 |
| 3 | 2 | 1 | 2 | 40.72 | 1 | 1 | 2 |
| 4 | 2 | 1 | 1 | 40.42 | 1 | 2 | 1 |
| 5 | 1 | 2 | 2 | 40.95 | 1 | 2 | 1 |
| 6 | 1 | 2 | 1 | 40.62 | 1 | 1 | 2 |
| 7 | 1 | 1 | 2 | 40.75 | 2 | 1 | 1 |
| 8 | 1 | 1 | 1 | 40.46 | 2 | 2 | 2 |
-----------------------------------------------------------
| Runs | Mold temp | Cooling | Holding | Length | Temp*Time | Time*Press | Temp*Press |
| (°C) | time (s) | press (Psi) | (mm) | ||||
| 1 | 38 | 28 | 650 | 40.85 | 2 | 2 | 2 |
| 2 | 38 | 28 | 400 | 40.42 | 2 | 1 | 1 |
| 3 | 38 | 18 | 650 | 40.72 | 1 | 1 | 2 |
| 4 | 38 | 18 | 400 | 40.42 | 1 | 2 | 1 |
| 5 | 23 | 28 | 650 | 40.95 | 1 | 2 | 1 |
| 6 | 23 | 28 | 400 | 40.62 | 1 | 1 | 2 |
| 7 | 23 | 18 | 650 | 40.75 | 2 | 1 | 1 |
| 8 | 23 | 18 | 400 | 40.46 | 2 | 2 | 2 |
As mentioned earlier when we have three variables. Mathematically, it is an equation of a plane:
A*Pressure + B*Cooling_Time = Length(C)
If the length is varying at different
level (constant or contour values). We essentially establish a group of line
equations shifting along the y-axis. This is how contour plot is developing in
this linear model.
From level averages we can establish these equations:
LENGTH:
|
Ave_23_°C
|
40.6950
|
Ave_18_s
|
40.5875
|
Ave_400
Psi
|
40.4800
|
Ave_38_°C
|
40.6025
|
Ave_28_s
|
40.7100
|
Ave_650 Psi
|
40.8175
|
|
-0.0925
|
0.1225
|
0.3375
|
Three linear lines (point-slope equations):
Length - 40.8175 = (0.3375 / 250) *
(Pressure - 650) (1)
==> Length = 0.00135 * Pressure + 39.94
==> Pressure = (Length - 39.94) / 0.00135
Length - 40.71 = (0.1225
/ 10) * (Cooling_Time
- 28) (2)
==> Length = 0.01225 * Cooling_Time + 40.367
==> Cooling_Time = (Length - 40.367) / 0.01225
Length - 40.695 = (- 0.0925 / 15) * (Temperature - 23) (3)
--------------------------------------------------------------------
Combine (1) and (2) to setup contour plot:
Length =
0.00135 * Pressure +
39.94
Length = 0.01225 * Time + 40.367
2 * Length = 0.00135 * Pressure + 0.01225 * Time + 80.307
Pressure = (2 * Length - (0.01225 * Time + 80.307))/0.00135 <==
Substituting different length values to create a group of line equations. These lines will become the contour plot. Basically, length value changes y-intercept and shifting the line along y-axis.
--------------------------------------------------------------------
When we get the equations, do a sanity check – plug in
the nominal or some value from operating window range to verify the result come
out right – If the equation does not show proper output, then the linear model
did not apply here. Sometime one insignificant factor may be the case, then we
have to look for other inputs for answer.
The excel spread sheet 'Mold_DOE.xlsx' includes ANOVA analysis. Below are the process using python programming with response charts and ANOVA table show at the end.
===========================================
Interactive
ANOVA Calculations with Python:
===========================================
One can use number 1 and 2 or (-1), (+1) for level low/high instead of (-), (+). It is easier to use in grouping, and sorting in python.
2 = High --> (+) , +1 1 = Low --> (–)
, –1
(+)*(+) = (+) (+)*(–)
= (–)
(–)*(–) = (+) (–)*(+) = (–)
====================================================================
# start python session by importing all libraries
import pandas as pd, numpy as np, matplotlib.pyplot as plt
# put excel file in a working
relative folder “data”
# importing convert to pandas DataFrame
# using absolute path ==> 'c:/user/data/Mold_DOE.xlsx'
# importing convert to pandas DataFrame
# using absolute path ==> 'c:/user/data/Mold_DOE.xlsx'
moldExp = pd.read_excel('data/Mold_DOE.xlsx', sheet_name="Mold_DOE", index_col = 0)
# you can bring data in using
Dictionary format
moldDict = {'Runs ': range(1,9),
'moldTemp': [38, 38, 38, 38, 23, 23, 23, 23],
'coolTime': [28, 28, 18, 18, 28, 28, 18, 18],
'holdPress': [650, 400, 650, 400, 650, 400, 650, 400],
'Length': [40.85, 40.42, 40.72, 40.42, 40.95, 40.62, 40.75, 40.46]}
# bring moldDict to pandas
DataFrame, you can use moldExp or moldDF for calculation
moldDF = pd.DataFrame(moldDict,
index=range(1,9))
# average all high and low main
factor levels
aveTemp = moldExp.groupby(['moldTemp'])[['Length']].mean()
aveTime = moldExp.groupby(['coolTime'])[['Length']].mean()
avePress = moldExp.groupby(['holdPress'])[['Length']].mean()
# average all high and low interaction factor levels
aveTemp_Time = moldExp.groupby(['Temp*Time'])[['Length']].mean()
aveTime_Press = moldExp.groupby(['Time*Press'])[['Length']].mean()
aveTemp_Press = moldExp.groupby(['Temp*Press'])[['Length']].mean()
# Computation of interaction between factors.
# Same as the different of the above interaction level averages,
# i.e ==> Temp_Press = aveTemp_Press.loc[2] - aveTemp_Press.loc[1]
aveTempCool = moldExp.groupby(['moldTemp','coolTime'])
[['Length']].mean()
[['Length']].mean()
aveCoolPress = moldExp.groupby(['coolTime','holdPress'])
[['Length']].mean()
[['Length']].mean()
aveTempPress = moldExp.groupby(['moldTemp','holdPress'])
[['Length']].mean()
[['Length']].mean()
Temp_Press = (aveTempPress.Length[0] +
aveTempPress.Length[3]
- aveTempPress.Length[1] - aveTempPress.Length[2]) / 2
Cool_Press = (aveCoolPress.Length[0] +
aveCoolPress.Length[3]
- aveCoolPress.Length[1] - aveCoolPress.Length[2]) / 2
Temp_Cool = (aveTempCool.Length[0] +
aveTempCool.Length[3]
- aveTempCool.Length[1] - aveTempCool.Length[2]) / 2
# plot the response graph of three
main factors at two levels
plt.figure(2)
plt.plot(['moldTemp1', 'moldTemp2'], aveTemp.Length, 'rs-' ,
['coolTime1', 'coolTime2'], aveTime.Length, 'co-' ,
['holdPress1', 'holdPress2'], avePress.Length, 'bD-' ,
lw=3, markersize=10, markerfacecolor='m')
# stacking Length values for text
position then plot,
# sometimes the data need to
organize for the function
aveResp = np.vstack([aveTemp, aveTime,
avePress]).ravel().round(3)
for n in range(6) :
i = n
plt.text(i + 0.1 , aveResp[i] , str(aveResp[i]) , color='g')
# axis labels
plt.title('Average effects at
Low and High Levels')
plt.xlabel('Factor Levels
(Input Variables)')
plt.ylabel('Responses (mm)')
# another way of looking at response
by magnitudes - delta Length of level averages
plt.figure(3)
X_factor = ['moldTemp', 'coolTime', 'holdPress',
'Temp*Press', 'Cool*Press', 'Temp*Cool']
'Temp*Press', 'Cool*Press', 'Temp*Cool']
Y_delta = [aveTemp.iloc[1] - aveTemp.iloc[0],
aveTime.iloc[1] - aveTime.iloc[0],
avePress.iloc[1] - avePress.iloc[0],
Temp_Press, Cool_Press, Temp_Cool]
# color the bar and draw a
horizontal line at [0, 0] level
plt.bar(X_factor, Y_delta, color = ['m','b','c','y', 'g', 'r'])
plt.plot([-0.4, 5.4], [0, 0], 'k-', lw = 2)
# setup text position for magnitude
values
# yText = [-0.0925, 0.1225, 0.3375,
0.0275, 0.0425, -0.0575]
# convert Y_delta to float, because
plt.text() does not like mixed data type
yText = np.round((np.array(Y_delta,
dtype=float)), 4)
for n in range(6) :
i = n
y = yText[n]
if y < 0 : y -= 0.015
else : y
+= 0.006
plt.text(i - 0.25, y, str(yText[i]))
# axis labels
plt.ylabel('Response
Magnitudes (mm)')
plt.xlabel('Factors-(Main Inputs
& Interactions)')
plt.title('Magnitude of
effects with +- sign')
# setup contour plot
#
L = 0.00135*Pressure + 39.94
#
L = 0.01225*Time+ 40.367
# 2*L = 0.00135*Pressure + 0.01225*coolTime
+ 80.307
# Pressure = (2*L -
(0.01225*coolTime + 80.307)) / 0.00135
plt.figure(4)
Length = np.arange(40.5, 40.81, 0.05)
coolTime = np.arange(17, 30, 1)
# plot multiple lines
for L in Length:
Pressure = (2*L - (0.01225*coolTime + 80.307)) / 0.00135
plt.plot(coolTime, Pressure)
# process window limits
plt.plot([18, 18], [400, 650], 'b-' , # vertical at x=18
[28, 28], [400, 650], 'b-' ,
[18, 28], [400, 400], 'b-' , # horizontal at y=400
[18, 28], [650, 650], 'b-', lw=3)
# setup text position for contour
Length values
pressY = np.arange(260,751,75)
for i in range(7):
plt.text(28.5, pressY[i], str(round(Length[i], 2)))
# axis labels
plt.ylabel('Hold Pressure (Psi)')
plt.xlabel('Cooling Time
(seconds)')
plt.title('Contour Plot
(Pressure-Time-Length) vs. Process Window')
# ============================
# ANOVA analysis process:
# ============================
# Total of all results:
T = sum(moldExp.Length)
# Correction Factor:
CF = T**2 / len(moldExp.Length)
# Total sum of squares – SS_T:
SS_T = sum(moldExp.Length**2) - CF
# Factor sum of squares - SS:
SS_Temp = (moldExp.groupby(['moldTemp'])[['Length']]
.sum()**2).sum()/4 - CF
.sum()**2).sum()/4 - CF
SS_Time = (moldExp.groupby(['coolTime'])[['Length']]
.sum()**2).sum()/4 - CF
.sum()**2).sum()/4 - CF
SS_Press = (moldExp.groupby(['holdPress'])[['Length']]
.sum()**2).sum()/4 - CF
.sum()**2).sum()/4 - CF
# Interaction sum of squares:
SS_TempTime = (moldExp.groupby(['Temp*Time'])[['Length']]
.sum()**2).sum()/4 - CF
.sum()**2).sum()/4 - CF
SS_TimePress = (moldExp.groupby(['Time*Press'])[['Length']]
.sum()**2).sum()/4 - CF
.sum()**2).sum()/4 - CF
SS_TempPress = (moldExp.groupby(['Temp*Press'])[['Length']]
.sum()**2).sum()/4 - CF
.sum()**2).sum()/4 - CF
# All other error sum of squares -
SS:
SS_e = SS_T - (SS_Temp + SS_Time +
SS_Press
+ SS_TempTime + SS_TimePress +
SS_TempPress)
# fT = (total number of trials *
number of repetition) – 1 = 8*1 - 1
# f
= number of levels – 1 = 2- 1 => Degrees of Freedom
fT = 8*1 - 1
fPress = 2-1
fTemp = 2-1
fTime = 2-1
fTempTime = fTemp * fTime
fTimePress = fTime * fPress
fTempPress = fTemp * fPress
fe = fT - (fTemp + fTime + fPress
+ fTempTime + fTimePress +
fTempPress)
# Mean square (variance) - MS:
MS_Temp = SS_Temp / fTemp
MS_Time = SS_Time / fTime
MS_Press = SS_Press / fPress
MS_TempTime = SS_TempTime / fTempTime
MS_TimePress = SS_TimePress /
fTimePress
MS_TempPress = SS_TempPress /
fTempPress
MS_e = SS_e / fe
# Factor F - ratios (Variance
Factor/ error variance)
F_Temp = MS_Temp / MS_e
F_Time = MS_Time / MS_e
F_Press = MS_Press / MS_e
F_TempTime = MS_TempTime / MS_e
F_TimePress = MS_TimePress / MS_e
F_TempPress = MS_TempPress / MS_e
F_e = MS_e / MS_e = 1
# Pure sum of squares - PS :
PS_Temp = SS_Temp - (MS_e * fTemp)
PS_Time = SS_Time - (MS_e * fTime)
PS_Press = SS_Press - (MS_e * fPress)
PS_TempTime = SS_TempTime - (MS_e *
fTempTime)
PS_TimePress = SS_TimePress - (MS_e *
fTimePress)
PS_TempPress = SS_TempPress - (MS_e *
fTempPress)
PS_e = SS_e + (fTemp + fTime + fPress
+ fTempTime + fTimePress + fTempPress) * MS_e
+ fTempTime + fTimePress + fTempPress) * MS_e
# Percentage contribution/Influence
- PI:
PI_Temp = PS_Temp / SS_T * 100
PI_Time = PS_Time / SS_T * 100
PI_Press = PS_Press / SS_T * 100
PI_TempTime = PS_TempTime / SS_T * 100
PI_TimePress = PS_TimePress / SS_T * 100
PI_TempPress = PS_TempPress / SS_T * 100
PI_e = PS_e / SS_T * 100
# Construct ANOVA table using pandas
DataFrame
Source = ['moldTemp', 'coolTime', 'holdPress', 'Temp*Time',
'Time*Press', 'Temp*Press', 'Error', 'Total']
df = [fTemp, fTime, fPress,
fTempTime, fTimePress, fTempPress, fe, fT]
SS = np.array([SS_Temp, SS_Time, SS_Press, SS_TempTime, SS_TimePress, SS_TempPress, SS_e, SS_T], dtype=float).round(4)
MS = np.array([MS_Temp, MS_Time, MS_Press, MS_TempTime, MS_TimePress, MS_TempPress, MS_e, 'nan'], dtype=float).round(4)
F = np.array([F_Temp, F_Time, F_Press, F_TempTime, F_TimePress, F_TempPress, F_e, 'nan'], dtype=float).round(2)
PS = np.array([PS_Temp, PS_Time, PS_Press, PS_TempTime, PS_TimePress, PS_TempPress, PS_e, 'nan'], dtype=float).round(4)
totalPI = sum(np.array([PI_Temp, PI_Time, PI_Press, PI_TempTime, PI_TimePress, PI_TempPress, PI_e], dtype=float).round(2))
PI = np.array([PI_Temp, PI_Time, PI_Press, PI_TempTime, PI_TimePress, PI_TempPress, PI_e, totalPI.item()], dtype=float).round(2)
anovaDict = {'Sources': Source,
'df': df,
'SS': SS,
'MS': MS,
'F' : F,
'PS': PS,
'PI': PI }
anovaMold = pd.DataFrame(anovaDict)
# show three graphs and print ANOVA result table
print(anovaMold)
plt.show()
---------------------------------------------------------------
Sources df SS MS F PS PI
0 moldTemp 1 0.0171 0.0171 16.90 0.0161 5.60
1 coolTime 1 0.0300 0.0300 29.64 0.0290 10.08
2 holdPress 1 0.2278 0.2278 225.00 0.2268 78.84
3 Temp*Time 1 0.0066 0.0066 6.53 0.0056 1.95
4 Time*Press 1 0.0036 0.0036 3.57 0.0026 0.90
5 Temp*Press 1 0.0015 0.0015 1.49 0.0005 0.17
6 Error 1 0.0010 0.0010 1.00 0.0071 2.46
7 Total 7 0.2877 NaN NaN NaN 100.00
-------------------------------------------------------------------
We have three graphs (Average effects, Magnitude effects, and Contour Plots show Pressure-Time-Length vs. Process Window) and one ANOVA table to check when finished.
Looking at magnitude bar chart, the interaction values are small (you can also look at the percent of influence in PI column of anova table). They are insignificants that mean we can pay more attention to other inputs. We did not factor-in the interactions in the excel ANOVA analysis. Still, the PI values did not change a whole lot when we included in Python calculation.
The holding pressure shows as highest bar. It is the most significant factor. Next one is cooling time. They both have positive effects (positive slope) – meaning proportionally increase with output length. For mold temperature, the slope is negative. That means inverse relation with length. others are relatively small and will not be consider for process control.
------------------------------------------------------------------
============================
Final
thoughts:
============================
The experimental layout need to be a balanced orthogonal array. That mean sum of a column factor (+) and (-) will be zero. Also, at a particular high or low level of any column the other corresponding columns (+) and (-) should sum up to zero. This is the way to ensure no correlation between variables, and their effect cancels out mathematically. Whenever it is possible or practical, try to randomize the run order.
Confirmation runs are used to verify the contour plot for potential usage in fine tuninng and troubleshooting injection molding process.
Due to small interaction values between factors, one can replace these interaction columns with confounding variables to get same run number with more inputs.
The Taguchi noise treatment with outer array can help to select factor combinations that are insensitive to noises such as lot or filler variations in injection molding process.
If each experiment is expensive or time is of a constraint. We can get valuable information with L4 array, two levels three factors layout:
---------------------------
| Runs | moldTemp | coolTime | holdPress |
| 1 | 1 | 1 | 1 |
| 2 | 1 | 2 | 2 |
| 3 | 2 | 1 | 2 |
| 4 | 2 | 2 | 1 |
The contour plot and process window limits are very important in helping to optimize the control parameters (in this case they are holding pressure and cooling time). Such as, from the plot one can select small cooling time value which is desirable for cycle time. Also, it can help to decide which machine best to run the product.
The contour length lines are also useful in predicting cause
and effect with confident as long as the values stay within the define
boundaries of high and low limits. From constant length contour lines vs. holding pressure and cooling
time, one can extrapolate optimal operating conditions. Also, SPC and cpk can
be used on these relationships for better process control.
If the length average stays relatively consistent off to one side of the nominal. The mold designer can draw a conclusion that the shrinkage factor and dimension need to adjust for the next mold design project. One can learn from this, after the process control is in place.
The injection molding process is highly dynamic and complex. But, with the help of good DOE modeling one can gain more understanding about the system. This help in developing a more robust and reliable process control in order to improve product overall yield.
Note: Python codes and excel spreadsheet are hosted on github.
Reference:
- Basic Experimental Strategies and Data Analysis, John Lawson, John Erjavec – 2017
- Design and analysis of experiments, Douglas C. Montgomery 9th – 2017
- Statistical Design and Analysis of Experiments 2nd – 2003
Robert L.
Mason, Richard F. Gunst, James L. Hess
- Practical Guide to Designed Experiments – A Unified
Modular Approach – 2005
Paul
D. Funkenbusch
- DOE Simplified - Practical Tools for Effective Experimentation 2nd – 2010
Mark
J. Anderson, Patrick J. Whitcomb
- The Mahalanobis-Taguchi Strategy: A Pattern Technology
System – 2002
Genichi
Taguchi and Rajesh Jugulum
- Taguchi’s Quality Engineering Handbook – 2005
Genichi
Taguchi, Subir Chowdhury, Yuin Wu
- A Primer on the Taguchi Method, Ranjit K. Roy, 2nd – 2010
- Applied Design of Experiments and Taguchi Methods
- Response surface methodology 4th – 2016
Douglas C. Montgomery,
- Injection molding handbook 3rd – 2000
Donald V. Rosato,
- Total Quality Process Control for Injection Molding, 2nd – 2010
- Injection Molding Process Control, Monitoring, and Optimization – 2016
Yang,
Chen, Lu, Gao
- Plastics Engineering Handbook SPI, Michael L. Berins, 5th – 1991
- Handbook of plastic processes, Charles A. Harper – 2006
- Practical Injection Molding, Bernie A. Olmsted, Martin E. Davis – 2001
