preprocess               package:Ringo               R Documentation

_P_r_e_p_r_o_c_e_s_s _R_a_w _C_h_I_P-_c_h_i_p _I_n_t_e_n_s_i_t_i_e_s

_D_e_s_c_r_i_p_t_i_o_n:

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

_U_s_a_g_e:

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

_A_r_g_u_m_e_n_t_s:

    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'

_D_e_t_a_i_l_s:

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

     _l_o_e_s_s Calls 'normalizeWithinArrays' with 'method="loess"'.

     _v_s_n Calls 'normalizeBetweenArrays' with 'method="vsn"'.

     _G_q_u_a_n_t_i_l_e Calls 'normalizeBetweenArrays' with
          'method="Gquantile"'.

     _R_q_u_a_n_t_i_l_e Calls 'normalizeBetweenArrays' with
          'method="Rquantile"'.

     _m_e_d_i_a_n Calls 'normalizeWithinArrays' with 'method="median".'

     _n_i_m_b_l_e_g_e_n Scaling procedure used by Nimblegen. Yields scaled
          log-ratios by a two step procedure: srat = log2(R) - log2(G)
          srat = srat - tukey.biweight(srat)

     _G_v_s_n Learns 'vsn' model on green channel intensities only and
          applies that transformation to both channels before computing
          fold changes.

     _R_v_s_n Learns 'vsn' model on red channel intensities only and
          applies that transformation to both channels before computing
          fold changes.

     _n_o_n_e 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'.

_V_a_l_u_e:

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

_N_o_t_e:

     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.

_A_u_t_h_o_r(_s):

     Joern Toedling toedling@ebi.ac.uk

_S_e_e _A_l_s_o:

     'normalizeWithinArrays', 'normalizeBetweenArrays',
     'malist','ExpressionSet', 'vsnMatrix'

_E_x_a_m_p_l_e_s:

        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"))

