normalise             package:arrayMagic             R Documentation

_N_o_r_m_a_l_i_s_a_t_i_o_n _o_f _m_i_c_r_o_a_r_r_a_y _d_a_t_a

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

     An object of class 'exprSetRG' is generated which contains the
     resulting normalised data.

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

     normalise(arrayDataObject, subtractBackground = FALSE, method = "vsn", subGroups = NULL, channelsSeparately = FALSE, hybridisationGroups, spotIdentifier, verbose = TRUE, ...)

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

arrayDataObject: object of class 'arrayData'; required; default
          missing. 'arrayDataObject' must contain the raw data, i.e. a
          three dimensional array (spot x channel x hybridisation), cf.
          the class methods 'getIntensities' and 'intensities<-', and
          must contain information on the hybridisations, cf. class
          methods 'getHybAttr' and '{hybAttrList<-}'. If the argument
          'subGroups' (see below) is specified it must also contain 
          information on the spots, cf. the class methods 'getSpotAttr'
          and 'spotAttr<-'. Note: Weights are only used by loess-type
          normalisations. 

subtractBackground: logical; default: 'FALSE'

  method: character string; required; default: "'vsn'"; possible
          values: "'none'", "'vsn'", "'quantile'", "'loess'",
          "'loessScale'", "'loessQuantile'". Note: "'quantile'" and 
          "'loess*'" normalisation transform the data to the (natural)
          logarithmic scale. Note: Weights are only used by loess-type
          normalisations. Note: "'loessScale'" and "'loessQuantile'"
          refer to a loess normalisation followed by a between slide
          normalisation, cf. the function 'normalizeBetweenArrays' of
          the 'limma' package. Note: "'quantile'" and  "'loess*'"
          normalisations do call the corresponding methods of the
          'limma' package and "'vsn'" uses the 'vsn' package. 

subGroups: character string or 'NULL'; required; default: 'NULL';
          'subGroups' allows to define subgroups of spots of each
          hybridisation which are normalised separately like a 
          print-tip normalisation. The list must contain a column name
          refering to the 'data.frame' of
          'getSpotAttr(arrayDataObject)'. In case of GenePix data you
          may for example specify the column name "Block". The column
          itself must contain integer values. Note: In case of 'method
          == "vsn"', 'vsn' is called with the argument 'strata', which
          differs to a separate normalisation of each subgroup with
          'vsn' itself.  

channelsSeparately: logical; required; default: 'FALSE'; If
          'channelsSeparately' ist set to 'TRUE' each channel is
          normalised separately. Only meaningful for single channel
          normalisation methods like "'vsn'" and "'quantile'"
          normalisation but not for ratio based normalisation like
          "'loess'".

hybridisationGroups: list of vectors of indexes or the character string
          "slideBySlide"; optional; default: missing. Each group of
          hybridisations is normalised separately. If missing all
          hybridisations are taken as one group. Only meaningful for
          normalisation methods like "vsn" and "quantile". The indexes
          must refer to the third dimension of
          'getIntensities(arrayDataObject)' and have to contain all
          hybridisations. 

spotIdentifier: character string; optional; default missing.
          'spotIdentifier' specifies the column of
          'getSpotAttr(arrayDataObject)' which must contain non-unique
          spot or gene identifiers. The identifiers are used as names
          for the resulting 'exprSetRG'-object; cf. the function
          'geneNames' of the 'exprSetRG-class'. 

 verbose: logical; required; default: 'TRUE'

     ...: further arguments which are passed to 'vsn' if "'vsn'" is
          specified for normalisation. The arguments must not include
          'strata' and 'verbose'. 

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

     object of class 'exprSetRG'

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

     Andreas Buness <a.buness@dkfz.de>

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

     'exprSetRG-class', 'processArrayData', 'processArrayDataObject'

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

            intensities <- array(data=runif(720),dim=c(120,2,3))
            dimnames(intensities) <- list(NULL, c("green","red"), NULL)
            hybAttr <- data.frame(Name=I(c("hx","hy","hz")), Index=c(1:3))
             arrayDataObject <- new("arrayData",
                                   intensities=intensities,
                                   hybAttrList=list(red=hybAttr,green=hybAttr)
                                  )
            exprSetRGObject <- normalise(arrayDataObject = arrayDataObject,
                                    subtractBackground = FALSE,
                                    method = "none",
                                    verbose = TRUE
                                    )
            nRed <- exprs(getExprSetRed(exprSetRGObject))
            nGreen <- exprs(getExprSetGreen(exprSetRGObject))
            stopifnot( all.equal.numeric( as.vector(nRed), as.vector(intensities[,"red",] )))
            stopifnot( all.equal.numeric( as.vector(nGreen), as.vector(intensities[,"green",] )) ) 

              
      

