Forward

General Screening Designs

The goal of a screening design is to determine what factors have an effect on the measured result (the response).

Two-Level Full Factorial Designs

A common experimental design is one with all input factors set at two levels each. These levels are called high and low or +1 and -1, respectively. A design with all possible high/low combinations of all the input factors is called a full factorial design in two levels. In general, a design with \(n\) levels and \(k\) factors is noted as a \(n^k\) design.

For example, consider a two-level design with three factors; a \(2^3\) design. Because this will be a full-factorial design, we want every possible combination of factor and level; \(2^3=8\), so we will have 8 runs.

Here is how you would make this design in R:

# Creates 3 Factors with levels -1 and 1
Factor.1 <- c(-1,1)
Factor.2 <- c(-1,1)
Factor.3 <- c(-1,1)

# expand.grid() creates a data frame with all posible combinations of Factors and Levels
design.base <- expand.grid(Factor.1,Factor.2,Factor.3)

# Renames the columns to be the factors we made above
colnames(design.base) <- c("Factor.1", "Factor.2", "Factor.3")

# mutate() adds a new column, here we're just labeling the runs explicitly
design.base <- design.base %>%
  mutate(Run = 1:nrow(design.base))

# Rearranges the columns so that 'Run' is first
design.base <- design.base[,c(4,1,2,3)]

# Displays the table
design.base %>% knitr::kable()

The \(2^3\) design is easily represented graphically; the design space is a cube in three-dimensional space, with each factor represented by one of the dimensions. Because we only have two levels, each run is on a vertex of the design space.

# These function use plotly to graph the design space
fig <- plot_ly(showlegend = F) %>%
  add_markers(data = design.base, x=~Factor.1, y=~Factor.2, z=~Factor.3,
            marker = list(
              color = ~Run,
              showscale = TRUE
            )
              ) %>%
  add_paths(data = t, x=~Factor.1, y=~Factor.2, z=~Factor.3)

fig %>% layout(annotations = list(
  x = 1.08,
  y = 1.05,
  text = "Run",
  showarrow = FALSE))

The design could be improved by adding replicates,

# sets the number of replicates to 2
replicates <- 2

# loops over the number of replicates ...
for(i in 1:replicates) {

  # bind_rows() combines rows in the dataframe
  design <- bind_rows(design.base,design.base)
}

# Displays the table
design %>% knitr::kable()

by adding center points,

# Creates a dataframe with the center points
center <- data.frame(
  Factor.1 = 0,
  Factor.2 = 0,
  Factor.3 = 0
)

# Sets the number of center points to 3
n.center <- 3

# Loops over the number of center points ...
for (i in 1:n.center) {

  # ... adding the center points to the design
  design <- bind_rows(design, center)
}

# Displays the table
design %>% knitr::kable()

and by randomizing the order of runs.

# Randomizes the row order
design <- design[sample(1:nrow(design)), ]

# Displays the table
design %>% knitr::kable()

An interaction is possible between any combination of factors; the \(2^3\) design has three possible two-factor interactions and one possible three-factor interaction. The levels are found by multiplying the constituent columns.

# Adds the interaction columns for the base design
design <- design.base %>%
  mutate(
    "F1xF2" = Factor.1 * Factor.2,
    "F2xF3" = Factor.2 * Factor.3,
    "F1xF3" = Factor.1 * Factor.3,
    "F1xF2xF3" = Factor.1 * Factor.2 * Factor.3
  )

# Displays the table
design %>% knitr::kable()

For example, take the \(2^3\) design; If 8 runs are too many to complete in one day, we need to block the design. Given that we need to confound the blocking effect with an interaction, we should choose the interaction we care the least about; in general we choose the highest order interaction(s).

Here is how this looks in R assigning the blocks according the three-factor interaction.

design <- design %>% mutate(Block = "")

# Loops over the number of rows ...
for(i in 1:nrow(design)) {

  # ... and assigns blocks acording the the value of `F1-F2-F3`
  if(design$`F1xF2xF3`[[i]] == -1) {
    design$Block[[i]] <- 1
  } else {
    design$Block[[i]] <- 2
  }
}

# Displays the table
design %>% knitr::kable()

