@@ -2,7 +2,7 @@ Package: mzR

 Type: Package

 Title: parser for netCDF, mzXML, mzData and mzML and mzIdentML files

        (mass spectrometry data)

-Version: 2.13.1

+Version: 2.13.2

 Author: Bernd Fischer, Steffen Neumann, Laurent Gatto, Qiang Kou

 Maintainer: Bernd Fischer <b.fischer@dkfz.de>,

 	    Steffen Neumann <sneumann@ipb-halle.de>,

@@ -47,6 +47,7 @@ exportMethods(close,

               tic,

               chromatogram,

               chromatograms,

+              chromatogramHeader,

               writeMSData)

 exportClasses("mzR",

@@ -1,3 +1,8 @@

+CHANGES IN VERSION 2.13.2

+--------------------------

+ o Add chromatogramHeader method to read header information for chromatograms

+   from an mzML file.

+

 CHANGES IN VERSION 2.13.1

 --------------------------

  o Read filter string from mzML files and add it to the data.frame returned by

@@ -13,6 +13,8 @@ setGeneric("writeMSfile", function(object, filename, outformat) standardGeneric(

 ##            function(object, filename, outformat, header, data)

 ##                standardGeneric("writeSpectrumList"))

 setGeneric("chromatogramsInfo", function(object) standardGeneric("chromatogramsInfo"))

+setGeneric("chromatogramHeader", function(object, chrom)

+    standardGeneric("chromatogramHeader"))

 setGeneric("creationDate", function(object) standardGeneric("creationDate"))

 setGeneric("manufacturer", function(object) standardGeneric("manufacturer"))

 setGeneric("model", function(object) standardGeneric("model"))

@@ -198,3 +198,19 @@ setMethod("chromatogram", "mzRpwiz",

               }

               return(ans)

           })

+

+setMethod("chromatogramHeader", "mzRpwiz",

+          function(object, chrom) {

+              if (missing(chrom)) {

+                  res <- object@backend$getAllChromatogramHeaderInfo()

+              } else {

+                  stopifnot(is.numeric(chrom))

+                  n <- nChrom(object)

+                  if (min(chrom) < 1 || max(chrom) > n)

+                      stop("Index out of bound [", 1, ":", n, "]")

+                  chrom <- chrom -1L

+                  res <- object@backend$getChromatogramHeaderInfo(chrom)

+              }

+              res$chromatogramId <- as.character(res$chromatogramId)

+              res

+          })

@@ -21,3 +21,36 @@ test_chromatograms2 <- function() {

     checkIdentical(tic(x), chromatogram(x, 1L))

     checkIdentical(nrow(tic(x)), 7534L)

 }

+

+test_chromatogramHeader <- function() {

+    library(mzR)

+    library(RUnit)

+    library(msdata)

+    

+    f <- proteomics(full.names = TRUE, pattern = "MRM")

+    x <- openMSfile(f)

+

+    chrs <- chromatogram(x)

+    ch <- chromatogramHeader(x)

+    checkEquals(colnames(ch), c("chromatogramId", "chromatogramIndex", "polarity",

+                                "precursorIsolationWindowTargetMZ",

+                                "precursorIsolationWindowLowerOffset",

+                                "precursorIsolationWindowUpperOffset",

+                                "precursorCollisionEnergy",

+                                "productIsolationWindowTargetMZ",

+                                "productIsolationWindowLowerOffset",

+                                "productIsolationWindowUpperOffset"))

+    checkEquals(ch$chromatogramId[1], "TIC")

+    checkEquals(sum(is.na(ch$precursorIsolationWindowTargetMZ)), 1)

+    checkEquals(sum(is.na(ch$productIsolationWindowTargetMZ)), 1)    

+    checkEquals(length(chrs), nrow(ch))

+    close(x)

+

+    ## Should return only the TIC.

+    f <- proteomics(full.names = TRUE, pattern = "MS3")

+    x <- openMSfile(f)

+    ch <- chromatogramHeader(x)

+    checkEquals(nrow(ch), 1)

+    checkEquals(ch$chromatogramId, "TIC")

+    close(x)

+}

@@ -27,10 +27,12 @@

 \alias{get3Dmap,mzRpwiz-method}

 \alias{chromatogram,mzRpwiz-method}

+\alias{chromatogramHeader,mzRpwiz-method}

 \alias{chromatograms,mzRpwiz-method}

 \alias{tic,mzRpwiz-method}

 \alias{nChrom}

 \alias{chromatogram}

+\alias{chromatogramHeader}

 \alias{chromatograms}

 \alias{tic}

@@ -59,6 +61,8 @@

  chromatograms(object, ...) ## same as chromatogram

+ \S4method{chromatogramHeader}{mzRpwiz}(object, chrom)

+

  tic(object, ...)

  nChrom(object)

@@ -78,6 +82,12 @@

     returned.}

   \item{resMz}{a \code{numeric} defining the m/z resolution.}

