Generalize error handling in seurat steps and make it easier to debug

bbimber · bbimber · commit b970a7d2d679 · 2022-01-30T07:09:57.000-08:00
diff --git a/singlecell/api-src/org/labkey/api/singlecell/pipeline/AbstractSingleCellPipelineStep.java b/singlecell/api-src/org/labkey/api/singlecell/pipeline/AbstractSingleCellPipelineStep.java
@@ -23,6 +23,7 @@
 import java.io.File;
 import java.io.IOException;
 import java.io.PrintWriter;
+import java.nio.file.Files;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
@@ -251,7 +252,7 @@ protected void executeR(SequenceOutputHandler.JobContext ctx, File rmd, String o
 
         executeR(ctx, getDockerContainerName(), outputPrefix, lines);
 
-        handlePossibleFailure(ctx);
+        handlePossibleFailure(ctx, outputPrefix);
     }
 
     public static void executeR(SequenceOutputHandler.JobContext ctx, String dockerContainerName, String outputPrefix, List<String> lines) throws PipelineJobException
@@ -526,7 +527,7 @@ protected void onFailure(SequenceOutputHandler.JobContext ctx) throws PipelineJo
         // This allows subclasses to implement tool-specific failure handling
     }
 
-    private void handlePossibleFailure(SequenceOutputHandler.JobContext ctx) throws PipelineJobException
+    private void handlePossibleFailure(SequenceOutputHandler.JobContext ctx, String outputPrefix) throws PipelineJobException
     {
         File errorFile = getSeuratErrorFile(ctx);
         if (errorFile.exists())
@@ -538,6 +539,19 @@ private void handlePossibleFailure(SequenceOutputHandler.JobContext ctx) throws
 
                 onFailure(ctx);
 
+                File html = getExpectedHtmlFile(ctx, outputPrefix);
+                if (html.exists())
+                {
+                    ctx.getLogger().info("Copying HTML locally for debugging: ", html.getName());
+                    File target = new File(ctx.getSourceDirectory(), html.getName());
+                    if (target.exists())
+                    {
+                        target.delete();
+                    }
+
+                    Files.copy(html.toPath(), target.toPath());
+                }
+
                 throw new PipelineJobException(getProvider().getName() + " Errors: " + StringUtils.join(errors, ";"));
             }
             catch (IOException e)