# These function use plotly to graph the design space
fig <- plot_ly() %>%
  add_markers(data = design, x=~Factor.1, y=~Factor.2, z=~Factor.3, color = ~Block, showscale = TRUE) %>%
  add_paths(data = t, x=~Factor.1, y=~Factor.2, z=~Factor.3, showlegend = F)

fig %>% layout(annotations = list(
  x = 1.08,
  y = 1.05,
  text = "Block",
  showarrow = FALSE))

You can see this results in the assignment of opposing corners of each face of the cube to the same block, meaning no run in the design space is connected to a run in the same block. This is because the \(2^3\) design has the geometric properties of being balanced and orthogonal.

Blocks are treated as separate experiments, addition of center points and randomization are performed within each block.

# Creates a separate dataframe for each block
  # filter() creates a subset of the data based on the chriteria supplied
design.block.1 <- design %>% filter(Block == 1)
design.block.2 <- design %>% filter(Block == 2)

# Sets the number of center points
n.center <- 2

for (i in 1:n.center) {
  design.block.1 <- bind_rows(design.block.1, center)
  design.block.2 <- bind_rows(design.block.2, center)
}

# Randomizes the runs within beach block
design.block.1 <- design.block.1[sample(1:nrow(design.block.1)), ]
design.block.2 <- design.block.2[sample(1:nrow(design.block.2)), ]

# Displays the tables
design.block.1 %>% knitr::kable(caption = "Block 1")

design.block.2 %>% knitr::kable(caption = "Block 2")

Two-level Fractional Factorial Designs

The downside to full-factorial designs is the exponential expansion of the number of runs as the number of factors increases. For example just 6 factors yields 64 runs, not including replicates and center points.

# Creates a full-factorial design with 6 factors
design <- expand.grid(c(-1,1),c(-1,1),c(-1,1),c(-1,1),c(-1,1),c(-1,1))

# mutate() adds a new column, here we're just labeling the runs explicitly
design <- design %>%
  mutate(Run = 1:nrow(design))

# Rearranges the columns so that 'Run' is first
design <- design[,c(7,1,2,3,4,5,6)]

  # Displays the table
design %>% knitr::kable()

We can reduce the number of runs by using a fractional factorial design instead.

As an example, let’s fractionate the \(2^3\) design by \(1/2\). Mathematically, \(1/2 \cdot 2^3\) is equivalent to \(2^{3-1}\), meaning there are \(2^2=4\) runs.

Therefore, let’s start with \(2^2\) as the base design.

# Creates two factors
Factor.1 <- c(-1,1)
Factor.2 <- c(-1,1)

# Creates the design with all possible combinations of factors and levels
design.base <- expand.grid(Factor.1,Factor.2)

# Renames the columns
colnames(design.base) <- c("Factor.1", "Factor.2")

# Adds the run column
design.base <- design.base %>%
  mutate(Run = 1:nrow(design.base))

# Re-orders the columns
design.base <- design.base[,c(3,1,2)] %>%
  # Makes a new column by multiplying Factor 1 by Factor 2
  mutate("Fact.1 x Fact.2" = Factor.1*Factor.2)

# Displays the table
design.base %>% knitr::kable()

To generate the missing column, we need one or more design generators; to do this we need to again consider confounding.

The price we pay for fractionating is the same as for blocking; to add a third factor we need to confound it with an interaction. Here, we only have one to choose, the \(Factor_1 \cdot Factor_2\) interaction. Therefore, we need to use the following design generator.

\[3 = 1 \cdot 2\]

# Alters the base design by renaming the two-factor interaction column to factor 3
design <- design.base
colnames(design)[4] <- "Factor.3"

# Displays the table
design %>% knitr::kable()

You can see that the runs we have retained by fractionating the design are orthogonal, they are on opposite corners of each face of the cube that represents our design space.

# These function use plotly to graph the design space
fig <- plot_ly(showlegend = F) %>%
  add_markers(data = design, x=~Factor.1, y=~Factor.2, z=~Factor.3,
            marker = list(
              color = ~Run,
              showscale = TRUE
            )
              ) %>%
  add_paths(data = t, x=~Factor.1, y=~Factor.2, z=~Factor.3)

