@@ -1,7 +1,7 @@

 Package: ShortRead

 Type: Package

 Title: Base classes and methods for high-throughput short-read sequencing data.

-Version: 0.1.52

+Version: 0.1.53

 Author: Martin Morgan, Michael Lawrence, Simon Anders

 Maintainer: Biocore Team c/o BioC user list <bioconductor@stat.math.ethz.ch>

 Description: Base classes, functions, and methods for representation of

@@ -103,14 +103,14 @@ setClass("ExperimentPath", contains = c(".ShortReadBase"),

 setClass("SRSet", contains = ".ShortReadBase",

          representation = representation(

            sourcePath="ExperimentPath", # for lazy loading

-           readInds="integer", # for tracking subsets and sorting

-           readCounts="integer", # counts of reads in each sample

+           readIndex="integer", # for tracking subsets and sorting

+           readCount="integer", # counts of reads in each sample

            phenoData="AnnotatedDataFrame", # experimental design

            readData="AnnotatedDataFrame"), # arbitrary read annotations

          prototype = prototype(

            sourcePath=new("ExperimentPath"),

-           readInds=NA_integer_,

-           readCounts=NA_integer_,

+           readIndex=integer(0),

+           readCount=integer(0),

            phenoData=new("AnnotatedDataFrame"),

            readData=new("AnnotatedDataFrame")),

          validity = .srValidity)

@@ -101,6 +101,14 @@ setGeneric("alphabetScore", function(object, ...) {

 setGeneric("readAligned", function(dirPath, pattern=character(0), ...)

            standardGeneric("readAligned"), signature="dirPath")

+## ExperimentPath

+

+experimentPath <- function(object, ...) {

+    slot(object, "basePath")

+}

+

+setGeneric("experimentPath")

+

 ## *Set

 setGeneric("qa", function(dirPath, ...) standardGeneric("qa"))

@@ -25,19 +25,19 @@ setMethod(".srValidity", "ExperimentPath", function(object) {

     }

 }

-ExperimentPath <- function(experimentPath, ...) {

+ExperimentPath <- function(experimentPath=NA_character_, ...) {

     new("ExperimentPath", basePath=experimentPath, ...)

 }

-experimentPath <- basePath <- function(object, ...) {

-    slot(object, "basePath")

-}

-

 basePath <- function(object, ...) {

     .Deprecated("experimentPath")

     experimentPath(object, ...)

 }

+setMethod("sampleNames", "ExperimentPath", function(object) {

+    character(0)

+})

+

 .show_additionalPathSlots <- function(object) { # for derived classes

     catPath <- function(nm) {

         vals <- do.call(nm, list(object))

@@ -1,13 +1,13 @@

-RochePath <- function(basePath,

-                      readPath=.srPath(basePath, "^run"),

+RochePath <- function(experimentPath=NA_character_,

+                      readPath=.srPath(experimentPath, "^run"),

                       qualPath=readPath,

                       ..., verbose=FALSE) {

     if (verbose) {

-      .checkPath(basePath)

+      .checkPath(experimentPath)

       .checkPath(readPath)

       .checkPath(qualPath)

     }

-    new("RochePath", ..., basePath=basePath,

+    new("RochePath", ..., basePath=experimentPath,

         readPath=readPath, qualPath=qualPath)

 }

@@ -52,7 +52,11 @@ setMethod("readQual", "RochePath", .readQual_RochePath)

 setMethod("read454", "RochePath", .read454_RochePath)

 .sampleNames_RochePath <- function(object) {

-  sub("_.*", "", basename(.file_names(readPath(object), "\\.fna")))

+    path <- readPath(object)

+    if (!is.na(path))

+        sub("_.*", "", basename(.file_names(path, "\\.fna")))

+    else

+        callNextMethod()

 }

 setMethod("sampleNames", "RochePath", .sampleNames_RochePath)

@@ -1,62 +1,68 @@

 .SRSet_validity <- function(object) {

-  msg <- NULL

-  len <- length(readInd(object))

-  rlen <- c(readData = nrow(readData(object)))

-  if (!all(rlen==len)) {

-    bad <- rlen!=len

-    msg <- c(msg,

-             sprintf("read length mismatch: expected %d, found:\n  %s",

-                     rlen, paste(names(rlen)[bad], rlen[bad], sep="=",

-                                collapse=", ")))

-  }

-  snames <- sampleNames(experimentPath(object))

-  slen <- length(snames)

-  oslen <- c(phenoData = nrow(phenoData(object)),

-             readCount = length(readCount(object)))

-  if (!all(oslen==slen)) {

-    bad <- oslen!=slen

-    msg <- c(msg,

-             sprintf("sample length mismatch: expected %d, found:\n  %s",

-                     slen, paste(names(oslen)[bad], oslen[bad], sep="=",

-                                collapse=", ")))

-  }

-  osnames <- sampleNames(object)

-  stest <- snames == osnames

-  if (!all(stest))

-    msg <- c(msg,

-             sprintf("sample names mismatch:\n  %s",

-                     slen, paste(snames[!stest], osnames[!stest],

-                                 sep = "!=", collapse = ", ")))

-  rind <- readInd(object)

-  if (!all(rind > 0 & rind <= len))

-    msg <- c(msg, "values in 'readInd' must be > 0 and <= number of reads")

-  rcount <- readCount(object)

-  if (!all(rcount >= 0))

-    msg <- c(msg, "values in 'readCount' must be non-negative")

-  if (sum(rcount) != len)

-    msg <- c(msg,

-             sprintf("'sum(readCount)', %d, must equal the number of reads, %d",

-                     sum(rcount), len))

-  if (is.null(msg)) TRUE else msg

+    msg <- NULL

+    len <- length(readIndex(object))

+    rlen <- c(readData = nrow(readData(object)))

+    if (!all(rlen==len)) {

+        bad <- rlen!=len

+        msg <- c(msg,

+                 sprintf("read length mismatch: expected %d, found:\n  %s",

+                         rlen, paste(names(rlen)[bad], rlen[bad],

+                                     sep="=", collapse=", ")))

+    }

+    snames <- sampleNames(sourcePath(object))

+    slen <- length(snames)

+    oslen <- c(phenoData = nrow(phenoData(object)),

+               readCount = length(readCount(object)))

+    if (!all(oslen==slen)) {

+        bad <- oslen!=slen

+        msg <- c(msg,

+                 sprintf("sample length mismatch: expected %d, found:\n  %s",

+                         slen, paste(names(oslen)[bad], oslen[bad],

+                                     sep="=", collapse=", ")))

+    }

+    osnames <- sampleNames(object)

+    stest <- snames == osnames

+    if (!all(stest))

+        msg <- c(msg,

+                 sprintf("sample names mismatch:\n  %s",

+                         slen, paste(snames[!stest], osnames[!stest],

+                                     sep = "!=", collapse = ", ")))

+    rind <- readIndex(object)

+    if (!all(rind > 0 & rind <= len))

+        msg <- c(msg, "values in 'readIndex' must be > 0 and <= number of reads")

+    rcount <- readCount(object)

+    if (!all(rcount >= 0))

+        msg <- c(msg, "values in 'readCount' must be non-negative")

+    if (sum(rcount) != len)

+        msg <- c(msg,

+                 sprintf("'sum(readCount)', %d, must equal the number of reads, %d",

+                         sum(rcount), len))

+    if (is.null(msg)) TRUE else msg

 }

 setMethod(".srValidity", "SRSet", .SRSet_validity)

+.make_getter(c("readData", "sourcePath", "readIndex", "readCount"))

+

+setMethod("experimentPath", "SRSet", function(object, ...) {

+    callGeneric(sourcePath(object), ...)

+})

+

 setMethod("sampleNames", "SRSet", function(object) {

-  sampleNames(phenoData(object))

+    sampleNames(phenoData(object))

 })

 setMethod("show", "SRSet", function(object) {

     callNextMethod()

-    cat("basePath(sourcePath(object)):\n  ",

-        basePath(sourcePath(object)), "\n", sep="")

+    cat("experimentPath(object): ", experimentPath(object), "\n",

+        sep="")

 })

 setMethod("detail", "SRSet", function(object, ...) {

     callNextMethod()

-    cat("\n")

+    cat("\nsourcePath\n")

     detail(sourcePath(object), ...)

-    cat("\nclass: AnnotatedDataFrame\n")

+    cat("\nphenoData\n")

     pd <- phenoData(object)

     cat("pData:\n")

     print(pData(pd))

@@ -66,7 +72,6 @@ setMethod("detail", "SRSet", function(object, ...) {

 setMethod("phenoData", "SRSet", function(object) object@phenoData)

-.make_getter(c("readData", "sourcePath"))

 ## proposed

 ##setMethod("readSRQ", "SRSet", function(object) readSRQ(sourcePath(object)))

@@ -5,47 +5,26 @@ setMethod(".srValidity", "SolexaPath", function(object) {

     if (is.null(msg)) TRUE else msg

 })

-.solexaPath <- function(path, pattern) {

-    path <- path.expand(path)

-    tryCatch({

-        res <- list.files(path, pattern=pattern, full.name=TRUE)

-        if (length(res)==0) NA_character_

-        else res

-    }, warning=function(warn) NA_character_)

-}

-

-SolexaPath <- function(experimentPath,

-                       dataPath=.solexaPath(experimentPath, "Data"),

-                       scanPath=.solexaPath(dataPath, "GoldCrest"),

-                       imageAnalysisPath=.solexaPath(dataPath, "^C"),

-                       baseCallPath=.solexaPath(imageAnalysisPath,

+SolexaPath <- function(experimentPath=NA_character_,

+                       dataPath=.srPath(experimentPath, "Data"),

+                       scanPath=.srPath(dataPath, "GoldCrest"),

+                       imageAnalysisPath=.srPath(dataPath, "^C"),

+                       baseCallPath=.srPath(imageAnalysisPath,

                          "^Bustard"),

-                       analysisPath=.solexaPath(baseCallPath,

+                       analysisPath=.srPath(baseCallPath,

                          "^GERALD"),

                        ..., verbose=FALSE) {

-    checkPath <- function(path) {

-        nm <- deparse(substitute(path))

-        if (length(path)==0) {

-            warning(nm, " not defined")

-        } else {

-            for (p in path)

-                if (!file.exists(p)) 

-                    warning(nm, " '", p, "' does not exist")

-        }

-    }

     if (verbose) {

-        checkPath(experimentPath)

-        checkPath(dataPath)

-        checkPath(scanPath)

-        checkPath(imageAnalysisPath)

-        checkPath(baseCallPath)

-        checkPath(analysisPath)

+        .checkPath(experimentPath)

+        .checkPath(dataPath)

+        .checkPath(scanPath)

+        .checkPath(imageAnalysisPath)

+        .checkPath(baseCallPath)

+        .checkPath(analysisPath)

     }

-    new("SolexaPath", ...,

-        basePath=experimentPath,

-        dataPath=dataPath, scanPath=scanPath,

-        imageAnalysisPath=imageAnalysisPath, baseCallPath=baseCallPath,

-        analysisPath=analysisPath)

+    new("SolexaPath", ..., basePath=experimentPath, dataPath=dataPath,

+        scanPath=scanPath, imageAnalysisPath=imageAnalysisPath,

+        baseCallPath=baseCallPath, analysisPath=analysisPath)

 }

 .make_getter(slotNames("SolexaPath"))

@@ -39,7 +39,7 @@

   \describe{

     \item{\code{basePath}}{See above.}

   }

-  The slot is accessed with \code{basePath} or \code{experimentPath}.

+  The slot is accessed with \code{experimentPath}.

 }

 \section{Extends}{

   Class \code{"\linkS4class{.ShortReadBase}"}, directly.

@@ -28,6 +28,7 @@

 \alias{alphabetByCycle,FastqQuality-method}

 \alias{srsort,FastqQuality-method}

 \alias{srorder,FastqQuality-method}

+\alias{srrank,FastqQuality-method}

 \alias{srduplicated,FastqQuality-method}

 \title{Quality scores for short reads and their alignments}

@@ -127,11 +128,12 @@

     \item{srsort}{\code{signature(x = "FastqQuality")}:}

     \item{srorder}{\code{signature(x = "FastqQuality")}:}

+    \item{srrank}{\code{signature(x = "FastqQuality")}:}

     \item{srduplicated}{\code{signature(x = "FastqQuality")}:

-      Apply \code{\link{srsort}}, \code{srorder}, \code{srduplicated} to

-      quality scores, returning objects as described on the appropriate

-      help page.}

+      Apply \code{\link{srsort}}, \code{srorder}, \code{srrank}, and

+      \code{srduplicated} to quality scores, returning objects as

+      described on the appropriate help page.}

   }

 }

@@ -6,6 +6,7 @@

 % methods

 \alias{SolexaSet,SolexaPath-method}

 \alias{qa,SolexaPath-method}

+\alias{report,SolexaPath-method}

 \alias{show,SolexaPath-method}

 \alias{detail,SolexaPath-method}

 % transforming methods

@@ -121,13 +122,20 @@ Class \code{"\linkS4class{.ShortReadBase}"}, by class ".Solexa", distance 2.

       \code{signature(dirPath="SolexaPath", pattern="character(0)", run=1, ...)}:

       Use \code{analysisPath(dirPath)[[run]]} as the directorpy path and

-      \code{pattern="s_[1_8]_export.txt"} as the pattern for discovering solexa

+      \code{pattern="s_[1-8]_export.txt"} as the pattern for discovering solexa

       \code{export}-formatted fileds, returning a

       \code{\linkS4class{SolexaExportQA}} object summarizing quality

       assessment. If \code{Rmpi} has been initiated, quality assessment

       calculations are distributed across available nodes (one node per

       export file.)}

+    \item{report}{

+      \code{signature(x, ..., dest=tempfile(), type="pdf")}: Use

+      \code{qa(x, ...)} to generate quality assessment measures, and

+      use these to generate a quality assessment report at location

+      \code{dest} of type \code{type} (e.g., \sQuote{pdf}).

+    }

+

     \item{SolexaSet}{\code{signature(path = "SolexaPath")}: create a

       \code{\linkS4class{SolexaSet}} object based on \code{path}.}

@@ -14,7 +14,6 @@

 \alias{alignData}

 % Solexa

 \alias{experimentPath}

-\alias{basePath}

 \alias{dataPath}

 \alias{scanPath}

 \alias{imageAnalysisPath}

@@ -48,7 +47,6 @@ alignQuality(object, ...)

 alignData(object, ...)

 ## Solexa

 experimentPath(object, ...)

-basePath(object, ...)

 dataPath(object, ...)

 scanPath(object, ...)

 imageAnalysisPath(object, ...)

new file mode 100644

@@ -0,0 +1,28 @@

+\name{deprecated}

+

+\alias{deprecated}

+\alias{basePath}

+

+\title{Deprecated and defunct functions}

+

+\description{

+

+  These functions were introduced but are now deprecated or defunct.

+

+}

+\usage{

+

+basePath(object, ...)

+

+}

+

+\arguments{

+

+  \item{object}{For \code{basePath}, and object of class

+  \code{ExperimentPath}.}

+

+  \item{...}{Additional arguments.}

+

+}

+\author{Martin Morgan}

+\keyword{manip}