Browse code

Fix unit tests and documentation

jorainer authored on 24/09/2019 16:50:18
Showing 4 changed files

... ...
@@ -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)
... ...
@@ -42,7 +42,7 @@ psms(object, ...)
42 42
 substitutions(object)
43 43
 database(object, ...)
44 44
 enzymes(object)
45
-tolerance(object)
45
+tolerance(object, ...)
46 46
 score(x, ...)
47 47
 para(object)
48 48
 specParams(object)
... ...
@@ -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 ;