+

+  \item{chrom}{

+    For \code{chromatogramHeader}: \code{numeric} specifying the index

+    of the chromatograms to be extracted from the file. If omitted, data

+    for all chromatograms is returned. 

+  }

   \item{...}{Other arguments. A \code{scan} parameter can be passed to

     \code{peaks}.}  }

@@ -128,6 +138,23 @@

   The \code{nChrom} function returns the number of chromatograms,

   including the total ion chromatogram.

+  The \code{chromatogramHeader} returns (similar to the \code{header}

+  function for spectra) a \code{data.frame} with metadata information

+  for the individual chromatograms. The \code{data.frame} has the

+  columns: \code{"chromatogramId"} (the ID of the chromatogram as

+  specified in the file), \code{"chromatogramIndex"} (the index of the

+  chromatogram within the file), \code{"polarity"} (the polarity for the

+  chromatogram, 0 for negative, +1 for positive and -1 for not set),

+  \code{"precursorIsolationWindowTargetMZ"} (the isolation window m/z of

+  the precursor), \code{"precursorIsolationWindowLowerOffset"},

+  \code{"precursorIsolationWindowUpperOffset"} (lower and upper offset

+  for the isolation window m/z), \code{"precursorCollisionEnergy"}

+  (collision energy),

+  \code{"productIsolationWindowTargetMZ"},

+  \code{"productIsolationWindowLowerOffset"} and

+  \code{"productIsolationWindowUpperOffset"} (definition of the m/z

+  isolation window for the product).

+  

   Note that access to chromatograms is only supported in the \code{pwiz}

   backend.

@@ -202,4 +229,8 @@

  head(tic(x))

  head(chromatogram(x, 1L)) ## same as tic(x)

  str(chromatogram(x, 10:12))  

+

+ ## get the header information for the chromatograms

+ ch <- chromatogramHeader(x)

+ head(ch)

 }

@@ -774,6 +774,111 @@ Rcpp::DataFrame RcppPwiz::getChromatogramsInfo( int whichChrom )

     return Rcpp::DataFrame::create( );

 }

+// get the header info for chromatograms.

+Rcpp::DataFrame RcppPwiz::getChromatogramHeaderInfo (Rcpp::IntegerVector whichChrom)

