@@ -28,3 +28,4 @@ URL: https://github.com/sneumann/mzR/

 BugReports: https://github.com/sneumann/mzR/issues/

 biocViews: Infrastructure, DataImport, Proteomics, Metabolomics,

         MassSpectrometry

+RoxygenNote: 6.0.1

@@ -11,7 +11,9 @@ import(Rcpp)

 export(openMSfile,

        openIDfile,

        pwiz.version,

-       nChrom)

+       nChrom,

+       writeMSData,

+       copyWriteMSData)

 exportMethods(close,

               isInitialized,

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

 CHANGES IN VERSION 2.11.4

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

- o nothing yet

+ o writeMSData and copyWriteMSData functions enabling to export MS data to

+   mzML or mzXML files.

 CHANGES IN VERSION 2.11.3

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

@@ -73,7 +73,7 @@ openIDfile <- function(filename, verbose = FALSE) {

 #'     for writing. Currently only \code{"pwiz"} backend is supported.

 #'

 #' @param outformat \code{character(1)} the format of the output file. One of

-#'     \code{"mzml"}, \code{"mzxml"} and \code{"mgf"}.

+#'     \code{"mzml"} or \code{"mzxml"}..

 #'

 #' @param rtime_seconds \code{logical(1)} whether the retention time is provided

 #'     in seconds or minutes (defaults to \code{TRUE}).

@@ -89,13 +89,40 @@ openIDfile <- function(filename, verbose = FALSE) {

 #'     performed with the software.

 #' 

 #' @author Johannes Rainer

+#'

+#' @seealso \code{\link{copyWriteMSData}} for a function to copy general

+#'     information from a MS data file and writing eventually modified MS data

+#'     from that originating file.

+#' 

+#' @examples

+#'

+#' ## Open a MS file and read the spectrum and header information

+#' library(msdata)

+#' fl <- system.file("threonine", "threonine_i2_e35_pH_tree.mzXML",

+#'     package = "msdata")

+#' ms_fl <- openMSfile(fl, backend = "pwiz")

+#'

+#' ## Get the spectra

+#' pks <- spectra(ms_fl)

+#' ## Get the header

+#' hdr <- header(ms_fl)

+#'

+#' ## Modify the spectrum data adding 100 to each intensity.

+#' pks <- lapply(pks, function(z) {

+#'     z[, 2] <- z[, 2] + 100

+#'     z

+#' })

+#'

+#' ## Write the data to a mzML file.

+#' out_file <- tempfile()

+#' writeMSData(filename = out_file, header = hdr, data = pks)

 writeMSData <- function(filename, header, data, backend = "pwiz",

                         outformat = c("mzml"),

                         rtime_seconds = TRUE,

                         software_processing) {

     backend <- match.arg(backend)

     ## supp_formats <- c("mzml", "mgf", "mzxml")

-    supp_formats <- "mzml"

+    supp_formats <- c("mzml", "mzxml")

     outformat <- match.arg(tolower(outformat), supp_formats)

     if (missing(filename))

         stop("'filename' is a required parameter")

@@ -118,6 +145,8 @@ writeMSData <- function(filename, header, data, backend = "pwiz",

         mzR <- c(mzR, "MS:1000545")

     software_processing <- c(software_processing, list(mzR))

     if (backend == "pwiz") {

+        if (outformat == "mzxml" & any(header$injectionTime > 0))

+            warning("mzXML export does not support writing ion injection time")

         pwizModule <- new(Pwiz)

         pwizModule$writeSpectrumList(filename, outformat,

                                      header, data, rtime_seconds,

@@ -136,35 +165,64 @@ writeMSData <- function(filename, header, data, backend = "pwiz",

 #'     (eventually) manipulated spectra and header data with arguments

 #'     \code{header} and \code{data}.

 #'

+#' @note \code{copyWriteMSData} supports at present copying data from

+#'     \code{mzXML} and \code{mzML} and exporting to \code{mzML}. Export to

+#'     \code{mzXML} can fail for some input files.

+#'

 #' @note This function does not allow to write new MS files with new content.

 #'     Use the \code{\link{writeMSData}} function for that.

 #'

 #' @inheritParams writeMSData

 #' 

-#' @param originalFile \code{character(1)} with the name of the original file

+#' @param original_file \code{character(1)} with the name of the original file

 #'     from which the spectrum data was first read.

 #'

 #' @seealso \code{\link{writeMSData}} for a function to save MS data to a new

 #'     mzML or mzXML file.

 #' 

 #' @author Johannes Rainer

-copyWriteMSData <- function(filename, originalFile, header, data,

+#'

+#' @examples

+#' 

+#' ## Open a MS file and read the spectrum and header information

+#' library(msdata)

+#' fl <- system.file("threonine", "threonine_i2_e35_pH_tree.mzXML",

+#'     package = "msdata")

+#' ms_fl <- openMSfile(fl, backend = "pwiz")

+#'

+#' ## Get the spectra

+#' pks <- spectra(ms_fl)

+#' ## Get the header

+#' hdr <- header(ms_fl)

+#'

+#' ## Modify the spectrum data adding 100 to each intensity.

+#' pks <- lapply(pks, function(z) {

+#'     z[, 2] <- z[, 2] + 100

+#'     z

+#' })

+#'

+#' ## Copy metadata and additional information from the originating file

+#' ## and save it, along with the modified data, to a new mzML file.

+#' out_file <- tempfile()

+#' copyWriteMSData(filename = out_file, original_file = fl,

+#'     header = hdr, data = pks)

+copyWriteMSData <- function(filename, original_file, header, data,

                             backend = "pwiz",

                             outformat = "mzml",

                             rtime_seconds = TRUE,

                             software_processing) {

     backend <- match.arg(backend)

     ## supp_formats <- c("mzml", "mgf", "mzxml")

-    supp_formats <- "mzml"

+    supp_formats <- c("mzml", "mzxml")

     outformat <- match.arg(tolower(outformat), supp_formats)

     if (missing(filename))

         stop("'filename' is a required parameter")

-    if (missing(originalFile))

-        stop("'originalFile' is a required parameter")

+    if (missing(original_file))

+        stop("'original_file' is a required parameter")

     if (missing(header) | missing(data))

         stop("'header' and 'data' are required")

-    if (!file.exists(originalFile))

-        stop("Original file ", originalFile, " not found")

+    if (!file.exists(original_file))

+        stop("Original file ", original_file, " not found")

     ## Other checks:

     header <- .validateHeader(header)

     if (is(header, "character"))

@@ -182,8 +240,12 @@ copyWriteMSData <- function(filename, originalFile, header, data,

         mzR <- c(mzR, "MS:1000545")

     software_processing <- c(software_processing, list(mzR))

     if (backend == "pwiz") {

+        if (outformat == "mzxml" & any(header$injectionTime > 0)) {

+            warning("mzXML export does not support writing ion injection time")

+            header$injectionTime = 0

+        }

         pwizModule <- new(Pwiz)

-        pwizModule$copyWriteMSfile(filename, outformat, originalFile,

+        pwizModule$copyWriteMSfile(filename, outformat, original_file,

                                    header, data, rtime_seconds,

                                    software_processing)

     }

@@ -1,4 +1,4 @@

-BUILT_RCPP_VERSION = package_version("0.12.10")

+BUILT_RCPP_VERSION = package_version("0.12.11")

 .onLoad <-

     function(libname, pkgname) {

@@ -5,40 +5,48 @@ dontrun_copyWriteMSData <- function() {

     library(mzR)

     library(RUnit)

     test_folder = "/Users/jo/Desktop/"

+

+    ## INPUT: mzXML

     orig_file <- system.file("threonine", "threonine_i2_e35_pH_tree.mzXML",

                         package = "msdata")

     mzxml <- openMSfile(orig_file, backend = "pwiz")

     pks <- peaks(mzxml)

     hdr <- header(mzxml)

+    ii <- mzR::instrumentInfo(mzxml)

     mzR::close(mzxml)

+    ## OUTPUT: mzML

     fnew <- paste0(test_folder, "test_copyWrite.mzML")

-    mzR:::copyWriteMSData(filename = fnew, originalFile = orig_file,

+    mzR:::copyWriteMSData(filename = fnew, original_file = orig_file,

                           header = hdr, data = pks, backend = "pwiz")

     ## Check content is same

     mzml_new <- openMSfile(fnew, backend = "pwiz")

     pks_new <- peaks(mzml_new)

     hdr_new <- header(mzml_new)

+    ii_new <- mzR::instrumentInfo(mzml_new)

     mzR::close(mzml_new)

     checkEquals(pks_new, pks)

-    checkEquals(hdr_new, hdr)  ## polarity is OK here

-

-    ## Save as mzXML

-    ## fnew <- paste0(test_folder, "test_copyWrite.mzXML")

-    ## mzR:::copyWriteMSData(filename = fnew, originalFile = orig_file,

-    ##                       header = hdr, data = pks, backend = "pwiz",

-    ##                       outformat = "mzxml")

-    ## ## Check content is same

-    ## mzml_new <- openMSfile(fnew, backend = "pwiz")

-    ## pks_new <- peaks(mzml_new)

-    ## hdr_new <- header(mzml_new)

-    ## mzR::close(mzml_new)

-    ## checkEquals(pks_new, pks)

-    ## checkEquals(hdr_new, hdr)  ## polarity is OK here

+    checkEquals(hdr_new, hdr)

+    checkEquals(ii, ii_new)

+    

+    ## OUTPUT: mzXML

+    fnew <- paste0(test_folder, "test_copyWrite.mzXML")

+    mzR:::copyWriteMSData(filename = fnew, original_file = orig_file,

+                          header = hdr, data = pks, backend = "pwiz",

+                          outformat = "mzxml")

+    ## Check content is same

+    mzml_new <- openMSfile(fnew, backend = "pwiz")

+    pks_new <- peaks(mzml_new)

+    hdr_new <- header(mzml_new)

+    ii_new <- mzR::instrumentInfo(mzml_new)

+    mzR::close(mzml_new)

+    checkEquals(pks_new, pks)

+    checkEquals(hdr_new, hdr)

+    checkEquals(ii, ii_new)

     ## Save as mgf

     ## fnew <- paste0(test_folder, "test_copyWrite.mgf")

-    ## mzR:::copyWriteMSData(filename = fnew, originalFile = orig_file,

+    ## mzR:::copyWriteMSData(filename = fnew, original_file = orig_file,

     ##                       header = hdr, data = pks, backend = "pwiz",

     ##                       outformat = "mgf")

     ## ## Check content is same

@@ -55,13 +63,12 @@ dontrun_copyWriteMSData <- function() {

     fnew <- paste0(test_folder, "test_copyWrite.mzML")

     ## index is not OK after subsetting

     checkException(mzR:::copyWriteMSData(filename = fnew,

-                                         originalFile = orig_file,

+                                         original_file = orig_file,

                                          header = hdr_sub, data = pks_sub,

                                          backend = "pwiz"))

     hdr_sub$seqNum <- seq_len(nrow(hdr_sub))

-    mzR:::copyWriteMSData(filename = fnew, originalFile = orig_file,

+    mzR:::copyWriteMSData(filename = fnew, original_file = orig_file,

                           header = hdr_sub, data = pks_sub, backend = "pwiz")

-

     ## Check content is same

     mzml_new <- openMSfile(fnew, backend = "pwiz")

     pks_new <- peaks(mzml_new)

@@ -78,43 +85,46 @@ dontrun_copyWriteMSData <- function() {

     ## wrong spectra.

     ## wrong data processing.

     checkException(mzR:::copyWriteMSData(filename = fnew,

-                                         originalFile = orig_file,

+                                         original_file = orig_file,

                                          header = pks, data = hdr,

                                          backend = "pwiz"))

     checkException(mzR:::copyWriteMSData(filename = fnew,

-                                         originalFile = orig_file,

+                                         original_file = orig_file,

                                          header = hdr, data = hdr,

                                          backend = "pwiz"))

     checkException(mzR:::copyWriteMSData(filename = fnew,

-                                         originalFile = orig_file,

+                                         original_file = orig_file,

                                          header = hdr, data = pks,

                                          backend = "Ramp"))

     checkException(mzR:::copyWriteMSData(filename = fnew,

-                                         originalFile = "somefile",

+                                         original_file = "somefile",

                                          header = hdr, data = pks,

                                          backend = "pwiz"))

     checkException(mzR:::copyWriteMSData(filename = fnew,

-                                         originalFile = orig_file,

+                                         original_file = orig_file,

                                          header = hdr, data = pks,

                                          backend = "pwiz",

                                          software_processing = c("other")))

-    ## mzML input file.

+    ## INPUT: mzML

     orig_file <- system.file("proteomics",

                              "TMT_Erwinia_1uLSike_Top10HCD_isol2_45stepped_60min_01.mzML.gz",

                              package = "msdata")

-    mzxml <- openMSfile(orig_file, backend = "pwiz")

-    pks <- peaks(mzxml)

-    hdr <- header(mzxml)

-    mzR::close(mzxml)

+    fl <- openMSfile(orig_file, backend = "pwiz")

+    pks <- peaks(fl)

+    hdr <- header(fl)

+    ii <- mzR::instrumentInfo(fl)

+    mzR::close(fl)

+    ## OUTPUT: mzML

     fnew <- paste0(test_folder, "test_copyWrite.mzML")

-    mzR:::copyWriteMSData(filename = fnew, originalFile = orig_file,

+    mzR:::copyWriteMSData(filename = fnew, original_file = orig_file,

                           header = hdr, data = pks, backend = "pwiz")

     ## Check content is same

     mzml_new <- openMSfile(fnew, backend = "pwiz")

     pks_new <- peaks(mzml_new)

     hdr_new <- header(mzml_new)

+    ii_new <- mzR::instrumentInfo(mzml_new)

     mzR::close(mzml_new)

     checkEquals(pks_new, pks)

     ## acquisitionNum and precursorScanNum will be different, replace with

@@ -124,6 +134,66 @@ dontrun_copyWriteMSData <- function() {

     hdr_new$acquisitionNum <- as.integer(factor(hdr_new$acquisitionNum))

     hdr_new$precursorScanNum <- as.integer(factor(hdr_new$precursorScanNum))

     checkEquals(hdr_new, hdr)  ## polarity is OK here

+    checkEquals(ii, ii_new)

+    

+    ## OUTPUT: mzXML

+    fnew <- paste0(test_folder, "test_copyWrite.mzXML")

+    mzR:::copyWriteMSData(filename = fnew, original_file = orig_file,

+                          header = hdr, data = pks, backend = "pwiz",

+                          outformat = "mzxml")

+    ## Check content is same

+    mzml_new <- openMSfile(fnew, backend = "pwiz")

+    pks_new <- peaks(mzml_new)

+    hdr_new <- header(mzml_new)

+    ii_new <- mzR::instrumentInfo(mzml_new)

+    mzR::close(mzml_new)

+    checkEquals(pks_new, pks)

+    ## acquisitionNum and precursorScanNum will be different, replace with

+    ## factors - order and all has to be the same though.

+    hdr$acquisitionNum <- as.integer(factor(hdr$acquisitionNum))

+    hdr$precursorScanNum <- as.integer(factor(hdr$precursorScanNum))

+    hdr_new$acquisitionNum <- as.integer(factor(hdr_new$acquisitionNum))

+    hdr_new$precursorScanNum <- as.integer(factor(hdr_new$precursorScanNum))

+    rt_col <- which(colnames(hdr) == "retentionTime")

+    checkEquals(hdr[, rt_col], hdr_new[, rt_col], tolerance = 0.01)

+    hdr$injectionTime <- 0  ## injectionTime export not supported.

+    checkEquals(hdr[ , -rt_col], hdr_new[ , -rt_col])

+    ## checkEquals(ii, ii_new)

+

+    ## Other mzML:

+    test_file <- system.file("microtofq", "MM14.mzML", package = "msdata")

+    in_file <- openMSfile(test_file, backend = "pwiz")

+    hdr <- header(in_file)

+    pks <- peaks(in_file)

+    ii <- mzR::instrumentInfo(in_file)

+    mzR::close(in_file)

+    

+    ## mzML

+    out_file <- paste0(test_folder, "test_copyWrite.mzML")

+    mzR:::copyWriteMSData(filename = out_file, original_file = test_file,

+                          header = hdr, data = pks,

+                          software_processing = c("MSnbase", "2.3.8"))

+    in_file <- openMSfile(out_file, backend = "pwiz")

+    hdr_2 <- header(in_file)

+    pks_2 <- peaks(in_file)

+    ii_2 <- mzR::instrumentInfo(in_file)

+    mzR::close(in_file)

+    checkEquals(hdr, hdr_2)

+    checkEquals(pks, pks_2)

+    checkEquals(ii, ii_2)

+    

+    ## mzXML output:

+    out_file <- paste0(test_folder, "test_copyWrite.mzXML")

+    mzR:::copyWriteMSData(filename = out_file, original_file = test_file,

+                          header = hdr, data = pks, outformat = "mzXML",

+                          software_processing = c("MSnbase", "2.3.8"))

+    in_file <- openMSfile(out_file, backend = "pwiz")

+    hdr_2 <- header(in_file)

+    pks_2 <- peaks(in_file)

+    mzR::close(in_file)

+    checkEquals(hdr, hdr_2)

+    checkEquals(pks, pks_2)

+    checkEquals(ii, ii_2)

 }

 dontrun_test_writeMSData <- function() {

@@ -131,6 +201,7 @@ dontrun_test_writeMSData <- function() {

     library(mzR)

     library(RUnit)

     test_folder = "/Users/jo/Desktop/"

+    ## Input: mzXML

     test_file <- system.file("threonine", "threonine_i2_e35_pH_tree.mzXML",

                              package = "msdata")

     in_file <- openMSfile(test_file, backend = "pwiz")

@@ -138,7 +209,7 @@ dontrun_test_writeMSData <- function() {

     pks <- peaks(in_file)

     mzR::close(in_file)

-    ## Test writing the data.

+    ## mzML

     out_file <- paste0(test_folder, "test_write.mzML")

     mzR:::writeMSData(filename = out_file, header = hdr, data = pks)

     in_file <- openMSfile(out_file, backend = "pwiz")

@@ -161,13 +232,113 @@ dontrun_test_writeMSData <- function() {

     checkEquals(pks, pks_2)

     ## mzXML output:

-    ## out_file <- paste0(test_folder, "test_write.mzXML")

+    out_file <- paste0(test_folder, "test_write.mzXML")

+    mzR:::writeMSData(filename = out_file, header = hdr, data = pks,

+                      outformat = "mzXML")

+    in_file <- openMSfile(out_file, backend = "pwiz")

+    hdr_2 <- header(in_file)

+    pks_2 <- peaks(in_file)

+    mzR::close(in_file)

+    checkEquals(hdr, hdr_2)

+    checkEquals(pks, pks_2)

+

+    ## mgf output:

+    ## out_file <- paste0(test_folder, "test_write.mgf")

     ## mzR:::writeMSData(filename = out_file, header = hdr, data = pks,

-    ##                   outformat = "mzXML")

+    ##                   outformat = "mgf")

     ## in_file <- openMSfile(out_file, backend = "pwiz")

     ## hdr_2 <- header(in_file)

     ## pks_2 <- peaks(in_file)

     ## mzR::close(in_file)

     ## checkEquals(hdr, hdr_2)

     ## checkEquals(pks, pks_2)

+

+    ## Input: mzML

+    test_file <- system.file("proteomics",

+                             "TMT_Erwinia_1uLSike_Top10HCD_isol2_45stepped_60min_01.mzML.gz",

+                             package = "msdata")

+    in_file <- openMSfile(test_file, backend = "pwiz")

+    hdr <- header(in_file)

+    pks <- peaks(in_file)

+    mzR::close(in_file)

+    

+    ## mzML

+    out_file <- paste0(test_folder, "test_write.mzML")

+    mzR:::writeMSData(filename = out_file, header = hdr, data = pks)

+    in_file <- openMSfile(out_file, backend = "pwiz")

+    hdr_2 <- header(in_file)

+    pks_2 <- peaks(in_file)

+    mzR::close(in_file)

+    checkEquals(hdr, hdr_2)

+    checkEquals(pks, pks_2)

+

+    ## mzXML output:

+    out_file <- paste0(test_folder, "test_write.mzXML")

+    mzR:::writeMSData(filename = out_file, header = hdr, data = pks,

+                      outformat = "mzXML")

+    in_file <- openMSfile(out_file, backend = "pwiz")

+    hdr_2 <- header(in_file)

+    pks_2 <- peaks(in_file)

+    mzR::close(in_file)

+    rt_col <- which(colnames(hdr) == "retentionTime")

+    checkEquals(hdr[, rt_col], hdr_2[, rt_col], tolerance = 0.01)

+    hdr$injectionTime <- 0  ## injectionTime export not supported.

+    checkEquals(hdr[ , -rt_col], hdr_2[ , -rt_col])

+    checkEquals(pks, pks_2)

+

+    ## Other mzML:

+    test_file <- system.file("microtofq", "MM14.mzML", package = "msdata")

+    in_file <- openMSfile(test_file, backend = "pwiz")

+    hdr <- header(in_file)

+    pks <- peaks(in_file)

+    mzR::close(in_file)

+    

+    ## mzML

+    out_file <- paste0(test_folder, "test_write.mzML")

+    mzR:::writeMSData(filename = out_file, header = hdr, data = pks)

+    in_file <- openMSfile(out_file, backend = "pwiz")

+    hdr_2 <- header(in_file)

+    pks_2 <- peaks(in_file)

+    mzR::close(in_file)

+    checkEquals(hdr, hdr_2)

+    checkEquals(pks, pks_2)

+

+    ## mzXML output:

+    out_file <- paste0(test_folder, "test_write.mzXML")

+    mzR:::writeMSData(filename = out_file, header = hdr, data = pks,

+                      outformat = "mzXML")

+    in_file <- openMSfile(out_file, backend = "pwiz")

+    hdr_2 <- header(in_file)

+    pks_2 <- peaks(in_file)

+    mzR::close(in_file)

+    checkEquals(hdr, hdr_2)

+    checkEquals(pks, pks_2)

+

+    ## mzData:

+    test_file <- system.file("iontrap", "extracted.mzData", package = "msdata")

+    in_file <- openMSfile(test_file, backend = "Ramp")

+    hdr <- header(in_file)

+    pks <- peaks(in_file)

+    mzR::close(in_file)

+

+    ## mzML

+    out_file <- paste0(test_folder, "test_write.mzML")

+    mzR:::writeMSData(filename = out_file, header = hdr, data = pks)

+    in_file <- openMSfile(out_file, backend = "pwiz")

+    hdr_2 <- header(in_file)

+    pks_2 <- peaks(in_file)

+    mzR::close(in_file)

+    checkEquals(hdr, hdr_2)

+    checkEquals(pks, pks_2)

+

+    ## mzXML output:

+    out_file <- paste0(test_folder, "test_write.mzXML")

+    mzR:::writeMSData(filename = out_file, header = hdr, data = pks,

+                      outformat = "mzXML")

+    in_file <- openMSfile(out_file, backend = "pwiz")

+    hdr_2 <- header(in_file)

+    pks_2 <- peaks(in_file)

+    mzR::close(in_file)

+    checkEquals(hdr, hdr_2)

+    checkEquals(pks, pks_2)

 }

@@ -131,6 +131,9 @@

 \seealso{

   \code{\link{instrumentInfo}} for metadata access and the

   \code{"\linkS4class{mzR}"} class.

+

+  \code{\link{writeMSData}} and \code{\link{copyWriteMSData}} for

+  functions to write MS data in \emph{mzML} or \code{mzXML} format.

 }

 \author{

deleted file mode 100644

@@ -1,17 +0,0 @@

-#include <Rcpp.h>

-#include "pwiz/data/msdata/Version.hpp"

-

-using namespace Rcpp;

-

-//' Get Proteowizard Version

-//' 

-//' Description

-//' Return the pwiz::msdata::Version as String

-RcppExport SEXP mzR_pwiz_version() {

-BEGIN_RCPP

-    Rcpp::RObject __result;

-    Rcpp::RNGScope __rngScope;

-    __result = Rcpp::wrap(pwiz::msdata::Version::str());

-    return __result;

-END_RCPP

-}

@@ -366,33 +366,13 @@ void RcppPwiz::copyWriteMSfile(const string& file, const string& format,

   MSData newmsd;

   newmsd.cvs = defaultCVList();

-  // Break the header down into its elements/columns:

-  // Rcpp::IntegerVector seqNum = spctr_header["seqNum"];

-  // Rcpp::IntegerVector acquisitionNum = spctr_header["acquisitionNum"];

   Rcpp::IntegerVector msLevel = spctr_header["msLevel"];

-  // Rcpp::IntegerVector polarity = spctr_header["polarity"];

-  // Rcpp::IntegerVector peaksCount = spctr_header["peaksCount"];

-  // Rcpp::NumericVector totIonCurrent = spctr_header["totIonCurrent"];

-  // Rcpp::NumericVector retentionTime = spctr_header["retentionTime"];

-  // Rcpp::NumericVector basePeakMZ = spctr_header["basePeakMZ"];

-  // Rcpp::NumericVector basePeakIntensity = spctr_header["basePeakIntensity"];

-  // Rcpp::NumericVector collisionEnergy = spctr_header["collisionEnergy"];

-  // Rcpp::NumericVector ionisationEnergy = spctr_header["ionisationEnergy"];

-  // Rcpp::NumericVector lowMZ = spctr_header["lowMZ"];

-  // Rcpp::NumericVector highMZ = spctr_header["highMZ"];

-  // Rcpp::IntegerVector precursorScanNum = spctr_header["precursorScanNum"];

-  // Rcpp::NumericVector precursorMZ = spctr_header["precursorMZ"];

-  // Rcpp::IntegerVector precursorCharge = spctr_header["precursorCharge"];

-  // Rcpp::NumericVector precursorIntensity = spctr_header["precursorIntensity"];

-  // Rcpp::IntegerVector mergedScan = spctr_header["mergedScan"];

-  // // Skipping mergedResultScanNum, mergedResultStartScanNum and mergedResultEndScanNum

-  // Rcpp::NumericVector ionInjectionTime = spctr_header["injectionTime"];

-

   // Copy data from the original file.

   // o fileDescription with: fileContent, sourceFileList

-  //   TODO: if we did filtering on MS or centroiding we might have to adapt the

-  //   fileContent.

-  newmsd.fileDescription = msd->fileDescription;

+  //   NOTE: don't copy the file description for mzXML export - somehow the

+  //   spectra data will then not be written.

+  if (format != "mzxml")

+    newmsd.fileDescription = msd->fileDescription;

   bool is_ms1 = false;

   bool is_msn = false;

   for (int i = 0; i < msLevel.size(); i++) {

@@ -405,15 +385,13 @@ void RcppPwiz::copyWriteMSfile(const string& file, const string& format,

     newmsd.fileDescription.fileContent.set(MS_MS1_spectrum);

   if (is_msn)

     newmsd.fileDescription.fileContent.set(MS_MSn_spectrum);

-  // The serializer adds also the original file here AND the newly written file.

   // o paramGroupList

-  newmsd.paramGroupPtrs = msd->paramGroupPtrs;

+  if (format != "mzxml")

+    newmsd.paramGroupPtrs = msd->paramGroupPtrs;

   // o sampleList

   newmsd.samplePtrs = msd->samplePtrs;

   // o instrumentConfigurationList

-  // vector<InstrumentConfigurationPtr> icp = msd->instrumentConfigurationPtrs;

-  // newmsd.instrumentConfigurationPtrs = icp;

   newmsd.instrumentConfigurationPtrs = msd->instrumentConfigurationPtrs;

   // o softwareList

   newmsd.softwarePtrs = msd->softwarePtrs;

@@ -425,26 +403,28 @@ void RcppPwiz::copyWriteMSfile(const string& file, const string& format,

       addDataProcessing(newmsd, Rcpp::as<Rcpp::StringVector>(software_processing(sp)));

     }

   }

-

+  

   // o run

   // Initialize the run and fill with data from the original file.

   Run &original_run = msd->run;

   newmsd.run.id = original_run.id;

-  newmsd.run.defaultInstrumentConfigurationPtr =

-    original_run.defaultInstrumentConfigurationPtr;

-  newmsd.run.samplePtr = original_run.samplePtr;

-  newmsd.run.startTimeStamp = original_run.startTimeStamp;

-  newmsd.run.defaultSourceFilePtr = original_run.defaultSourceFilePtr;

+  if (format != "mzxml") {

+    newmsd.run.defaultInstrumentConfigurationPtr =

+      original_run.defaultInstrumentConfigurationPtr;

+    newmsd.run.samplePtr = original_run.samplePtr;

+    newmsd.run.startTimeStamp = original_run.startTimeStamp;

+    newmsd.run.defaultSourceFilePtr = original_run.defaultSourceFilePtr;

+  }

   // Now filling with new data

   addSpectrumList(newmsd, spctr_header, spctr_data, rtime_seconds);

-  if(format == "mgf") {

+  if (format == "mgf") {

     std::ofstream* mgfOutFileP = new std::ofstream(file.c_str());

     Serializer_MGF serializerMGF;

     serializerMGF.write(*mgfOutFileP, newmsd);

     mgfOutFileP->flush();

     mgfOutFileP->close();

-  } else if(format == "mzxml") {

+  } else if (format == "mzxml") {

     std::ofstream mzXMLOutFileP(file.c_str());

     Serializer_mzXML::Config config;

     config.binaryDataEncoderConfig.compression = BinaryDataEncoder::Compression_Zlib;

@@ -452,7 +432,7 @@ void RcppPwiz::copyWriteMSfile(const string& file, const string& format,

     serializerMzXML.write(mzXMLOutFileP, newmsd);

     mzXMLOutFileP.flush();

     mzXMLOutFileP.close();

-  } else if(format == "mzml") {

+  } else if (format == "mzml") {

     std::ofstream mzXMLOutFileP(file.c_str());

     Serializer_mzML::Config config;

     config.binaryDataEncoderConfig.compression = BinaryDataEncoder::Compression_Zlib;

@@ -477,28 +457,7 @@ void RcppPwiz::writeSpectrumList(const string& file, const string& format,

   MSData newmsd;

   newmsd.cvs = defaultCVList();

-  // Break the header down into its elements/columns:

-  // Rcpp::IntegerVector seqNum = spctr_header["seqNum"];

-  // Rcpp::IntegerVector acquisitionNum = spctr_header["acquisitionNum"];

   Rcpp::IntegerVector msLevel = spctr_header["msLevel"];

-  // Rcpp::IntegerVector polarity = spctr_header["polarity"];

-  // Rcpp::IntegerVector peaksCount = spctr_header["peaksCount"];

-  // Rcpp::NumericVector totIonCurrent = spctr_header["totIonCurrent"];

-  // Rcpp::NumericVector retentionTime = spctr_header["retentionTime"];

-  // Rcpp::NumericVector basePeakMZ = spctr_header["basePeakMZ"];

-  // Rcpp::NumericVector basePeakIntensity = spctr_header["basePeakIntensity"];

-  // Rcpp::NumericVector collisionEnergy = spctr_header["collisionEnergy"];

-  // Rcpp::NumericVector ionisationEnergy = spctr_header["ionisationEnergy"];

-  // Rcpp::NumericVector lowMZ = spctr_header["lowMZ"];

-  // Rcpp::NumericVector highMZ = spctr_header["highMZ"];

-  // Rcpp::IntegerVector precursorScanNum = spctr_header["precursorScanNum"];

-  // Rcpp::NumericVector precursorMZ = spctr_header["precursorMZ"];

-  // Rcpp::IntegerVector precursorCharge = spctr_header["precursorCharge"];

-  // Rcpp::NumericVector precursorIntensity = spctr_header["precursorIntensity"];

-  // Rcpp::IntegerVector mergedScan = spctr_header["mergedScan"];

-  // // Skipping mergedResultScanNum, mergedResultStartScanNum and mergedResultEndScanNum

-  // Rcpp::NumericVector ionInjectionTime = spctr_header["injectionTime"];

-

   bool is_ms1 = false;

   bool is_msn = false;

   for (int i = 0; i < msLevel.size(); i++) {

@@ -519,18 +478,18 @@ void RcppPwiz::writeSpectrumList(const string& file, const string& format,

     }

   }

-  newmsd.run.id = "Experiment 1";

+  newmsd.run.id = "Experiment_1";

   // Now filling with new data

   addSpectrumList(newmsd, spctr_header, spctr_data, rtime_seconds);

-  if(format == "mgf") {

+  if (format == "mgf") {

     std::ofstream* mgfOutFileP = new std::ofstream(file.c_str());

     Serializer_MGF serializerMGF;

     serializerMGF.write(*mgfOutFileP, newmsd);

     mgfOutFileP->flush();

     mgfOutFileP->close();

-  } else if(format == "mzxml") {

+  } else if (format == "mzxml") {

     std::ofstream mzXMLOutFileP(file.c_str());

     Serializer_mzXML::Config config;

     config.binaryDataEncoderConfig.compression = BinaryDataEncoder::Compression_Zlib;

@@ -538,7 +497,7 @@ void RcppPwiz::writeSpectrumList(const string& file, const string& format,

     serializerMzXML.write(mzXMLOutFileP, newmsd);

     mzXMLOutFileP.flush();

     mzXMLOutFileP.close();

-  } else if(format == "mzml") {

+  } else if (format == "mzml") {

     std::ofstream mzXMLOutFileP(file.c_str());

     Serializer_mzML::Config config;

     config.binaryDataEncoderConfig.compression = BinaryDataEncoder::Compression_Zlib;