ccd | R Documentation |
These functions generate central-composite designs, or building blocks thereof. They allow for flexible choices of replications, aliasing of predictors and fractional blocks, and choices of axis or ‘star’ points.
cube(basis, generators, n0 = 4, reps = 1, coding, randomize = TRUE,
blockgen, bid = 1, inscribed = FALSE)
star(basis, n0 = 4, alpha = "orthogonal", reps = 1, randomize = TRUE)
dupe(design, randomize = TRUE, coding)
foldover(basis, variables, bid, randomize = TRUE)
ccd(basis, generators, blocks = "Block", n0 = 4, alpha = "orthogonal",
wbreps = 1, bbreps = 1, randomize = TRUE, inscribed = FALSE,
coding, oneblock = FALSE)
basis |
In |
generators |
Optional formula or list of formulas to generate aliased variables |
n0 |
Integer giving the number of center points. In |
reps |
Integer number of replications of the cube or the star. (This does not create replicate blocks; use |
coding |
List of coding formulas for the design variables (those in |
randomize |
Logical value determining whether or not to randomize the design. In |
blockgen |
A formula, string, or list thereof. Each element is evaluated, and the distinct combinations define fractional blocks for the design. Unlike |
bid |
(For block ID.) An integer index (from 1 to number of blocks) of the fractional block to return. The indexes are defined by the standard ordering of the block generators; e.g. if |
inscribed |
Logical value; if |
alpha |
If numeric, the position of the ‘star’ points. May also be a character string that matches or partially matches one of these:
The user may specify a vector value of |
design |
A |
blocks |
A string or a formula. If a character string, it is the name of the blocking factor; if a formula, the left-hand side is used as the name of the blocking factor. The formula(s) on the right-hand side are used to generate separate fractional blocks. |
variables |
Character vector of names of variables to fold over. |
wbreps |
Number(s) of within-block replications. If this is a vector of length 2, then separate numbers are used for the ‘cube’ and the ‘star’ blocks respectively. |
bbreps |
Number(s) of between-block replications (i.e., number of repeats of each block). If this is a vector of length 2, then separate numbers are used for the ‘cube’ and the ‘star’ blocks respectively. |
oneblock |
Logical. If |
Central-composite designs (CCDs) are popular designs for use in response-surface exploration. They are blocked designs consisting of at least one ‘cube’ block (two-level factorial or fractional factorial, plus center points), and at least one ‘star’ block (points along each axis at positions -alpha
and +alpha
), plus center points. Everything is put on a coded scale, where the cube portion of the design has values of -1 and 1 for each variable, and the center points are 0.
The ccd
function creates an entire CCD design; however, in practice, we often start with just the cube portion and build from there. Therefore, the functions cube
, star
, dupe
, and foldover
are provided, and one may use djoin
to combine them.
In cube
and ccd
, the basis
argument determines a basic design used to create cube blocks.
For example, ‘cube(basis = ~ A + B + C)’ would generate a basic design of 8 factorial points plus center points.
Use generators
if you want additional variables in a fractional design; for example, ‘generators = c(D ~ -A*B, E ~ B*C)’ added to the above would generate a 5-factor design with defining relation I = -ABD = BCE = -ACDE
. For convenience, basis
may be an integer instead of a formula, in which case default variable names of x1, x2, ...
are used; for example, ‘cube(3, ~ -x1*x2*x3)’ generates a 1/2 fraction design with added center points.
If you want the cube points divided into fractional blocks, give the formula(s) in the blockgen
argument of cube
, or the blocks
argument of ccd
. For instance, suppose we call ‘cube(basis = A+B+C+D+E’, ‘generators = F~-A*C*D)’.
This design has 32 runs; but adding the argument ‘blockgen = c("A*B*C","C*D*E")’ will
create a fractional block of 32/4 = 8 runs. (cube
is flexible; we could have used a
formula instead, either ‘blockgen = ~ c(A*B*C, C*D*E)’ or
‘blockgen = c(~A*B*C, ~C*D*E)’.) Center points are added to each block as specified.
In a call to ccd
with the same basis
and generators
, adding
‘blocks = Day ~ c(A*B*C, C*D*E)’ would do the same thing, only all 4 blocks will be
included, and a factor named Day
distinguishes the blocks.
The functions star
, dupe
, and foldover
provide for creating new design blocks based on an existing design. They also provide for delayed evaluation: if the basis
argument is missing, these functions simply return the call, djoin
will fill-in ‘basis = design1’ and evaluate it.
dupe
simply makes a copy of the design, and re-randomizes it. Therefore it is also a convenient way to re-randomize a design. If coding
is provided, the coding formulas are replaced as well – for example, to re-center the design.
Use star
to generate star (axis) points, which consist of center points plus points at +/- alpha
on each coordinate axis. You may specify the alpha
you want, or a character argument to specify a certain criterion be met. For example, using delayed evaluation, ‘ccd1 = djoin(cube1, star(alpha="sph"))’ will return a CCD with cube1
as the cube block, and with axis points at the same distance as the corners of the cube. Conditions for the criteria on alpha
are described in detail in references such as Myers et al. (2009).
In star
, determinations of orthogonality and rotatability are based on computed design moments of basis
, rather than any assumptions about the structure of the design being augmented. Thus, it may be possible to augment an unusual design to obtain a rotatable design. Also, if an orthogonal star block is requested, the value of alpha
may vary from axis to axis if that is required to satisfy the condition.
foldover
reverses the levels of one or more design variables (i.e., those that are coded). By default, it reverses them all. However, if the bid
argument is supplied, it instead returns the bid
th fractional block that cube
would have generated. That is, ‘foldover(des, bid=3)’ is equivalent to ‘cube(<arguments that created des>, bid=3)’ – only it does so much more efficiently by folding on the appropriate factors.
In cases where there are constraints on the region of operability, you may want to specify inscribed = TRUE
. This will scale-down the design so that no coded value exceeds 1. If using a building-block approach starting with a first-order design from cube
, call cube
with inscribed
set to the anticipated value of alpha
, or use ‘inscribed = TRUE’, and then use ‘alpha = "spherical"’ in the subsequent call to star
.
ccd
generates an entire CCD. In practice, the building-block approach with cube
, star
, etc. is usually preferable, but ccd
exists for convenience and backward compatibility with pre-2.00 versions of rsm. Many of the arguments are the same as those in cube
; however, n0
, wbreps
, bbreps
may be single values or vectors; if vectors, the first element is for the cube portions and the second element is for the star portions. In ccd
, specifying wbreps
is equivalent to specifying reps
in a call to cube
or star
. bbreps
refers to replicate blocks in the experiment, so that ‘bbreps = c(2,3)’ specifies that we join two cube blocks and three blocks of star points.
If coding
is not specified in a new design, default identity codings are created, e.g. ‘x1 ~ x1.as.is’.
A coded.data
object with the generated design, with additional variables run.order
and std.order
. If a multi-block design, the generated blocking variable will be a factor
; all other variables will be numeric. The designs are sorted by blocks and run.order
within blocks; and (unlike pre-1.41 versions of rsm) the row.names
will be integers corresponding to this ordering. The user may sort by block and std.order
within block to display the designs in their pre-randomized order.
Poor choices of generators
and/or blocks
can alias or partially alias some effects needed to estimate a second-order response surface. It is a good idea to run varfcn
before collecting data to examine the prediction capabilities of the design and to ensure that the desired model can be fitted.
The function ccd.pick
is available to help determine good choices for arguments to cube
, star
, and ccd
.
An alternative to a CCD when you want to go straight to second-order modeling is a Box-Behnken design, generated by bbd
. These designs are not as various or flexible as CCDs, but they can require fewer runs.
The non-exported function rsm:::.ccd.1.41
is provided in case it is needed by other packages for compatibility with old versions of rsm (version 1.41 or earlier). Given the same seed, it will also reproduce the randomization as a previously generated design from an old version.
Russell V. Lenth
Lenth RV (2009) “Response-Surface Methods in R, Using rsm”, Journal of Statistical Software, 32(7), 1–17. \Sexpr[results=rd]{tools:::Rd_expr_doi("10.18637/jss.v032.i07")}
Myers, RH, Montgomery, DC, and Anderson-Cook, CM (2009) Response Surface Methodology (3rd ed.), Wiley.
ccd.pick
, coded.data
, varfcn
, bbd
library(rsm)
### Generate a standard 3-variable first-order design with 8 corner points and 4 center points
( FOdes <- cube (3, n0 = 4, coding = list (
x1 ~ (Temp - 150)/10, x2 ~ (Pres - 50)/5, x3 ~ Feedrate - 4)) )
### Add an orthodonal star block with 12 runs to create a second-order CCD
( SOdes <- djoin(FOdes, star(n0=6)) )
### Same as above, except make the whole CCD at once; and make it rotatable
### and inscribed so that no coded value exceeds 1
SOdes2 <- ccd (3, n0 = c(4,6), alpha = "rotatable", inscribed = TRUE, coding = list (
x1 ~ (Temp - 150)/10, x2 ~ (Pres - 50)/5, x3 ~ Feedrate - 4))
### Make two replicate blocks of FOdes (2nd one randomized differently)
djoin(FOdes, dupe(FOdes))
### Fractional blocking illustration (with no center points)
# Basic design (bid = 1 ---> block generators b1 = -1, b2 = -1)
block1 <- cube (~ x1 + x2 + x3 + x4, generators = x5 ~ x1 * x2 * x3 * x4,
n0 = 0, blockgen = ~ c(x1 * x2, x1 * x3), bid = 1)
block1
# The foldover (on all variables) of block1, in the same order
foldover(block1, randomize=FALSE)
# The 4th fractional block:
( block4 <- foldover(block1, bid = 4) )
Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.