fig %>% layout(annotations = list(
  x = 1.08,
  y = 1.05,
  text = "Run",
  showarrow = FALSE))

Note we could have also generated the design by setting Factor 3 equal to \(-Factor_1 \cdot Factor_2\); this results in the opposite corners of the design space being included.

\[3 = -1 \cdot 2\]

design <- design.base %>%
  mutate("Factor.3" = -Factor.1*Factor.2)

# Displays the table
design %>% knitr::kable()

# These function use plotly to graph the design space
fig <- plot_ly(showlegend = F) %>%
  add_markers(data = design, x=~Factor.1, y=~Factor.2, z=~Factor.3,
            marker = list(
              color = ~Run,
              showscale = TRUE
            )
              ) %>%
  add_paths(data = t, x=~Factor.1, y=~Factor.2, z=~Factor.3)

fig %>% layout(annotations = list(
  x = 1.08,
  y = 1.05,
  text = "Run",
  showarrow = FALSE))

# Creates a full-factorial design with 5 factors
design.base <- expand.grid(c(-1,1),c(-1,1),c(-1,1),c(-1,1),c(-1,1))

# Names the columns
colnames(design.base) <- c("F.1", "F.2", "F.3", "F.4", "F.5")

# Makes a run column
design.base <- design.base %>%
  mutate(Run = 1:nrow(design.base))

# Puts the 'Run' column first
design.base <- design.base[,c(6,1,2,3,4,5)]

# Displays the table
design.base %>% knitr::kable()

# Adds Factors according to the equations in the Design Generators
design <- design.base %>% mutate(
  F.6 = F.1*F.2*F.3*F.4*F.5,
  F.7 = F.2*F.3*F.4*F.5,
  F.8 = F.1*F.3*F.4*F.5
)

# Displays the table
design %>% knitr::kable()

Defining Relation

\[I=\] \[2 \cdot 3 \cdot 4 \cdot 5 \cdot 7=\] \[1 \cdot 3 \cdot 4 \cdot 5 \cdot 8=\] \[1 \cdot 2 \cdot 3 \cdot 4 \cdot 5 \cdot 6=\] \[1 \cdot 2 \cdot 3 \cdot 4 \cdot 5 \cdot 6 \cdot 7=\] \[1 \cdot 2 \cdot 3 \cdot 4 \cdot 5 \cdot 7 \cdot 8=\] \[1 \cdot 2 \cdot 3 \cdot 4 \cdot 5 \cdot 6 \cdot 8=\] \[1 \cdot 2 \cdot 3 \cdot 4 \cdot 5 \cdot 6 \cdot 7 \cdot 8\]

The defining relation is useful in considering confounding. For example, multiplying all the words by 1 gives all the confounding relations for Factor 1

\[I \cdot 1 \implies 1=\] \[1 \cdot 2 \cdot 3 \cdot 4 \cdot 5 \cdot 7 =\] \[3 \cdot 4 \cdot 5 \cdot 8 =\] \[2 \cdot 3 \cdot 4 \cdot 5 \cdot 6 =\] \[2 \cdot 3 \cdot 4 \cdot 5 \cdot 6 \cdot 7 =\] \[2 \cdot 3 \cdot 4 \cdot 5 \cdot 7 \cdot 8 =\] \[2 \cdot 3 \cdot 4 \cdot 5 \cdot 6 \cdot 8 =\] \[2 \cdot 3 \cdot 4 \cdot 5 \cdot 6 \cdot 7 \cdot 8\]

The length of the shortest word in the defining relation is also equivalent to the resolution of the design.

For example, the generating relation in our \(2^{3-1}\) design was $ 3 = 1 2 $. Because the number of factors is low there is only one word; therefore the generating relation is also the defining relation, $ I = 1 2 3 $. Because the shortest word is 3 Factors the main effects are confounded with 2 factor interactions.

\[ 1 = 2 \cdot 3 \] \[ 2 = 1 \cdot 3 \] \[ 3 = 1 \cdot 2 \]

The \(2^{8-3}\) design above is a resolution V design.

Close

In writing this post, I learned

• why one would use the different DoE design types,
• how to make factorial designs,
• why one would use a fractional factorial design, and
  • what compromises are needed to make a fractional design.