EexprSet-class             package:maDB             R Documentation

_C_l_a_s_s "_E_e_x_p_r_S_e_t" _a_n _e_x_t_e_n_d_e_d _v_e_r_i_s_i_o_n _o_f _t_h_e "_e_x_p_r_S_e_t" _c_l_a_s_s _f_r_o_m "_B_i_o_b_a_s_e"

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

     The "EexprSet" class extends the "exprSet" class from the package
     "Biobase",  additional functionality that has been included in
     this type of object are a "weights" slot, that can be used to mark
     flagged genes, some generic methods like "drawMA" and
     "drawHistogram" as well the  functions "getM" and "getA" that are
     quite usefull. The "EexprSet" class can be used for both two 
     color micro arrays and Affymetrix GeneChips. Limma objects can be
     converted with the 'createEexprSetFromLimma' function

_O_b_j_e_c_t_s _f_r_o_m _t_h_e _C_l_a_s_s:

     Objects can be created by calls of the form 'new("EexprSet",
     ...)'. if to this call a "exprSet" is submitted, this is converted
     to a "EexprSet" object. All of the following afguments can be
     passed also through the constructor call.

_S_l_o_t_s:

     '_t_y_p_e': Object of class '"character"' specifying if the data
          origins from a one color array ("Affymetrix")  or from a two
          color array ("TwoColor"). This argument is optional. 

     '_p_r_i_n_t_e_r': Object of class '"Layout"' same as in the limma package
          the printer attribute. Defines the  number of rows and
          columns per subgrid as well as the rows and columns of
          subgrids on the array. 

     '_s_a_m_p_l_e_s': Object of class '"list"' a list containing the sample
          names. Optional, the names of the chips/arrays  are anyway
          stored in the rownames of the "exprSet".

     '_a_r_r_a_y._p_a_i_r_s': Object of class '"numeric"' a vector that specifies
          what columns belong to each other.  like the red and green
          intensities per array. In Affymetrix chips this is a optional
          parameter, for two color micro arrys  this parameter should
          be defined. e.g with "array.pairs=c(1,-1,2,-2)" for a
          "EexprSet" that contains data from two arrays  (and has
          therefore 4 expression columns), the number defines what
          columns belong to each other, the signs define the color
          (positive for Red, negative for Green, in the tradition of
          the M value that is 'log2(R)-log2(G)').  By using the
          "createEexprSetFromLimma" one has not to care about all these
          erguments, as the function will read all this from the limma
          object.

     '_w_e_i_g_h_t_s': Object of class '"matrix"' a matrix with zeros (flagged
          features) and ones (not flagged ones). should always have the
          same number of columns and rows as the "exprMatrix". Optional
          argument. 

     '_e_x_p_r_s': Object of class '"exprMatrix"' the object that contains
          the expression information for each gene/feature. In
          Affymetrix GeneChip experiments it has the same number of
          columns as chips and the same number of rows as probe sets on
          each chip. For two color micro arrays it has 2xnumber of
          array columns (as the red and also the green channel  are
          stored each into one column). 

     '_s_e._e_x_p_r_s': Object of class '"exprMatrix"' same as "exprs". 

     '_p_h_e_n_o_D_a_t_a': Object of class '"phenoData"' look at the
          documentation of the "exprSet" object. 

     '_d_e_s_c_r_i_p_t_i_o_n': Object of class '"characterORMIAME"' look at the
          documentation of the "exprSet" object. 

     '_a_n_n_o_t_a_t_i_o_n': Object of class '"character"' look at the
          documentation of the "expSet" class. 

     '_n_o_t_e_s': Object of class '"character"' look at the documentation
          of the "exprSet" class. 

     '_g_e_n_e_s': Object of class '"matrix"', holds information about the
          genes that belong to the rows in the 'exprs' slot. This slot
          is automatically loaded with the 'genes' slot of a 'limma'
          object (MAList or RGList) when the function 'toEexprSet' is
          used to transform those objects into a EexprSet object.

_E_x_t_e_n_d_s:

     Class '"exprSet"', directly.