+{

+  if (msd != NULL) {

+    CVID nativeIdFormat_ = id::getDefaultNativeIDFormat(*msd); // Ask CHRIS if I'm correctly dereferencing this...

+    ChromatogramListPtr clp = msd->run.chromatogramListPtr;

+    if (clp.get() == 0) {

+      Rcpp::Rcerr << "The direct support for chromatogram info is only available in mzML format." << std::endl;

+      return Rcpp::DataFrame::create();

+    } else if (clp->size() == 0) {

+      Rcpp::Rcerr << "No available chromatogram info." << std::endl;

+      return Rcpp::DataFrame::create();

+    }

+

+    int N = clp->size();  

+    int N_chrom = whichChrom.size();

+

+    Rcpp::StringVector chromatogramId(N_chrom); // the ID from the chrom

+    Rcpp::IntegerVector chromatogramIndex(N_chrom);  // In contrast to the acquisitionNum we report here the index (1 based) of the chromatogram within the file.

+    Rcpp::IntegerVector polarity(N_chrom);

+    // MS:1000827: isolation window target m/z

+    // MS:1000828: isolation window lower offset

+    // MS:1000829: isolation window upper offset

+    Rcpp::NumericVector precursorIsolationWindowTargetMZ(N_chrom);

+    Rcpp::NumericVector precursorIsolationWindowLowerOffset(N_chrom);

+    Rcpp::NumericVector precursorIsolationWindowUpperOffset(N_chrom);

+    Rcpp::NumericVector precursorCollisionEnergy(N_chrom);

+    Rcpp::NumericVector productIsolationWindowTargetMZ(N_chrom);

+    Rcpp::NumericVector productIsolationWindowLowerOffset(N_chrom);

+    Rcpp::NumericVector productIsolationWindowUpperOffset(N_chrom);

+        

+    for (int i = 0; i < N_chrom; i++) {

+      int current_chrom = whichChrom[i];

+      if (current_chrom < 0 || current_chrom > N) {

+	Rcpp::Rcerr << "Provided index out of bounds" << std::endl;

+	return Rcpp::DataFrame::create();

+      }

+      ChromatogramPtr ch = clp->chromatogram(current_chrom - 1, false);

+      chromatogramId[i] = ch->id;

+      chromatogramIndex[i] = current_chrom;

+      CVParam param = ch->cvParamChild(MS_scan_polarity);

+      polarity[i] = (param.cvid==MS_negative_scan ? 0 : (param.cvid==MS_positive_scan ? +1 : -1 ) );

+      if (!ch->precursor.empty()) {

+	precursorIsolationWindowTargetMZ[i] = ch->precursor.isolationWindow.cvParam(MS_isolation_window_target_m_z).value.empty() ? NA_REAL : ch->precursor.isolationWindow.cvParam(MS_isolation_window_target_m_z).valueAs<double>();

+	precursorIsolationWindowLowerOffset[i] = ch->precursor.isolationWindow.cvParam(MS_isolation_window_lower_offset).value.empty() ? 0 : ch->precursor.isolationWindow.cvParam(MS_isolation_window_lower_offset).valueAs<double>();

+	precursorIsolationWindowUpperOffset[i] = ch->precursor.isolationWindow.cvParam(MS_isolation_window_upper_offset).value.empty() ? 0 : ch->precursor.isolationWindow.cvParam(MS_isolation_window_upper_offset).valueAs<double>();

+	precursorCollisionEnergy[i] = ch->precursor.activation.cvParam(MS_collision_energy).value.empty() ? NA_REAL : ch->precursor.activation.cvParam(MS_collision_energy).valueAs<double>(); 

+      } else {

+	precursorIsolationWindowTargetMZ[i] = NA_REAL;

+	precursorIsolationWindowLowerOffset[i] = NA_REAL;

+	precursorIsolationWindowUpperOffset[i] = NA_REAL;

+	precursorCollisionEnergy[i] = NA_REAL;

+      }

+      if (!ch->product.empty()) {

+	productIsolationWindowTargetMZ[i] = ch->product.isolationWindow.cvParam(MS_isolation_window_target_m_z).value.empty() ? NA_REAL : ch->product.isolationWindow.cvParam(MS_isolation_window_target_m_z).valueAs<double>();

+	productIsolationWindowLowerOffset[i] = ch->product.isolationWindow.cvParam(MS_isolation_window_lower_offset).value.empty() ? 0 : ch->product.isolationWindow.cvParam(MS_isolation_window_lower_offset).valueAs<double>();

+	productIsolationWindowUpperOffset[i] = ch->product.isolationWindow.cvParam(MS_isolation_window_upper_offset).value.empty() ? 0 : ch->product.isolationWindow.cvParam(MS_isolation_window_upper_offset).valueAs<double>();

+      } else {

+	productIsolationWindowTargetMZ[i] = NA_REAL;

+	productIsolationWindowLowerOffset[i] = NA_REAL;

+	productIsolationWindowUpperOffset[i] = NA_REAL;

+      }

+    }

+    Rcpp::List chromHeader(10);

+    std::vector<std::string> names;

+    int i = 0;

+    names.push_back("chromatogramId");

+    chromHeader[i++] = Rcpp::wrap(chromatogramId);

+    names.push_back("chromatogramIndex");

+    chromHeader[i++] = Rcpp::wrap(chromatogramIndex);

+    names.push_back("polarity");

+    chromHeader[i++] = Rcpp::wrap(polarity);

+    names.push_back("precursorIsolationWindowTargetMZ");

+    chromHeader[i++] = Rcpp::wrap(precursorIsolationWindowTargetMZ);

+    names.push_back("precursorIsolationWindowLowerOffset");

+    chromHeader[i++] = Rcpp::wrap(precursorIsolationWindowLowerOffset);

+    names.push_back("precursorIsolationWindowUpperOffset");

+    chromHeader[i++] = Rcpp::wrap(precursorIsolationWindowUpperOffset);

+    names.push_back("precursorCollisionEnergy");

+    chromHeader[i++] = Rcpp::wrap(precursorCollisionEnergy);

+    names.push_back("productIsolationWindowTargetMZ");

+    chromHeader[i++] = Rcpp::wrap(productIsolationWindowTargetMZ);

+    names.push_back("productIsolationWindowLowerOffset");

+    chromHeader[i++] = Rcpp::wrap(productIsolationWindowLowerOffset);

+    names.push_back("productIsolationWindowUpperOffset");

+    chromHeader[i++] = Rcpp::wrap(productIsolationWindowUpperOffset);

+    

+    chromHeader.attr("names") = names;

+    return chromHeader;

+  }

+  Rprintf("Warning: pwiz not yet initialized.\n ");

+  return Rcpp::DataFrame::create( );

+}

