... | ... |
@@ -83,38 +83,53 @@ test_getScanHeaderInfo <- function() { |
83 | 83 |
ramp <- openMSfile(file, backend = "Ramp") |
84 | 84 |
## Read single scan header. |
85 | 85 |
scan_3 <- header(mzml, scans = 3) |
86 |
+ scan_3_ramp <- header(ramp, scans = 3) |
|
86 | 87 |
cn <- names(scan_3) |
87 | 88 |
cn <- cn[!(cn %in% c("spectrumId", "scanWindowLowerLimit", |
88 |
- "scanWindowUpperLimit"))] |
|
89 |
- scan_3_ramp <- header(ramp, scans = 3) |
|
89 |
+ "scanWindowUpperLimit", "centroided"))] |
|
90 |
+ scan_3 <- scan_3[cn] |
|
91 |
+ scan_3_ramp <- scan_3_ramp[cn] |
|
92 |
+ ## Special case for columns that have an NA reported: they might have a |
|
93 |
+ ## 0 or NA in Ramp. |
|
94 |
+ nas <- is.na(scan_3) |
|
90 | 95 |
## Ramp does not read polarity |
91 | 96 |
scan_3$polarity <- 0 |
92 |
- scan_3$centroided <- NA |
|
93 |
- checkEquals(scan_3[cn], scan_3_ramp[cn]) |
|
94 |
- |
|
97 |
+ checkEquals(scan_3[!nas], scan_3_ramp[!nas]) |
|
98 |
+ ## All others have to be 0 or NA |
|
99 |
+ checkEquals(all(scan_3_ramp[nas] == 0 | is.na(scan_3_ramp[nas])), TRUE) |
|
100 |
+ |
|
95 | 101 |
## Read all scan header |
96 | 102 |
all_scans <- header(mzml) |
97 | 103 |
all_scans_ramp <- header(ramp) |
104 |
+ all_scans <- all_scans[, cn] |
|
105 |
+ all_scans_ramp <- all_scans_ramp[, cn] |
|
98 | 106 |
all_scans$polarity <- 0 |
99 |
- all_scans$centroided <- NA |
|
100 |
- checkEquals(all_scans[, cn], all_scans_ramp[, cn]) |
|
101 |
- |
|
107 |
+ nas <- vapply(all_scans, function(z) all(is.na(z)), logical(1)) |
|
108 |
+ checkEquals(all_scans[, !nas], all_scans_ramp[, !nas]) |
|
109 |
+ ## All others have to be 0 or NA |
|
110 |
+ checkEquals(all(all_scans_ramp[nas] == 0 | is.na(all_scans_ramp[nas])), TRUE) |
|
111 |
+ |
|
102 | 112 |
## passing the index of all scan headers should return the same |
103 |
- all_scans_2 <- header(mzml, scans = 1:nrow(all_scans)) |
|
104 |
- all_scans_ramp_2 <- header(ramp, scans = 1:nrow(all_scans)) |
|
105 |
- all_scans_2$polarity <- 0 |
|
106 |
- all_scans_2$centroided <- NA |
|
107 |
- checkEquals(all_scans, all_scans_2) |
|
108 |
- checkEquals(as.list(all_scans[3, ]), scan_3) |
|
109 |
- checkEquals(all_scans_2[, cn], all_scans_ramp_2[, cn]) |
|
110 |
- |
|
113 |
+ all_scans <- header(mzml, scans = 1:nrow(all_scans)) |
|
114 |
+ all_scans_ramp <- header(ramp, scans = 1:nrow(all_scans)) |
|
115 |
+ all_scans <- all_scans[, cn] |
|
116 |
+ all_scans_ramp <- all_scans_ramp[, cn] |
|
117 |
+ all_scans$polarity <- 0 |
|
118 |
+ nas <- vapply(all_scans, function(z) all(is.na(z)), logical(1)) |
|
119 |
+ checkEquals(all_scans[, !nas], all_scans_ramp[, !nas]) |
|
120 |
+ ## All others have to be 0 or NA |
|
121 |
+ checkEquals(all(all_scans_ramp[, nas] == 0 | is.na(all_scans_ramp[, nas])), TRUE) |
|
122 |
+ |
|
111 | 123 |
## Some selected scans |
112 |
- scan_3 <- header(mzml, scans = c(3, 1, 14)) |
|
113 |
- scan_3_ramp <- header(ramp, scans = c(3, 1, 14)) |
|
114 |
- ## Ramp does not read polarity |
|
115 |
- scan_3$polarity <- 0 |
|
116 |
- scan_3$centroided <- NA |
|
117 |
- checkEquals(scan_3[, cn], scan_3_ramp[, cn]) |
|
124 |
+ all_scans <- header(mzml, scans = c(3, 1, 14)) |
|
125 |
+ all_scans_ramp <- header(ramp, scans = c(3, 1, 14)) |
|
126 |
+ all_scans <- all_scans[, cn] |
|
127 |
+ all_scans_ramp <- all_scans_ramp[, cn] |
|
128 |
+ all_scans$polarity <- 0 |
|
129 |
+ nas <- vapply(all_scans, function(z) all(is.na(z)), logical(1)) |
|
130 |
+ checkEquals(all_scans[, !nas], all_scans_ramp[, !nas]) |
|
131 |
+ ## All others have to be 0 or NA |
|
132 |
+ checkEquals(all(all_scans_ramp[, nas] == 0 | is.na(all_scans_ramp[, nas])), TRUE) |
|
118 | 133 |
|
119 | 134 |
close(mzml) |
120 | 135 |
close(ramp) |
... | ... |
@@ -126,33 +141,65 @@ test_getScanHeaderInfo <- function() { |
126 | 141 |
ramp <- openMSfile(file, backend = "Ramp") |
127 | 142 |
## Read single scan header. |
128 | 143 |
scan_3 <- header(mzml, scans = 3) |
129 |
- scan_3$centroided <- NA |
|
130 | 144 |
scan_3_ramp <- header(ramp, scans = 3) |
131 |
- checkEquals(scan_3[cn], scan_3_ramp[cn]) |
|
145 |
+ scan_3 <- scan_3[cn] |
|
146 |
+ scan_3_ramp <- scan_3_ramp[cn] |
|
147 |
+ nas <- vapply(scan_3, function(z) all(is.na(z)), logical(1)) |
|
148 |
+ checkEquals(scan_3[!nas], scan_3_ramp[!nas]) |
|
149 |
+ checkEquals(all(scan_3_ramp[nas] == 0 | is.na(scan_3_ramp[nas])), TRUE) |
|
132 | 150 |
|
133 | 151 |
## Read all scan header |
134 | 152 |
all_scans <- header(mzml) |
135 |
- all_scans$centroided <- NA |
|
136 | 153 |
all_scans_ramp <- header(ramp) |
154 |
+ all_scans <- all_scans[, cn] |
|
155 |
+ all_scans_ramp <- all_scans_ramp[, cn] |
|
156 |
+ |
|
137 | 157 |
## Ramp unable to read precursorScanNum from an mzXML file. |
138 | 158 |
all_scans$precursorScanNum <- 0 |
139 |
- checkEquals(all_scans[, cn], all_scans_ramp[, cn]) |
|
159 |
+ ## Replace all NA in all_scans with 0 |
|
160 |
+ all_scans <- data.frame(lapply(all_scans, function(z) { |
|
161 |
+ z[is.na(z)] <- 0 |
|
162 |
+ z |
|
163 |
+ })) |
|
164 |
+ all_scans_ramp <- data.frame(lapply(all_scans_ramp, function(z) { |
|
165 |
+ z[is.na(z)] <- 0 |
|
166 |
+ z |
|
167 |
+ })) |
|
168 |
+ checkEquals(all_scans, all_scans_ramp) |
|
140 | 169 |
|
141 | 170 |
## passing the index of all scan headers should return the same |
142 |
- all_scans_2 <- header(mzml, scans = 1:nrow(all_scans)) |
|
143 |
- all_scans_2$centroided <- NA |
|
144 |
- all_scans_ramp_2 <- header(ramp, scans = 1:nrow(all_scans)) |
|
145 |
- all_scans_2$precursorScanNum <- 0 |
|
146 |
- checkEquals(all_scans, all_scans_2) |
|
147 |
- checkEquals(as.list(all_scans[3, cn]), scan_3[cn]) |
|
148 |
- checkEquals(all_scans_2[, cn], all_scans_ramp_2[, cn]) |
|
171 |
+ all_scans <- header(mzml, scans = 1:nrow(all_scans)) |
|
172 |
+ all_scans_ramp <- header(ramp, scans = 1:nrow(all_scans)) |
|
173 |
+ all_scans$precursorScanNum <- 0 |
|
174 |
+ all_scans <- all_scans[, cn] |
|
175 |
+ all_scans_ramp <- all_scans_ramp[, cn] |
|
176 |
+ ## Replace all NA in all_scans with 0 |
|
177 |
+ all_scans <- data.frame(lapply(all_scans, function(z) { |
|
178 |
+ z[is.na(z)] <- 0 |
|
179 |
+ z |
|
180 |
+ })) |
|
181 |
+ all_scans_ramp <- data.frame(lapply(all_scans_ramp, function(z) { |
|
182 |
+ z[is.na(z)] <- 0 |
|
183 |
+ z |
|
184 |
+ })) |
|
185 |
+ checkEquals(all_scans, all_scans_ramp) |
|
149 | 186 |
|
150 | 187 |
## Some selected scans |
151 |
- scan_3 <- header(mzml, scans = c(3, 1, 14)) |
|
152 |
- scan_3_ramp <- header(ramp, scans = c(3, 1, 14)) |
|
153 |
- scan_3$precursorScanNum <- 0 |
|
154 |
- scan_3$centroided <- NA |
|
155 |
- checkEquals(scan_3[, cn], scan_3_ramp[, cn]) |
|
188 |
+ all_scans <- header(mzml, scans = c(3, 1, 14)) |
|
189 |
+ all_scans_ramp <- header(ramp, scans = c(3, 1, 14)) |
|
190 |
+ all_scans$precursorScanNum <- 0 |
|
191 |
+ all_scans <- all_scans[, cn] |
|
192 |
+ all_scans_ramp <- all_scans_ramp[, cn] |
|
193 |
+ ## Replace all NA in all_scans with 0 |
|
194 |
+ all_scans <- data.frame(lapply(all_scans, function(z) { |
|
195 |
+ z[is.na(z)] <- 0 |
|
196 |
+ z |
|
197 |
+ })) |
|
198 |
+ all_scans_ramp <- data.frame(lapply(all_scans_ramp, function(z) { |
|
199 |
+ z[is.na(z)] <- 0 |
|
200 |
+ z |
|
201 |
+ })) |
|
202 |
+ checkEquals(all_scans, all_scans_ramp) |
|
156 | 203 |
|
157 | 204 |
close(mzml) |
158 | 205 |
close(ramp) |
... | ... |
@@ -166,55 +213,62 @@ test_getScanHeaderInfo <- function() { |
166 | 213 |
scan_3 <- header(mzml, scans = 3) |
167 | 214 |
scan_3_ramp <- header(ramp, scans = 3) |
168 | 215 |
## Ramp does not read polarity, injectionTime or filterString |
169 |
- scan_3$polarity <- 0 |
|
170 |
- scan_3$injectionTime <- 0 |
|
171 |
- scan_3$filterString <- NA_character_ |
|
172 |
- scan_3$centroided <- NA |
|
173 |
- scan_3$isolationWindowTargetMZ <- NA_real_ |
|
174 |
- scan_3$isolationWindowLowerOffset <- NA_real_ |
|
175 |
- scan_3$isolationWindowUpperOffset <- NA_real_ |
|
176 |
- checkEquals(scan_3[cn], scan_3_ramp[cn]) |
|
177 |
- |
|
216 |
+ cn <- names(scan_3) |
|
217 |
+ cn <- cn[!(cn %in% c("spectrumId", "scanWindowLowerLimit", |
|
218 |
+ "scanWindowUpperLimit", "centroided", |
|
219 |
+ "polarity", "filterString", |
|
220 |
+ "isolationWindowTargetMZ", |
|
221 |
+ "isolationWindowLowerOffset", |
|
222 |
+ "isolationWindowUpperOffset", |
|
223 |
+ "injectionTime"))] |
|
224 |
+ scan_3 <- scan_3[cn] |
|
225 |
+ scan_3_ramp <- scan_3_ramp[cn] |
|
226 |
+ scan_3[is.na(scan_3)] <- 0 |
|
227 |
+ scan_3_ramp[is.na(scan_3_ramp)] <- 0 |
|
228 |
+ checkEquals(scan_3, scan_3_ramp) |
|
229 |
+ |
|
178 | 230 |
## Read all scan header |
179 |
- all_scans <- header(mzml) |
|
180 |
- all_scans_ramp <- header(ramp) |
|
181 |
- ## Ramp does not read polarity, injectionTime or filterString |
|
182 |
- all_scans$polarity <- 0 |
|
183 |
- all_scans$injectionTime <- 0 |
|
184 |
- all_scans$filterString <- NA_character_ |
|
185 |
- all_scans$centroided <- NA |
|
186 |
- all_scans$isolationWindowTargetMZ <- NA_real_ |
|
187 |
- all_scans$isolationWindowLowerOffset <- NA_real_ |
|
188 |
- all_scans$isolationWindowUpperOffset <- NA_real_ |
|
189 |
- checkEquals(all_scans[, cn], all_scans_ramp[, cn]) |
|
231 |
+ all_scans <- header(mzml)[, cn] |
|
232 |
+ all_scans_ramp <- header(ramp)[, cn] |
|
233 |
+ ## Replace all NA in all_scans with 0 |
|
234 |
+ all_scans <- data.frame(lapply(all_scans, function(z) { |
|
235 |
+ z[is.na(z)] <- 0 |
|
236 |
+ z |
|
237 |
+ })) |
|
238 |
+ all_scans_ramp <- data.frame(lapply(all_scans_ramp, function(z) { |
|
239 |
+ z[is.na(z)] <- 0 |
|
240 |
+ z |
|
241 |
+ })) |
|
242 |
+ checkEquals(all_scans, all_scans_ramp) |
|
190 | 243 |
|
191 | 244 |
## passing the index of all scan headers should return the same |
192 |
- all_scans_2 <- header(mzml, scans = 1:nrow(all_scans)) |
|
193 |
- all_scans_ramp_2 <- header(ramp, scans = 1:nrow(all_scans)) |
|
194 |
- ## Ramp does not read polarity, injectionTime or filterString |
|
195 |
- all_scans_2$polarity <- 0 |
|
196 |
- all_scans_2$injectionTime <- 0 |
|
197 |
- all_scans_2$filterString <- NA_character_ |
|
198 |
- all_scans_2$centroided <- NA |
|
199 |
- all_scans_2$isolationWindowTargetMZ <- NA_real_ |
|
200 |
- all_scans_2$isolationWindowLowerOffset <- NA_real_ |
|
201 |
- all_scans_2$isolationWindowUpperOffset <- NA_real_ |
|
202 |
- checkEquals(all_scans[, cn], all_scans_2[, cn]) |
|
203 |
- checkEquals(as.list(all_scans[3, cn]), scan_3[cn]) |
|
204 |
- checkEquals(all_scans_2[, cn], all_scans_ramp_2[, cn]) |
|
205 |
- |
|
245 |
+ all_scans_2 <- header(mzml, scans = 1:nrow(all_scans))[, cn] |
|
246 |
+ all_scans_ramp <- header(ramp, scans = 1:nrow(all_scans))[, cn] |
|
247 |
+ ## Replace all NA in all_scans with 0 |
|
248 |
+ all_scans_2 <- data.frame(lapply(all_scans_2, function(z) { |
|
249 |
+ z[is.na(z)] <- 0 |
|
250 |
+ z |
|
251 |
+ })) |
|
252 |
+ all_scans_ramp <- data.frame(lapply(all_scans_ramp, function(z) { |
|
253 |
+ z[is.na(z)] <- 0 |
|
254 |
+ z |
|
255 |
+ })) |
|
256 |
+ checkEquals(all_scans, all_scans_ramp) |
|
257 |
+ checkEquals(all_scans, all_scans_2) |
|
258 |
+ |
|
206 | 259 |
## Some selected scans |
207 |
- scan_3 <- header(mzml, scans = c(3, 1, 14)) |
|
208 |
- scan_3_ramp <- header(ramp, scans = c(3, 1, 14)) |
|
209 |
- ## Ramp does not read polarity, injectionTime or filterString |
|
210 |
- scan_3$polarity <- 0 |
|
211 |
- scan_3$injectionTime <- 0 |
|
212 |
- scan_3$filterString <- NA_character_ |
|
213 |
- scan_3$centroided <- NA |
|
214 |
- scan_3$isolationWindowTargetMZ <- NA_real_ |
|
215 |
- scan_3$isolationWindowLowerOffset <- NA_real_ |
|
216 |
- scan_3$isolationWindowUpperOffset <- NA_real_ |
|
217 |
- checkEquals(scan_3[, cn], scan_3_ramp[, cn]) |
|
260 |
+ all_scans <- header(mzml, scans = c(3, 1, 14))[, cn] |
|
261 |
+ all_scans_ramp <- header(ramp, scans = c(3, 1, 14))[, cn] |
|
262 |
+ ## Replace all NA in all_scans with 0 |
|
263 |
+ all_scans <- data.frame(lapply(all_scans, function(z) { |
|
264 |
+ z[is.na(z)] <- 0 |
|
265 |
+ z |
|
266 |
+ })) |
|
267 |
+ all_scans_ramp <- data.frame(lapply(all_scans_ramp, function(z) { |
|
268 |
+ z[is.na(z)] <- 0 |
|
269 |
+ z |
|
270 |
+ })) |
|
271 |
+ checkEquals(all_scans, all_scans_ramp) |
|
218 | 272 |
|
219 | 273 |
close(mzml) |
220 | 274 |
close(ramp) |
... | ... |
@@ -482,7 +482,7 @@ test_writeMSData <- function() { |
482 | 482 |
## I don't quite understand that, but the acquisitionNum and the |
483 | 483 |
## precursorScanNum are different while the spectrumId is the same. |
484 | 484 |
## Still, check that the precursorScanNum is what we expect: |
485 |
- checkEquals(hdr_new$precursorScanNum, c(0, 1, 0, 0, 4, 4)) |
|
485 |
+ checkEquals(hdr_new$precursorScanNum, c(NA, 1, NA, NA, 4, 4)) |
|
486 | 486 |
hdr_new$acquisitionNum <- as.integer(factor(hdr_new$acquisitionNum)) |
487 | 487 |
hdr_new$precursorScanNum <- as.integer(factor(hdr_new$precursorScanNum)) |
488 | 488 |
hdr_sub$acquisitionNum <- as.integer(factor(hdr_sub$acquisitionNum)) |
... | ... |
@@ -506,7 +506,7 @@ test_writeMSData <- function() { |
506 | 506 |
ii_new <- mzR::instrumentInfo(mzml_new) |
507 | 507 |
mzR::close(mzml_new) |
508 | 508 |
checkEquals(pks_new, pks_sub) |
509 |
- checkEquals(hdr_new$precursorScanNum, c(0, 1, 0, 0, 4, 4)) |
|
509 |
+ checkEquals(hdr_new$precursorScanNum, c(NA, 1, NA, NA, 4, 4)) |
|
510 | 510 |
rownames(hdr_sub) <- NULL |
511 | 511 |
rownames(hdr_new) <- NULL |
512 | 512 |
hdr_sub$acquisitionNum <- as.integer(factor(hdr_sub$acquisitionNum)) |
... | ... |
@@ -562,16 +562,25 @@ test_writeMSData <- function() { |
562 | 562 |
test_file <- system.file("iontrap", "extracted.mzData", package = "msdata") |
563 | 563 |
in_file <- openMSfile(test_file, backend = "Ramp") |
564 | 564 |
hdr <- header(in_file) |
565 |
+ hdr_orig <- hdr |
|
565 | 566 |
pks <- peaks(in_file) |
566 | 567 |
mzR::close(in_file) |
567 | 568 |
|
568 | 569 |
## mzML |
569 | 570 |
out_file <- paste0(test_folder, "/test_write.mzML") |
570 |
- writeMSData(file = out_file, header = hdr, object = pks) |
|
571 |
+ writeMSData(file = out_file, header = hdr_orig, object = pks) |
|
571 | 572 |
in_file <- openMSfile(out_file, backend = "pwiz") |
572 | 573 |
hdr_2 <- header(in_file) |
573 | 574 |
pks_2 <- peaks(in_file) |
574 | 575 |
mzR::close(in_file) |
576 |
+ hdr <- data.frame(lapply(hdr, function(z) { |
|
577 |
+ z[is.na(z)] <- 0 |
|
578 |
+ z |
|
579 |
+ })) |
|
580 |
+ hdr_2 <- data.frame(lapply(hdr_2, function(z) { |
|
581 |
+ z[is.na(z)] <- 0 |
|
582 |
+ z |
|
583 |
+ })) |
|
575 | 584 |
checkEquals(hdr, hdr_2) |
576 | 585 |
checkEquals(pks, pks_2) |
577 | 586 |
## validate mzML: |
... | ... |
@@ -581,10 +590,14 @@ test_writeMSData <- function() { |
581 | 590 |
|
582 | 591 |
## mzXML output: |
583 | 592 |
out_file <- paste0(test_folder, "test_write.mzXML") |
584 |
- writeMSData(file = out_file, header = hdr, object = pks, |
|
593 |
+ writeMSData(file = out_file, header = hdr_orig, object = pks, |
|
585 | 594 |
outformat = "mzXML") |
586 | 595 |
in_file <- openMSfile(out_file, backend = "pwiz") |
587 | 596 |
hdr_2 <- header(in_file) |
597 |
+ hdr_2 <- data.frame(lapply(hdr_2, function(z) { |
|
598 |
+ z[is.na(z)] <- 0 |
|
599 |
+ z |
|
600 |
+ })) |
|
588 | 601 |
pks_2 <- peaks(in_file) |
589 | 602 |
mzR::close(in_file) |
590 | 603 |
checkEquals(pks, pks_2) |
... | ... |
@@ -391,7 +391,7 @@ Rcpp::DataFrame RcppPwiz::getAllScanHeaderInfo ( ) { |
391 | 391 |
SpectrumListPtr slp = msd->run.spectrumListPtr; |
392 | 392 |
int N = slp->size(); |
393 | 393 |
|
394 |
- allScanHeaderInfo = getSpectrumHeader(Rcpp::seq(1, N)); |
|
394 |
+ allScanHeaderInfo = getScanHeaderInfo(Rcpp::seq(1, N)); |
|
395 | 395 |
isInCacheAllScanHeaderInfo = TRUE; |
396 | 396 |
} |
397 | 397 |
return allScanHeaderInfo ; |