_M_e_t_h_o_d_s:

     _a_v_e_r_a_g_e See documenation 'average'.

     _d_r_a_w_B_i_o_C_o_n_t_r_o_l_s 'signature(object = "EexprSet")': Draws the
          expression intensities from the biotynilated control
          sequences that Affymetrix included in their GeneChips. 

     _d_r_a_w_H_i_s_t_o_g_r_a_m '(object,index=NULL,type=NULL,draw.pairs=FALSE,nr.br
          eaks=250,draw.legend=FALSE,col=NULL)': Draws histograms of
          the intensities of the different chips. 'index': with index
          you can specify the channels (intensities) for which a
          histogram should be drawn. By default a histogram with all
          channels available will be drawn. 'type': not used yet...
          'draw.pairs': not used yet... 'nr.breaks': the number of
          breaks for the histogram. 'draw.legend': if a legend should
          be drawn into the plot. 'col': the color in which the lines
          should be drawn. By default for each line an other color will
          be used.

     _d_r_a_w_M_A '(object,array.pairs=NULL,g=NULL,r=NULL,log.values=NULL,one
          .image=TRUE,draw.flagged=FALSE,use.weights.from=NULL,main=NUL
          L,colramp=NULL,col=NULL,...)': Draws an M versus A plot of
          the data. By submitting r and g one can specify what chips
          (or channel) should be used as the red intensities and which
          as the green channel. 'array.pairs': a vector with the
          indizes of the channels to compare. Red signal channels
          should be specified as positive numbers, green channels as
          negative ones. When the object was created with the
          'createEexprSetFromLimmaClass' this argument is already
          stored in the object itself. Usually it is better to specify
          the channels to draw with the 'r' and 'g' arguments. 'g': the
          index of the green intensity channel in the 'exprs' matrix.
          'r': the same for the red signal channel. 'log.values': if
          the values in the object are already in log2 scale. This
          argument is optional as the function checks for log scale
          values anyway. 'one.image': if all MA plots should be drawn
          into one image, only usefull when array.pairs are specified!
          'draw.flagged': if the flagged genes should also be drawn
          into the plot (as orange points). 'use.weights.from': index
          of the channel from which the weights should be used; if for
          one MA plot only the weights of one of the two signal
          channels should be used, otherwise only those genes will be
          drawn, that are not flagged bad in both channels. 'main': the
          title for the plot. 'colramp': a function that takes numbers
          as input and returns colors (just like the heat.colors or
          topo.colors). If submitted the points are colored according
          to the density of spots in the place of the point. Requires
          the "geneplotter" package. 'col': the color or vector of
          colors in which the points should be drawn.

     _d_r_a_w_P_o_l_y_A_C_o_n_t_r_o_l_s 'signature(object = "EexprSet")': Draws the
          expression intensities of the poly A control sequences from
          Affymetrix. 

     _g_e_t_A '(object,r,g,remove.flagged=FALSE)': returns the A values
          (average intensity, A = 1/2 * log2(R*G)). To define which
          columns in the expression matrix represent the green and
          which the red channel one can submit the r and g parameters
          with the index of the red signals and green signals
          respectively. For example 'getA(Eset,r=2,g=1)' uses the
          second column of the exprs slot of the Eset object as red
          signal channel in the formula above and the first column as
          green signal channel. It is also possible to submit a
          numerical vector with the indizes of the red signal channels
          as r (for example 'r=c(2,4)') and the same for the g
          parameter ('g=c(1,3). This returns an A values matrix with
          two columns, the first with A values using the the 2nd column
          as red and 1st column as green channel, the second column of
          A values was calculated by using the 4th column as red and
          the 3rd as green channel. By setting the parameter
          \code{remove.flagged} to \code{TRUE} will give all genes that
          have a weight of 0 (in the \code{weights} slot of the
          \code{EexprSet} object) in one of the signal channels a
          \code{NA} value.')

     _g_e_t_A_r_r_a_y_s '(object,...)': returns the names of the arrays of the
          'EexprSet' object submitted.

     _g_e_t_M '(object,r,g,remove.flagged=FALSE)': Same as the getA
          function, but this function returns the regulation M (M =
          log2(R/G)). 

     _g_e_t_S_i_g_n_a_l_C_h_a_n_n_e_l_s '(object,...)': returns the signal channel names
          of the 'EexprSet' object submitted.

     _g_e_t_W_e_i_g_h_t_s 'object)': Returns the weights for the single
          intensities. A weight of 0 means that the feature was
          flagged, a weight of 1 means that the signal is ok. 

     _t_o_E_x_p_r_S_e_t '(object)': Casts the EexprSet object in a expSet
          object. 

     _l_o_a_d_F_r_o_m_D_B '(object,connection,name,pk,v=TRUE)': loads a formerly
          saved (with the function 'publishToDB') 'EexprSet' object
          from the database. This method requires the 'tkfiDB' package.
          Arguments: 'object': a instance of the 'EexprSet' class,
          submit 'new("EexprSet")' to create a new one.  'connection':
          the database connection to a PostgreSQL database. 'name': the
          experiment name (experiment title) that you want to load from
          the database. To get a overview of the available experiments
          in the database you can call
          'dbGetExperimentInfo(connection)'. 'pk': optional argument.
          Useful to load a subset of an experiment from the database.
          Simply submit the primary keys from the signal channels
          (column 'signal_channels_pk' in the result from the
          'dbGetExperimentInfo' function). 'v': if TRUE additional
          informations will be printed to the console.

     _p_u_b_l_i_s_h_T_o_D_B 'signature(object = "EexprSet")': stores the object
          into a PostgreSQL database. Call 'help(publishToDB)' to get
          more information of this method. This method requires the
          'tkfiDB' package.

     _w_r_i_t_e_T_a_b_l_e '(object,file,mas5calls,include.annotation)': writes
          the expression values to a tab delimited table. Arguments:
          'object': the object from the type 'EexprSet' that contains
          the normalized values. 'file': the file where the data should
          be written into. 'mas5calls': optional, for MAS5 normalized
          chips. If submitted, the calls will be included in the output
          file.

_N_o_t_e:

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

     Johannes Rainer

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

     'createEexprSetFromLimma', 'average'

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