diff --git a/singlecell/api-src/org/labkey/api/singlecell/pipeline/SingleCellRawDataStep.java b/singlecell/api-src/org/labkey/api/singlecell/pipeline/SingleCellRawDataStep.java
@@ -0,0 +1,9 @@
+package org.labkey.api.singlecell.pipeline;
+
+/**
+ * NOTE: this is a special class designed to encompass the steps related to processing raw count data from the 10x/loupe matrix
+ */
+public interface SingleCellRawDataStep extends SingleCellStep
+{
+    public final String STEP_TYPE = "singleCellRawData";
+}
diff --git a/singlecell/api-src/org/labkey/api/singlecell/pipeline/SingleCellStep.java b/singlecell/api-src/org/labkey/api/singlecell/pipeline/SingleCellStep.java
@@ -16,7 +16,6 @@
 public interface SingleCellStep extends PipelineStep
 {
     public static final String STEP_TYPE = "singleCell";
-    public static final String SEURAT_PROCESSING = "seuratProcessing";
 
     public Collection<String> getRLibraries();
 
diff --git a/singlecell/resources/chunks/Functions.R b/singlecell/resources/chunks/Functions.R
@@ -86,7 +86,10 @@ saveData <- function(seuratObj, datasetId) {
 }
 
 intermediateFiles <- c()
-addIntermediateFile <- function(f) { intermediateFiles <<- c(intermediateFiles, f) }
+addIntermediateFile <- function(f) { intermediateFiles <- c(intermediateFiles, f) }
+
+errorMessages <- c()
+addErrorMessage <- function(f) { errorMessages <- c(errorMessages, f) }
 
 print('Updating future.globals.maxSize')
 options(future.globals.maxSize = Inf)
diff --git a/singlecell/resources/chunks/PrepareRawCounts.R b/singlecell/resources/chunks/PrepareRawCounts.R
@@ -5,7 +5,7 @@ for (datasetId in names(seuratObjects)) {
     seuratObj <- CellMembrane::ReadAndFilter10xData(dataDir = rawCountDir, datasetId = datasetId, datasetName = datasetName, emptyDropsLower = emptyDropsLower, emptyDropsFdrThreshold = emptyDropsFdrThreshold, useEmptyDropsCellRanger = useEmptyDropsCellRanger, nExpectedCells = nExpectedCells)
 
     if (!is.null(maxAllowableCells) && ncol(seuratObj) > maxAllowableCells) {
-        stop(paste0('The seurat object has ', ncol(seuratObj), ' cells, which is more than the max allowable cells (', maxAllowableCells, '). Please review emptyDrops results as this probably means thresholds were suboptimal.'))
+        addErrorMessage(paste0('The seurat object has ', ncol(seuratObj), ' cells, which is more than the max allowable cells (', maxAllowableCells, '). Please review emptyDrops results as this probably means thresholds were suboptimal.'))
     }
 
     saveData(seuratObj, datasetId)
diff --git a/singlecell/resources/chunks/RunCellHashing.R b/singlecell/resources/chunks/RunCellHashing.R
@@ -1,4 +1,3 @@
-errors <- c()
 for (datasetId in names(seuratObjects)) {
     seuratObj <- readRDS(seuratObjects[[datasetId]])
 
@@ -13,12 +12,12 @@ for (datasetId in names(seuratObjects)) {
 
             fractionFailedHashing <- 1 - (sum(seuratObj@meta.data$HTO.Classification %in% c('Singlet', 'Doublet')) / nrow(seuratObj@meta.data))
             if (!is.null(maxHashingPctFail) && fractionFailedHashing > maxHashingPctFail) {
-                errors <- c(errors, paste0('Fraction failing cell hashing was : ', fractionFailedHashing, ' for dataset: ', datasetId, ', above threshold of: ', maxHashingPctFail))
+                addErrorMessage(paste0('Fraction failing cell hashing was : ', fractionFailedHashing, ' for dataset: ', datasetId, ', above threshold of: ', maxHashingPctFail))
             }
 
             fractionDiscordantHashing <- 1 - (sum(seuratObj@meta.data$HTO.Classification == 'Discordant') / nrow(seuratObj@meta.data))
             if (!is.null(maxHashingPctDiscordant) && fractionDiscordantHashing > maxHashingPctDiscordant) {
-                errors <- c(errors, paste0('Discordant hashing rate was: ', fractionDiscordantHashing, ' for dataset: ', datasetId, ', above threshold of: ', maxHashingPctDiscordant))
+                addErrorMessage(paste0('Discordant hashing rate was: ', fractionDiscordantHashing, ' for dataset: ', datasetId, ', above threshold of: ', maxHashingPctDiscordant))
             }
         } else {
             # Add empty columns to keep objects consistent
@@ -45,13 +44,4 @@ for (datasetId in names(seuratObjects)) {
     # Cleanup
     rm(seuratObj)
     gc()
-}
-
-if (length(errors) > 0) {
-    print('There were errors:')
-    for (msg in errors) {
-        print(msg)
-    }
-
-    write(errors, file = 'seuratErrors.txt')
 }
diff --git a/singlecell/resources/chunks/SaveData.R b/singlecell/resources/chunks/SaveData.R
@@ -1,3 +1,12 @@
 if (length(intermediateFiles) > 0) {
     write.table(data.frame(file = intermediateFiles), file = 'intermediateFiles.txt', quote = FALSE, delim = '\t', row.names = FALSE, col.names = FALSE)
+}
+
+if (length(errorMessages) > 0) {
+    print('There were errors:')
+    for (msg in errorMessages) {
+        print(msg)
+    }
+
+    write(errorMessages, file = 'seuratErrors.txt')
 }
diff --git a/singlecell/resources/chunks/SeuratPrototype.R b/singlecell/resources/chunks/SeuratPrototype.R
@@ -1,47 +1,46 @@
 metricData <- data.frame(dataId = integer(), readsetId = integer(), metricname = character(), metricvalue = numeric())
 
-errors <- c()
 for (datasetId in names(seuratObjects)) {
   seuratObj <- readRDS(seuratObjects[[datasetId]])
   metricData <- rbind(metricData, data.frame(dataId = datasetId, readsetId = datasetIdToReadset[[datasetId]], metricname = 'TotalCells', metricvalue = ncol(seuratObj)))
 
   if (length(unique(seuratObj$DatasetId)) > 1) {
-    errors <- c(errors, paste0('Seurat data prototypes must be a single dataset. Problem ID: ', datasetId))
+    addErrorMessage(paste0('Seurat data prototypes must be a single dataset. Problem ID: ', datasetId))
   }
 
   if (is.null(usesHashing[[datasetId]])) {
-    errors <- c(errors, paste0('No hashing context provided for: ', datasetId))
+    addErrorMessage(paste0('No hashing context provided for: ', datasetId))
     break
   }
 
   if (usesHashing[[datasetId]]) {
     if (requireHashing && !('HTO.Classification' %in% names(seuratObj@meta.data))) {
-      errors <- c(errors, paste0('Missing cell hashing calls for dataset: ', datasetId))
+      addErrorMessage(paste0('Missing cell hashing calls for dataset: ', datasetId))
     }
 
     fractionFailedHashing <- 1 - (sum(seuratObj@meta.data$HTO.Classification %in% c('Singlet', 'Doublet')) / nrow(seuratObj@meta.data))
     if (!is.null(maxHashingPctFail) && fractionFailedHashing > maxHashingPctFail) {
-      errors <- c(errors, paste0('Fraction failing cell hashing was : ', fractionFailedHashing, ' for dataset: ', datasetId, ', above threshold of: ', maxHashingPctFail))
+      addErrorMessage(paste0('Fraction failing cell hashing was : ', fractionFailedHashing, ' for dataset: ', datasetId, ', above threshold of: ', maxHashingPctFail))
     }
 
     metricData <- rbind(metricData, data.frame(dataId = datasetId, readsetId = datasetIdToReadset[[datasetId]], metricname = 'FractionFailedHashing', metricvalue = fractionFailedHashing))
 
     fractionDiscordantHashing <- 1 - (sum(seuratObj@meta.data$HTO.Classification == 'Discordant') / nrow(seuratObj@meta.data))
     if (!is.null(maxHashingPctDiscordant) && fractionDiscordantHashing > maxHashingPctDiscordant) {
-      errors <- c(errors, paste0('Discordant hashing rate was: ', fractionDiscordantHashing, ' for dataset: ', datasetId, ', above threshold of: ', maxHashingPctDiscordant))
+      addErrorMessage(paste0('Discordant hashing rate was: ', fractionDiscordantHashing, ' for dataset: ', datasetId, ', above threshold of: ', maxHashingPctDiscordant))
     }
 
     metricData <- rbind(metricData, data.frame(dataId = datasetId, readsetId = datasetIdToReadset[[datasetId]], metricname = 'FractionDiscordantHashing', metricvalue = fractionDiscordantHashing))
   }
 
   if (is.null(usesCiteSeq[[datasetId]])) {
-    errors <- c(errors, paste0('No CITE-seq context provided for: ', datasetId))
+    addErrorMessage(paste0('No CITE-seq context provided for: ', datasetId))
     break
   }
 
   if (usesCiteSeq[[datasetId]] && requireCiteSeq) {
     if (!'ADT' %in% names(seuratObj@assays)) {
-      errors <- c(errors, paste0('Missing ADT data for dataset: ', datasetId))
+      addErrorMessage(paste0('Missing ADT data for dataset: ', datasetId))
     }
 
     fractionADTGT0 <- sum(seuratObj@meta.data$nCount_ADT > 0) / nrow(seuratObj@meta.data)
@@ -52,29 +51,29 @@ for (datasetId in names(seuratObjects)) {
   }
 
   if (requireSaturation && !'Saturation.RNA' %in% names(seuratObj@meta.data)) {
-    errors <- c(errors, paste0('Missing per-cell RNA saturation data for dataset: ', datasetId))
+    addErrorMessage(paste0('Missing per-cell RNA saturation data for dataset: ', datasetId))
   }
 
   if (!is.null(minSaturation)) {
     if (!'Saturation.RNA' %in% names(seuratObj@meta.data)) {
-      errors <- c(errors, paste0('Min saturation provided, but missing per-cell RNA saturation data for dataset: ', datasetId))
+      addErrorMessage(paste0('Min saturation provided, but missing per-cell RNA saturation data for dataset: ', datasetId))
     }
   }
 
   if ('Saturation.RNA' %in% names(seuratObj@meta.data)) {
     meanSaturation.RNA <- mean(seuratObj$Saturation.RNA)
     if (!is.null(minSaturation) && meanSaturation.RNA < minSaturation) {
-      errors <- c(errors, paste0('Mean RNA saturation was: ', meanSaturation.RNA, ' for dataset: ', datasetId, ', below threshold of: ', minSaturation))
+      addErrorMessage(paste0('Mean RNA saturation was: ', meanSaturation.RNA, ' for dataset: ', datasetId, ', below threshold of: ', minSaturation))
     }
 
     metricData <- rbind(metricData, data.frame(dataId = datasetId, readsetId = datasetIdToReadset[[datasetId]], metricname = 'MeanSaturation.RNA', metricvalue = meanSaturation.RNA))
   }
 
   if (requireSingleR && !'dice.label' %in% names(seuratObj@meta.data)) {
-    errors <- c(errors, paste0('Missing SingleR DICE labels for dataset: ', datasetId))
+    addErrorMessage(paste0('Missing SingleR DICE labels for dataset: ', datasetId))
   }
 
-  if (length(errors) > 0) {
+  if (length(errorMessages) > 0) {
     break
   }
 
@@ -90,15 +89,6 @@ for (datasetId in names(seuratObjects)) {
   gc()
 }
 
-if (length(errors) > 0) {
-  print('There were errors:')
-  for (msg in errors) {
-    print(msg)
-  }
-
-  write(errors, file = 'seuratErrors.txt')
-}
-
 if (nrow(metricData) > 0) {
   write.table(metricData, file = 'seurat.metrics.txt', sep = '\t', quote = F, row.names = F, col.names = F)
 }
diff --git a/singlecell/resources/chunks/SubsetSeurat.R b/singlecell/resources/chunks/SubsetSeurat.R
@@ -21,5 +21,5 @@ for (datasetId in names(seuratObjects)) {
 }
 
 if (totalPassed == 0) {
-	stop('No cells remained in any seurat objects after subsetting')
+	addErrorMessage('No cells remained in any seurat objects after subsetting')
 }
diff --git a/singlecell/resources/web/singlecell/panel/SingleCellProcessingPanel.js b/singlecell/resources/web/singlecell/panel/SingleCellProcessingPanel.js
@@ -218,12 +218,12 @@ Ext4.define('SingleCell.panel.SingleCellProcessingPanel', {
             items.push({
                 xtype: 'sequenceanalysis-analysissectionpanel',
                 title: 'Prepare Raw Data',
-                stepType: 'singleCell',
+                stepType: 'singleCellRawData',
                 singleTool: true,
                 comboValue: 'PrepareRawCounts',
                 sectionDescription: 'This section allows you to control the parsing of the raw 10x count data',
                 toolConfig: {
-                    singleCell: [{
+                    singleCellRawData: [{
                         description: 'Options related to processing the 10x matrix into a seurat object',
                         label: 'Prepare Raw Counts',
                         name: 'PrepareRawCounts',
diff --git a/singlecell/src/org/labkey/singlecell/SingleCellModule.java b/singlecell/src/org/labkey/singlecell/SingleCellModule.java
@@ -27,6 +27,7 @@
 import org.labkey.api.sequenceanalysis.SequenceAnalysisService;
 import org.labkey.api.sequenceanalysis.pipeline.SequencePipelineService;
 import org.labkey.api.singlecell.CellHashingService;
+import org.labkey.api.singlecell.pipeline.SingleCellRawDataStep;
 import org.labkey.api.singlecell.pipeline.SingleCellStep;
 import org.labkey.api.util.PageFlowUtil;
 import org.labkey.api.view.WebPartFactory;
@@ -123,6 +124,7 @@ protected void doStartupAfterSpringConfig(ModuleContext moduleContext)
     public static void registerPipelineSteps()
     {
         SequencePipelineService.get().registerPipelineStepType(SingleCellStep.class, SingleCellStep.STEP_TYPE);
+        SequencePipelineService.get().registerPipelineStepType(SingleCellRawDataStep.class, SingleCellRawDataStep.STEP_TYPE);
         CellHashingService.setInstance(CellHashingServiceImpl.get());
 
         SequencePipelineService.get().registerPipelineStep(new CellRangerGexCountStep.Provider());
diff --git a/singlecell/src/org/labkey/singlecell/pipeline/singlecell/PrepareRawCounts.java b/singlecell/src/org/labkey/singlecell/pipeline/singlecell/PrepareRawCounts.java
@@ -1,14 +1,11 @@
 package org.labkey.singlecell.pipeline.singlecell;
 
-import org.labkey.api.pipeline.PipelineJobException;
 import org.labkey.api.sequenceanalysis.pipeline.AbstractPipelineStepProvider;
 import org.labkey.api.sequenceanalysis.pipeline.PipelineContext;
-import org.labkey.api.sequenceanalysis.pipeline.SequenceOutputHandler;
 import org.labkey.api.singlecell.pipeline.SeuratToolParameter;
-import org.labkey.api.singlecell.pipeline.SingleCellStep;
+import org.labkey.api.singlecell.pipeline.SingleCellRawDataStep;
 
 import java.util.Arrays;
-import java.util.List;
 
 public class PrepareRawCounts extends AbstractCellMembraneStep
 {
@@ -19,7 +16,7 @@ public PrepareRawCounts(PipelineContext ctx, PrepareRawCounts.Provider provider)
         super(provider, ctx);
     }
 
-    public static class Provider extends AbstractPipelineStepProvider<SingleCellStep>
+    public static class Provider extends AbstractPipelineStepProvider<SingleCellRawDataStep>
     {
         public Provider()
         {

Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,6 @@`
`16`	`16`	`public interface SingleCellStep extends PipelineStep`
`17`	`17`	`{`
`18`	`18`	`public static final String STEP_TYPE = "singleCell";`
`19`		`- public static final String SEURAT_PROCESSING = "seuratProcessing";`
`20`	`19`
`21`	`20`	`public Collection<String> getRLibraries();`
`22`	`21`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@ for (datasetId in names(seuratObjects)) {`
`5`	`5`	`seuratObj <- CellMembrane::ReadAndFilter10xData(dataDir = rawCountDir, datasetId = datasetId, datasetName = datasetName, emptyDropsLower = emptyDropsLower, emptyDropsFdrThreshold = emptyDropsFdrThreshold, useEmptyDropsCellRanger = useEmptyDropsCellRanger, nExpectedCells = nExpectedCells)`
`6`	`6`
`7`	`7`	`if (!is.null(maxAllowableCells) && ncol(seuratObj) > maxAllowableCells) {`
`8`		`- stop(paste0('The seurat object has ', ncol(seuratObj), ' cells, which is more than the max allowable cells (', maxAllowableCells, '). Please review emptyDrops results as this probably means thresholds were suboptimal.'))`
	`8`	`+ addErrorMessage(paste0('The seurat object has ', ncol(seuratObj), ' cells, which is more than the max allowable cells (', maxAllowableCells, '). Please review emptyDrops results as this probably means thresholds were suboptimal.'))`
`9`	`9`	`}`
`10`	`10`
`11`	`11`	`saveData(seuratObj, datasetId)`
Original file line number	Diff line number	Diff line change
`@@ -1,47 +1,46 @@`
`1`	`1`	`metricData <- data.frame(dataId = integer(), readsetId = integer(), metricname = character(), metricvalue = numeric())`
`2`	`2`
`3`		`-errors <- c()`
`4`	`3`	`for (datasetId in names(seuratObjects)) {`
`5`	`4`	`seuratObj <- readRDS(seuratObjects[[datasetId]])`
`6`	`5`	`metricData <- rbind(metricData, data.frame(dataId = datasetId, readsetId = datasetIdToReadset[[datasetId]], metricname = 'TotalCells', metricvalue = ncol(seuratObj)))`
`7`	`6`
`8`	`7`	`if (length(unique(seuratObj$DatasetId)) > 1) {`
`9`		`- errors <- c(errors, paste0('Seurat data prototypes must be a single dataset. Problem ID: ', datasetId))`
	`8`	`+ addErrorMessage(paste0('Seurat data prototypes must be a single dataset. Problem ID: ', datasetId))`
`10`	`9`	`}`
`11`	`10`
`12`	`11`	`if (is.null(usesHashing[[datasetId]])) {`
`13`		`- errors <- c(errors, paste0('No hashing context provided for: ', datasetId))`
	`12`	`+ addErrorMessage(paste0('No hashing context provided for: ', datasetId))`
`14`	`13`	`break`
`15`	`14`	`}`
`16`	`15`
`17`	`16`	`if (usesHashing[[datasetId]]) {`
`18`	`17`	`if (requireHashing && !('HTO.Classification' %in% names(seuratObj@meta.data))) {`
`19`		`- errors <- c(errors, paste0('Missing cell hashing calls for dataset: ', datasetId))`
	`18`	`+ addErrorMessage(paste0('Missing cell hashing calls for dataset: ', datasetId))`
`20`	`19`	`}`
`21`	`20`
`22`	`21`	`fractionFailedHashing <- 1 - (sum(seuratObj@meta.data$HTO.Classification %in% c('Singlet', 'Doublet')) / nrow(seuratObj@meta.data))`
`23`	`22`	`if (!is.null(maxHashingPctFail) && fractionFailedHashing > maxHashingPctFail) {`
`24`		`- errors <- c(errors, paste0('Fraction failing cell hashing was : ', fractionFailedHashing, ' for dataset: ', datasetId, ', above threshold of: ', maxHashingPctFail))`
	`23`	`+ addErrorMessage(paste0('Fraction failing cell hashing was : ', fractionFailedHashing, ' for dataset: ', datasetId, ', above threshold of: ', maxHashingPctFail))`
`25`	`24`	`}`
`26`	`25`
`27`	`26`	`metricData <- rbind(metricData, data.frame(dataId = datasetId, readsetId = datasetIdToReadset[[datasetId]], metricname = 'FractionFailedHashing', metricvalue = fractionFailedHashing))`
`28`	`27`
`29`	`28`	`fractionDiscordantHashing <- 1 - (sum(seuratObj@meta.data$HTO.Classification == 'Discordant') / nrow(seuratObj@meta.data))`
`30`	`29`	`if (!is.null(maxHashingPctDiscordant) && fractionDiscordantHashing > maxHashingPctDiscordant) {`
`31`		`- errors <- c(errors, paste0('Discordant hashing rate was: ', fractionDiscordantHashing, ' for dataset: ', datasetId, ', above threshold of: ', maxHashingPctDiscordant))`
	`30`	`+ addErrorMessage(paste0('Discordant hashing rate was: ', fractionDiscordantHashing, ' for dataset: ', datasetId, ', above threshold of: ', maxHashingPctDiscordant))`
`32`	`31`	`}`
`33`	`32`
`34`	`33`	`metricData <- rbind(metricData, data.frame(dataId = datasetId, readsetId = datasetIdToReadset[[datasetId]], metricname = 'FractionDiscordantHashing', metricvalue = fractionDiscordantHashing))`
`35`	`34`	`}`
`36`	`35`
`37`	`36`	`if (is.null(usesCiteSeq[[datasetId]])) {`
`38`		`- errors <- c(errors, paste0('No CITE-seq context provided for: ', datasetId))`
	`37`	`+ addErrorMessage(paste0('No CITE-seq context provided for: ', datasetId))`
`39`	`38`	`break`
`40`	`39`	`}`
`41`	`40`
`42`	`41`	`if (usesCiteSeq[[datasetId]] && requireCiteSeq) {`
`43`	`42`	`if (!'ADT' %in% names(seuratObj@assays)) {`
`44`		`- errors <- c(errors, paste0('Missing ADT data for dataset: ', datasetId))`
	`43`	`+ addErrorMessage(paste0('Missing ADT data for dataset: ', datasetId))`
`45`	`44`	`}`
`46`	`45`
`47`	`46`	`fractionADTGT0 <- sum(seuratObj@meta.data$nCount_ADT > 0) / nrow(seuratObj@meta.data)`
`@@ -52,29 +51,29 @@ for (datasetId in names(seuratObjects)) {`
`52`	`51`	`}`
`53`	`52`
`54`	`53`	`if (requireSaturation && !'Saturation.RNA' %in% names(seuratObj@meta.data)) {`
`55`		`- errors <- c(errors, paste0('Missing per-cell RNA saturation data for dataset: ', datasetId))`
	`54`	`+ addErrorMessage(paste0('Missing per-cell RNA saturation data for dataset: ', datasetId))`
`56`	`55`	`}`
`57`	`56`
`58`	`57`	`if (!is.null(minSaturation)) {`
`59`	`58`	`if (!'Saturation.RNA' %in% names(seuratObj@meta.data)) {`
`60`		`- errors <- c(errors, paste0('Min saturation provided, but missing per-cell RNA saturation data for dataset: ', datasetId))`
	`59`	`+ addErrorMessage(paste0('Min saturation provided, but missing per-cell RNA saturation data for dataset: ', datasetId))`
`61`	`60`	`}`
`62`	`61`	`}`
`63`	`62`
`64`	`63`	`if ('Saturation.RNA' %in% names(seuratObj@meta.data)) {`
`65`	`64`	`meanSaturation.RNA <- mean(seuratObj$Saturation.RNA)`
`66`	`65`	`if (!is.null(minSaturation) && meanSaturation.RNA < minSaturation) {`
`67`		`- errors <- c(errors, paste0('Mean RNA saturation was: ', meanSaturation.RNA, ' for dataset: ', datasetId, ', below threshold of: ', minSaturation))`
	`66`	`+ addErrorMessage(paste0('Mean RNA saturation was: ', meanSaturation.RNA, ' for dataset: ', datasetId, ', below threshold of: ', minSaturation))`
`68`	`67`	`}`
`69`	`68`
`70`	`69`	`metricData <- rbind(metricData, data.frame(dataId = datasetId, readsetId = datasetIdToReadset[[datasetId]], metricname = 'MeanSaturation.RNA', metricvalue = meanSaturation.RNA))`
`71`	`70`	`}`
`72`	`71`
`73`	`72`	`if (requireSingleR && !'dice.label' %in% names(seuratObj@meta.data)) {`
`74`		`- errors <- c(errors, paste0('Missing SingleR DICE labels for dataset: ', datasetId))`
	`73`	`+ addErrorMessage(paste0('Missing SingleR DICE labels for dataset: ', datasetId))`
`75`	`74`	`}`
`76`	`75`
`77`		`- if (length(errors) > 0) {`
	`76`	`+ if (length(errorMessages) > 0) {`
`78`	`77`	`break`
`79`	`78`	`}`
`80`	`79`
`@@ -90,15 +89,6 @@ for (datasetId in names(seuratObjects)) {`
`90`	`89`	`gc()`
`91`	`90`	`}`
`92`	`91`
`93`		`-if (length(errors) > 0) {`
`94`		`- print('There were errors:')`
`95`		`- for (msg in errors) {`
`96`		`- print(msg)`
`97`		`- }`
`98`		`-`
`99`		`- write(errors, file = 'seuratErrors.txt')`
`100`		`-}`
`101`		`-`
`102`	`92`	`if (nrow(metricData) > 0) {`
`103`	`93`	`write.table(metricData, file = 'seurat.metrics.txt', sep = '\t', quote = F, row.names = F, col.names = F)`
`104`	`94`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,5 +21,5 @@ for (datasetId in names(seuratObjects)) {`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`if (totalPassed == 0) {`
`24`		`- stop('No cells remained in any seurat objects after subsetting')`
	`24`	`+ addErrorMessage('No cells remained in any seurat objects after subsetting')`
`25`	`25`	`}`