+

+Rcpp::DataFrame RcppPwiz::getAllChromatogramHeaderInfo ( ) {

+  if (msd != NULL) {

+    ChromatogramListPtr clp = msd->run.chromatogramListPtr;

+    int N = clp->size();

+    

+    return getChromatogramHeaderInfo(Rcpp::seq(1, N));

+  }

+  Rprintf("Warning: pwiz not yet initialized.\n ");

+  return Rcpp::DataFrame::create( );

+}

+

 Rcpp::NumericMatrix RcppPwiz::get3DMap ( std::vector<int> scanNumbers, double whichMzLow, double whichMzHigh, double resMz )

 {

     if (msd != NULL)

@@ -90,10 +90,14 @@ public:

      **/

     Rcpp::DataFrame getScanHeaderInfo(Rcpp::IntegerVector whichScan);

+    Rcpp::DataFrame getChromatogramHeaderInfo(Rcpp::IntegerVector whichScan);

+

     Rcpp::DataFrame getChromatogramsInfo(int whichChrom);

     Rcpp::DataFrame getAllScanHeaderInfo();

+    Rcpp::DataFrame getAllChromatogramHeaderInfo();

+

     Rcpp::List getPeakList(int whichScan);

     Rcpp::NumericMatrix get3DMap(std::vector<int> scanNumbers, double whichMzLow, double whichMzHigh, double resMz);

@@ -25,5 +25,7 @@ RCPP_MODULE(Pwiz)

     .method( "get3DMap", &RcppPwiz::get3DMap, "Reads all scans and returns them as a matrix." )

     .method( "getLastScan", &RcppPwiz::getLastScan, "Returns the last scan (not necessarily the number of scans because of missing scans)." )

     .method( "getLastChrom", &RcppPwiz::getLastChrom, "Returns the index of the last chromatogram." )

+    .method("getChromatogramHeaderInfo", &RcppPwiz::getChromatogramHeaderInfo, "Returns a data.frame with the chromatogram header information")

+    .method("getAllChromatogramHeaderInfo", &RcppPwiz::getAllChromatogramHeaderInfo, "Returns a data.frame with the header for all chromatograms")

     ;

 }