expressopdnn            package:affypdnn            R Documentation

_P_o_s_i_t_i_o_n _D_e_p_e_n_d_a_n_t _N_e_a_r_e_s_t _N_e_i_g_h_b_o_r_s _m_o_d_e_l _f_o_r _a_f_f_y

_D_e_s_c_r_i_p_t_i_o_n:

     a wrapper to perform the PDNN method.

_U_s_a_g_e:

     pdnn.scalevalue.exprSet(eset, scale.to=500)
     expressopdnn(afbatch,
           # background correction
                  bg.correct = FALSE,
                  bgcorrect.method = NULL,
                  bgcorrect.param = list(),
           # normalize
                  normalize = FALSE,
                  normalize.method = NULL,
                  normalize.param = list(),
                   pmcorrect.method = c("pdnn", "pdnnpredict"),
           # pdnn
                  params.chiptype = NULL,          
           # expression values
                  summary.subset = NULL,
           # PDNN expression values scaling
                  eset.normalize = TRUE,
                  scale.to = 500,
           # misc.
                  verbose = TRUE,
                  widget = FALSE)

_A_r_g_u_m_e_n_t_s:

 afbatch: object of 'AffyBatch-class'

bg.correct: a boolean to express whether background correction is
          wanted or not.

bgcorrect.method: the name of the background adjustment method

bgcorrect.param: a list of parameters for bgcorrect.method (if
          needed/wanted)

    eset: An object of 'exprSet-class'

normalize: normalization step wished or not.

normalize.method: the normalization method to use

normalize.param: a list of parameters to be passed to the normalization
          method (if wanted).

pmcorrect.method: the name of the PM adjustement method (only two
          choices here, default to 'pdnn').

params.chiptype: An object with chip type specific parameters. If
          'NULL', the parameter files included in the package will be
          used whenever possible...

eset.normalize: is any normalization step on expression values to be
          performed

scale.to: a value to scale against.

summary.subset: a list of 'affyids'. If 'NULL', a expression summary
          value is computed for everything on the chip.

 verbose: logical value. If 'TRUE' it writes out some messages.

  widget: a boolean to specify the use of widgets (the package tkWidget
          is required). NOTE: this not yet implemented !

_D_e_t_a_i_l_s:

     'expressopdnn' is very similar to 'expresso'. It is mainly a
     wrapper around the pre-processing steps `background correction',
     `normalization', `perfect match correction' and the PDNN method to
     compute expression values (see the first reference for more
     details about the preprocessing steps and and the second reference
     for further details about the PDNN method).

     The wrapper 'expresso' has no way to handle easily the computation
     of chip-wide results that have to be used during the
     'computeExprSet' step. An easy way to overcome this was to write
     this simple wrapper.

     'pdnn.scalevalue' is performed after the expression values have
     computed to somehow `normalize' the values between different
     chips. When setting 'normalize' to 'TRUE' this step might be
     considered unnecessary (and the 'eset.normalize' set to 'FALSE').

_V_a_l_u_e:

     An object of 'exprsSet-class', with an attribute 'pps.warnings' as
     returned by the method 'computeExprSet'.

_S_e_e _A_l_s_o:

     'expresso and \code{computeExprVal.method.pdnn}'

_E_x_a_m_p_l_e_s:

     library(affydata)
     data(Dilution)

     ## one CEL to go faster
     afbatch <- Dilution[1]

     ## Take only few IDs (the 10 first)
     ids <- ls(getCdfInfo(afbatch))[1:10]
     eset <- expressopdnn(afbatch, bg.correct=FALSE,
                          normalize=FALSE,
                          summary.subset=ids) 

