preprocess {Ringo} | R Documentation

## Preprocess Raw ChIP-chip Intensities

### Description

Calls one of various (`limma`) functions to transform raw probe intensities into (background-corrected) normalized log ratios (M-values).

### Usage

    preprocess(myRG, method="vsn", ChIPChannel="R", inputChannel="G",
               returnMAList=FALSE, idColumn="PROBE_ID", verbose=TRUE, ...)

### Arguments

`myRG` | object of class `RGList`
`method` | string; denoting which normalization method to choose, see below for details
`ChIPChannel` | string; which element of the `RGList` holds the ChIP result, see details
`inputChannel` | string; which element of the `RGList` holds the untreated input sample; see details
`returnMAList` | logical; should an MAList object be returned? Default is to return an ExpressionSet object.
`idColumn` | string; indicating which column of the `genes` data.frame of the RGList holds the identifier for reporters on the microarray. This column, after calling `make.names` on it, will make up the unique `featureNames` of the resulting `ExpressionSet`. If argument `returnMAList` is `TRUE`, this argument is ignored.
`verbose` | logical; progress output to STDOUT?
`...` | further arguments to be passed on `normalizeWithinArrays` and `normalizeBetweenArrays`

### Details

The procedure and called `limma` functions depend on the choice of method.

loess

  Calls `normalizeWithinArrays` with `method="loess"`.

vsn

  Calls `normalizeBetweenArrays` with `method="vsn"`.

Gquantile

  Calls `normalizeBetweenArrays` with `method="Gquantile"`.

Rquantile

  Calls `normalizeBetweenArrays` with `method="Rquantile"`.

median

  Calls `normalizeWithinArrays` with `method="median".`

nimblegen

  Scaling procedure used by Nimblegen. Yields scaled log-ratios by a two step procedure: srat = log2(R) - log2(G) srat = srat - tukey.biweight(srat)

Gvsn

  Learns `vsn` model on green channel intensities only and applies that transformation to both channels before computing fold changes.

Rvsn

  Learns `vsn` model on red channel intensities only and applies that transformation to both channels before computing fold changes.

none

  No normalization of probe intensities, takes raw `log2(R)-log2(G)` as component `M` and `(log2(R)+log2(G))/2` as component `A`; uses `normalizeWithinArrays` with `method="none"`.

Mostly with two-color ChIP-chip, the ChIP sample is marked with the red Cy5 dye and for the untreated input sample the green Cy3 dye is used. In that case the RGList`myRG`'s element `R` holds the ChIP data, and element `G` holds the input data. If this is not the case with your data, use the arguments `ChIPChannel` and `inputChannel` to specify the respective elements of `myRG`.

### Value

Returns normalized, transformed values as an object of class `ExpressionList` or `MAList`.

### Note

Since Ringo version 1.5.6, this function does not call limma's function `backgroundCorrect` directly any longer. If wanted by the user, background correction should be indicated as additional arguments passed on to `normalizeWithinArrays` or `normalizeBetweenArrays`, or alternatively call `backgroundCorrect` on the `RGList` before `preprocess`ing.

### Author(s)

Joern Toedling

### See Also

`normalizeWithinArrays`, `normalizeBetweenArrays`, `malist`, `ExpressionSet`, `vsnMatrix`

### Examples

       exDir <- system.file("exData",package="Ringo")
       exRG <- readNimblegen("example_targets.txt","spottypes.txt",
                             path=exDir)
       exampleX <- preprocess(exRG)
       sampleNames(exampleX) <- make.names(paste(exRG$targets$Cy5,"vs",
                                            exRG$targets$Cy3,sep="_"))
       print(exampleX)
       ### compare VSN to NimbleGen's tukey-biweight scaling
       exampleX.NG <- preprocess(exRG, method="nimblegen")
       sampleNames(exampleX.NG) <- sampleNames(exampleX)
       if (interactive())
         corPlot(cbind(exprs(exampleX),exprs(exampleX.NG)),
           grouping=c("VSN normalized","Tukey-biweight scaled"))

[Package Ringo version 1.46.0 Index]