@@ -177,6 +177,7 @@ export(runMNNCorrect)

 export(runModelGeneVar)

 export(runNormalization)

 export(runPerCellQC)

+export(runQuickUMAP)

 export(runSCANORAMA)

 export(runSCMerge)

 export(runScDblFinder)

@@ -200,6 +201,7 @@ export(runSoupX)

 export(runTSCAN)

 export(runTSCANClusterDEAnalysis)

 export(runTSCANDEG)

+export(runUMAP)

 export(runVAM)

 export(runWilcox)

 export(runZINBWaVE)

@@ -242,6 +244,7 @@ import(DropletUtils)

 import(GSVAdata)

 import(SingleCellExperiment)

 import(fishpond)

+importFrom(BiocParallel,SerialParam)

 importFrom(S4Vectors,"metadata<-")

 importFrom(S4Vectors,metadata)

 importFrom(SingleCellExperiment,"counts<-")

@@ -195,7 +195,7 @@ setTopHVG <- function(inSCE,

     return(df)

 }

-#' parse `useFeatureSubset` in other functions such as `scaterPCA`, `getUMAP`..

+#' parse `useFeatureSubset` in other functions such as `scaterPCA`, `runUMAP`..

 #' Do checks, and return logical vector. Or character vector as needed by Seurat

 #' methods

 #' @param inSCE Input \linkS4class{SingleCellExperiment} object

@@ -579,8 +579,7 @@ plotBarcodeRankDropsResults <- function(inSCE,

 #' data(scExample, package="singleCellTK")

 #' \dontrun{

 #' sce <- subsetSCECols(sce, colData = "type != 'EmptyDroplet'")

-#' sce <- getUMAP(inSCE=sce, useAssay="counts", logNorm=TRUE, 

-#'                reducedDimName="UMAP")

+#' sce <- runQuickUMAP(sce)

 #' sce <- runScrublet(sce)

 #' plotScrubletResults(inSCE=sce, reducedDimName="UMAP")

 #' }

@@ -878,8 +877,7 @@ plotScrubletResults <- function(inSCE,

 #' @examples

 #' data(scExample, package="singleCellTK")

 #' sce <- subsetSCECols(sce, colData = "type != 'EmptyDroplet'")

-#' sce <- getUMAP(inSCE=sce, useAssay="counts", logNorm=TRUE, 

-#'                reducedDimName="UMAP")

+#' sce <- runQuickUMAP(sce)

 #' sce <- runDoubletFinder(sce)

 #' plotDoubletFinderResults(inSCE=sce, reducedDimName="UMAP")

 #' @export

@@ -1262,8 +1260,7 @@ plotDoubletFinderResults <- function(inSCE,

 #' @examples

 #' data(scExample, package="singleCellTK")

 #' sce <- subsetSCECols(sce, colData = "type != 'EmptyDroplet'")

-#' sce <- getUMAP(inSCE=sce, useAssay="counts", logNorm=TRUE, 

-#'                reducedDimName="UMAP")

+#' sce <- runQuickUMAP(sce)

 #' sce <- runScDblFinder(sce)

 #' plotScDblFinderResults(inSCE=sce, reducedDimName="UMAP")

 #' @export

@@ -1568,8 +1565,7 @@ plotScDblFinderResults <- function(inSCE,

 #' @examples

 #' data(scExample, package="singleCellTK")

 #' sce <- subsetSCECols(sce, colData = "type != 'EmptyDroplet'")

-#' sce <- getUMAP(inSCE=sce, useAssay="counts", logNorm=TRUE, 

-#'                reducedDimName="UMAP")

+#' sce <- runQuickUMAP(sce)

 #' sce <- runCxds(sce)

 #' plotCxdsResults(inSCE=sce, reducedDimName="UMAP")

 #' @export

@@ -1871,8 +1867,7 @@ plotCxdsResults <- function(inSCE,

 #' @examples

 #' data(scExample, package="singleCellTK")

 #' sce <- subsetSCECols(sce, colData = "type != 'EmptyDroplet'")

-#' sce <- getUMAP(inSCE=sce, useAssay="counts", logNorm=TRUE, 

-#'                reducedDimName="UMAP")

+#' sce <- runQuickUMAP(sce)

 #' sce <- runBcds(sce)

 #' plotBcdsResults(inSCE=sce, reducedDimName="UMAP")

 #' @export

@@ -2175,8 +2170,7 @@ plotBcdsResults <- function(inSCE,

 #' @examples

 #' data(scExample, package="singleCellTK")

 #' sce <- subsetSCECols(sce, colData = "type != 'EmptyDroplet'")

-#' sce <- getUMAP(inSCE=sce, useAssay="counts", logNorm=TRUE, 

-#'                reducedDimName="UMAP")

+#' sce <- runQuickUMAP(sce)

 #' sce <- runCxdsBcdsHybrid(sce)

 #' plotScdsHybridResults(inSCE=sce, reducedDimName="UMAP")

 #' @export

@@ -91,7 +91,7 @@ reportCellQC <- function(inSCE, output_file = NULL,

 #' sce <- subsetSCECols(sce, colData = "type != 'EmptyDroplet'")

 #' \dontrun{

 #' sce <- runDecontX(sce)

-#' sce <- getUMAP(sce, useAssay = "counts", logNorm = TRUE)

+#' sce <- runQuickUMAP(sce)

 #' reportQCTool(inSCE = sce, algorithm = "DecontX")

 #' }

 #' @export

@@ -124,7 +124,8 @@ plotBatchCorrCompare <- function(inSCE, corrMat, batch = NULL, condition = NULL,

                                  title = "Batch Variance before correction") +

     ggplot2::theme(text=ggplot2::element_text(size=10))

-  inSCE <- getUMAP(inSCE, useAssay = origAssay, reducedDimName = "umap.before")

+  inSCE <- runUMAP(inSCE, useAssay = origAssay, useReducedDim = NULL, 

+                   reducedDimName = "umap.before")

   umap.before <- plotSCEDimReduceColData(inSCE, batch, "umap.before",

                                          shape = condition, axisLabelSize = 9,

                                          axisSize = 8, dotSize = 1,

@@ -145,10 +146,11 @@ plotBatchCorrCompare <- function(inSCE, corrMat, batch = NULL, condition = NULL,

       ggplot2::theme(text=ggplot2::element_text(size=10))

     if (method == "ComBatSeq") {

-      inSCE <- getUMAP(inSCE, useAssay = corrMat, logNorm = TRUE,

-                       reducedDimName = "umap.after")

+      inSCE <- runUMAP(inSCE, useAssay = corrMat, useReducedDim = NULL, 

+                       logNorm = TRUE, reducedDimName = "umap.after")

     } else {

-      inSCE <- getUMAP(inSCE, useAssay = corrMat, reducedDimName = "umap.after")

+      inSCE <- runUMAP(inSCE, useAssay = corrMat, useReducedDim = NULL,

+                       logNorm = FALSE, reducedDimName = "umap.after")

     }

   } else if (matType == "altExp") {

     # Doing log, because only Seurat returns altExp,

@@ -161,8 +163,8 @@ plotBatchCorrCompare <- function(inSCE, corrMat, batch = NULL, condition = NULL,

                                   title = paste0("Batch Variance corrected with ",

                                                  method)) +

       ggplot2::theme(text=ggplot2::element_text(size=10))

-    inSCE <- getUMAP(inSCE, useAltExp = corrMat, useAssay = corrMat,

-                     reducedDimName = "umap.after")

+    inSCE <- runQuickUMAP(inSCE, useAssay = corrMat, useAltExp = corrMat, 

+                          reducedDimName = "umap.after")

   } else if (matType == "reducedDim") {

     bv.after <- plotBatchVariance(inSCE, useReddim = corrMat, batch = batch,

                                   condition = condition,

@@ -173,7 +175,7 @@ plotBatchCorrCompare <- function(inSCE, corrMat, batch = NULL, condition = NULL,

       SingleCellExperiment::reducedDim(inSCE, "umap.after") <-

         SingleCellExperiment::reducedDim(inSCE, corrMat)

     } else {

-      inSCE <- getUMAP(inSCE, useReducedDim = corrMat,

+      inSCE <- runUMAP(inSCE, useReducedDim = corrMat,

                        reducedDimName = "umap.after")

     }

   } else {

@@ -16,18 +16,18 @@

 #' @examples

 #' data(scExample, package = "singleCellTK")

 #' sce <- subsetSCECols(sce, colData = "type != 'EmptyDroplet'")

-#' sce <- getUMAP(inSCE = sce, useAssay = "counts", reducedDimName = "UMAP")

+#' sce <- runQuickUMAP(sce)

 #' plotUMAP(sce)

 plotUMAP <- function(inSCE, colorBy = NULL, shape = NULL,

                      reducedDimName = "UMAP", runUMAP = FALSE,

-                     useAssay = "logcounts"){

+                     useAssay = "counts"){

   if(!(reducedDimName %in% names(SingleCellExperiment::reducedDims(inSCE)))){

     if (runUMAP){

-      inSCE <- getUMAP(inSCE, useAssay = useAssay,

-                       reducedDimName = reducedDimName)

+      inSCE <- runQuickUMAP(inSCE, useAssay = useAssay,

+                            reducedDimName = reducedDimName)

     } else {

       stop(reducedDimName,

-           " dimension not found. Run getUMAP() or set runUMAP to TRUE.")

+           " dimension not found. Run runUMAP() or set runUMAP to TRUE.")

     }

   }

   UMAPDf <- data.frame(SingleCellExperiment::reducedDim(inSCE,

@@ -2,7 +2,7 @@

 #' @details Wrapper function to run one of the available dimensionality

 #' reduction algorithms integrated within SCTK from \code{\link{scaterPCA}},

 #' \code{\link{runSeuratPCA}}, \code{\link{runSeuratICA}}, \code{\link{getTSNE}},

-#' \code{\link{runSeuratTSNE}}, \code{\link{getUMAP}} and

+#' \code{\link{runSeuratTSNE}}, \code{\link{runUMAP}} and

 #' \code{\link{runSeuratUMAP}}. Users can use an assay by specifying

 #' \code{useAssay}, use the assay in an altExp by specifying both

 #' \code{useAltExp} and \code{useAssay}, or use a low-dimensionality

@@ -72,7 +72,7 @@ runDimReduce <- function(inSCE,

                        useFeatureSubset = useFeatureSubset, scale = scale,

                        seed = seed, ...)

   } else if (method == "scaterUMAP") {

-    inSCE <- getUMAP(inSCE = inSCE, useAssay = useAssay, useAltExp = useAltExp,

+    inSCE <- runUMAP(inSCE = inSCE, useAssay = useAssay, useAltExp = useAltExp,

                      useReducedDim = useReducedDim,

                      useFeatureSubset = useFeatureSubset, scale = scale,

                      reducedDimName = reducedDimName, seed = seed, ...)

@@ -360,9 +360,8 @@ runSoupX <- function(inSCE,

     out <- SoupX::adjustCounts(sc, method = adjustMethod,

                                roundToInt = roundToInt, tol = tol, pCut = pCut)

     message(paste0(date(), " ... Generating UMAP"))

-    # Most of time `useAssay` should be "counts", thus logNorm=TRUE

-    inSCE <- getUMAP(inSCE, useAssay = useAssay, logNorm = TRUE,

-                     reducedDimName = "sampleUMAP")

+    inSCE <- runQuickUMAP(inSCE, useAssay = useAssay, 

+                          reducedDimName = "sampleUMAP")

     return(list(sc = sc, out = out,

                 umap = SingleCellExperiment::reducedDim(inSCE, "sampleUMAP")))

 }

similarity index 71%

rename from R/getUMAP.R

rename to R/runUMAP.R

@@ -1,21 +1,26 @@

 #' Run UMAP embedding with scater method

+#' @rdname runUMAP

 #' @description Uniform Manifold Approximation and Projection (UMAP) algorithm

-#' is commonly for 2D visualization of single-cell data. This function wraps the

-#' scater \code{\link[scater]{calculateUMAP}} function.

-#'

-#' With this funciton, users can create UMAP embedding directly from raw count

-#' matrix, with necessary preprocessing including normalization, scaling,

-#' dimension reduction all automated. Yet we still recommend having the PCA as

-#' input, so that the result can match with the clustering based on the same

-#' input PCA.

+#' is commonly for 2D visualization of single-cell data. These functions wrap 

+#' the scater \code{\link[scater]{calculateUMAP}} function.

+#' 

+#' Users can use \code{runQuickUMAP} to directly create UMAP embedding from raw

+#' count matrix, with necessary preprocessing including normalization, variable

+#' feature selection, scaling, dimension reduction all automated. Therefore, 

+#' \code{useReducedDim} is disabled for \code{runQuickUMAP}. 

+#' 

+#' In a complete analysis, we still recommend having dimension reduction such as

+#' PCA created beforehand and select proper numbers of dimensions for using

+#' \code{runUMAP}, so that the result can match with the clustering based on the

+#' same input PCA. 

 #' @param inSCE Input \linkS4class{SingleCellExperiment} object.

+#' @param useReducedDim The low dimension representation to use for UMAP

+#' computation. If \code{useAltExp} is specified, \code{useReducedDim} has to

+#' exist in \code{reducedDims(altExp(inSCE, useAltExp))}. Default \code{"PCA"}.

 #' @param useAssay Assay to use for UMAP computation. If \code{useAltExp} is

 #' specified, \code{useAssay} has to exist in

 #' \code{assays(altExp(inSCE, useAltExp))}. Ignored when using

-#' \code{useReducedDim}. Default \code{"logcounts"}.

-#' @param useReducedDim The low dimension representation to use for UMAP

-#' computation. If \code{useAltExp} is specified, \code{useReducedDim} has to

-#' exist in \code{reducedDims(altExp(inSCE, useAltExp))}. Default \code{NULL}.

+#' \code{useReducedDim}. Default \code{NULL}.

 #' @param useAltExp The subset to use for UMAP computation, usually for the

 #' selected variable features. Default \code{NULL}.

 #' @param sample Character vector. Indicates which sample each cell belongs to.

@@ -25,7 +30,7 @@

 #' coordinates obtained from this method. Default \code{"UMAP"}.

 #' @param logNorm Whether the counts will need to be log-normalized prior to

 #' generating the UMAP via \code{\link{scaterlogNormCounts}}. Ignored when using

-#' \code{useReducedDim}. Default \code{FALSE}.

+#' \code{useReducedDim}. Default \code{TRUE}.

 #' @param useFeatureSubset Subset of feature to use for dimension reduction. A

 #' character string indicating a \code{rowData} variable that stores the logical

 #' vector of HVG selection, or a vector that can subset the rows of

@@ -67,23 +72,23 @@

 #' data(scExample, package = "singleCellTK")

 #' sce <- subsetSCECols(sce, colData = "type != 'EmptyDroplet'")

 #' # Run from raw counts

-#' sce <- getUMAP(inSCE = sce, useAssay = "counts", logNorm = TRUE, nTop = 2000,

-#'                scale = TRUE, pca = TRUE)

+#' sce <- runQuickUMAP(sce)

 #' \dontrun{

 #' # Run from PCA

 #' sce <- scaterlogNormCounts(sce, "logcounts")

 #' sce <- runModelGeneVar(sce)

 #' sce <- scaterPCA(sce, useAssay = "logcounts",

 #'                  useFeatureSubset = "HVG_modelGeneVar2000", scale = TRUE)

-#' sce <- getUMAP(sce, useReducedDim = "PCA")

+#' sce <- runUMAP(sce, useReducedDim = "PCA")

 #' }

 #' @importFrom S4Vectors metadata<-

-getUMAP <- function(inSCE, useAssay = "logcounts", useReducedDim = NULL,

+#' @importFrom BiocParallel SerialParam

+runUMAP <- function(inSCE, useReducedDim = "PCA", useAssay = NULL, 

                     useAltExp = NULL, sample = NULL, reducedDimName = "UMAP",

-                    logNorm = FALSE, useFeatureSubset = NULL, nTop = 2000,

+                    logNorm = TRUE, useFeatureSubset = NULL, nTop = 2000,

                     scale = TRUE, pca = TRUE, initialDims = 25, nNeighbors = 30,

                     nIterations = 200, alpha = 1, minDist = 0.01, spread = 1,

-                    seed = NULL, BPPARAM = BiocParallel::SerialParam()) {

+                    seed = NULL, BPPARAM = SerialParam()) {

   params <- as.list(environment())

   params$inSCE <- NULL

   params$BPPARAM <- NULL

@@ -120,7 +125,7 @@ getUMAP <- function(inSCE, useAssay = "logcounts", useReducedDim = NULL,

     if (!isTRUE(pca) & !is.null(useAssay)) {

       initialDims <- NULL

     }

-

+    

     nNeighbors <- min(ncol(sceSample), nNeighbors)

     message(paste0(date(), " ... Computing Scater UMAP for sample '",

                    samples[i], "'."))

@@ -145,3 +150,39 @@ getUMAP <- function(inSCE, useAssay = "logcounts", useReducedDim = NULL,

   metadata(inSCE)$sctk$runDimReduce$embedding[[reducedDimName]] <- params

   return(inSCE)

 }

+

+#' @rdname runUMAP

+#' @param ... Parameters passed to \code{runUMAP}

+#' @importFrom BiocParallel SerialParam

+#' @export

+runQuickUMAP <- function(inSCE, useAssay = "counts", sample = "sample", ...) {

+  args <- list(...)

+  if (!is.null(args$useReducedDim)) {

+    warning("Forcing `useReducedDim` to be `NULL`. Please use `runUMAP` for ",

+            "using reducedDim.")

+  }

+  args$useReducedDim <- NULL

+  args <- c(list(inSCE = inSCE, useAssay = useAssay, useReducedDim = NULL), 

+            args)

+  inSCE <- do.call("runUMAP", args = args)

+  return(inSCE)

+}

+

+#' @rdname runUMAP

+#' @export

+#' @importFrom BiocParallel SerialParam

+getUMAP <- function(inSCE, useReducedDim = "PCA", useAssay = NULL, 

+                    useAltExp = NULL, sample = NULL, reducedDimName = "UMAP",

+                    logNorm = TRUE, useFeatureSubset = NULL, nTop = 2000,

+                    scale = TRUE, pca = TRUE, initialDims = 25, nNeighbors = 30,

+                    nIterations = 200, alpha = 1, minDist = 0.01, spread = 1,

+                    seed = NULL, BPPARAM = SerialParam()) {

+  .Deprecated("runUMAP")

+  runUMAP(inSCE, useReducedDim = useReducedDim, useAssay = useAssay, 

+          useAltExp = useAltExp, sample = sample, 

+          reducedDimName = reducedDimName,

+          logNorm = logNorm, useFeatureSubset = useFeatureSubset, nTop = nTop,

+          scale = scale, pca = pca, initialDims = initialDims, 

+          nNeighbors = nNeighbors, nIterations = nIterations, alpha = alpha, 

+          minDist = minDist, spread = spread, seed = seed, BPPARAM = BPPARAM)

+}

@@ -144,8 +144,7 @@ A wrapper function which visualizes outputs from the

 \examples{

 data(scExample, package="singleCellTK")

 sce <- subsetSCECols(sce, colData = "type != 'EmptyDroplet'")

-sce <- getUMAP(inSCE=sce, useAssay="counts", logNorm=TRUE, 

-               reducedDimName="UMAP")

+sce <- runQuickUMAP(sce)

 sce <- runBcds(sce)

 plotBcdsResults(inSCE=sce, reducedDimName="UMAP")

 }

@@ -144,8 +144,7 @@ A wrapper function which visualizes outputs from the

 \examples{

 data(scExample, package="singleCellTK")

 sce <- subsetSCECols(sce, colData = "type != 'EmptyDroplet'")

-sce <- getUMAP(inSCE=sce, useAssay="counts", logNorm=TRUE, 

-               reducedDimName="UMAP")

+sce <- runQuickUMAP(sce)

 sce <- runCxds(sce)

 plotCxdsResults(inSCE=sce, reducedDimName="UMAP")

 }

@@ -144,8 +144,7 @@ A wrapper function which visualizes outputs from the

 \examples{

 data(scExample, package="singleCellTK")

 sce <- subsetSCECols(sce, colData = "type != 'EmptyDroplet'")

-sce <- getUMAP(inSCE=sce, useAssay="counts", logNorm=TRUE, 

-               reducedDimName="UMAP")

+sce <- runQuickUMAP(sce)

 sce <- runDoubletFinder(sce)

 plotDoubletFinderResults(inSCE=sce, reducedDimName="UMAP")

 }

@@ -144,8 +144,7 @@ A wrapper function which visualizes outputs from the

 \examples{

 data(scExample, package="singleCellTK")

 sce <- subsetSCECols(sce, colData = "type != 'EmptyDroplet'")

-sce <- getUMAP(inSCE=sce, useAssay="counts", logNorm=TRUE, 

-               reducedDimName="UMAP")

+sce <- runQuickUMAP(sce)

 sce <- runScDblFinder(sce)

 plotScDblFinderResults(inSCE=sce, reducedDimName="UMAP")

 }

@@ -144,8 +144,7 @@ A wrapper function which visualizes outputs from the

 \examples{

 data(scExample, package="singleCellTK")

 sce <- subsetSCECols(sce, colData = "type != 'EmptyDroplet'")

-sce <- getUMAP(inSCE=sce, useAssay="counts", logNorm=TRUE, 

-               reducedDimName="UMAP")

+sce <- runQuickUMAP(sce)

 sce <- runCxdsBcdsHybrid(sce)

 plotScdsHybridResults(inSCE=sce, reducedDimName="UMAP")

 }

@@ -145,8 +145,7 @@ A wrapper function which visualizes outputs from the

 data(scExample, package="singleCellTK")

 \dontrun{

 sce <- subsetSCECols(sce, colData = "type != 'EmptyDroplet'")

-sce <- getUMAP(inSCE=sce, useAssay="counts", logNorm=TRUE, 

-               reducedDimName="UMAP")

+sce <- runQuickUMAP(sce)

 sce <- runScrublet(sce)

 plotScrubletResults(inSCE=sce, reducedDimName="UMAP")

 }

@@ -10,7 +10,7 @@ plotUMAP(

   shape = NULL,

   reducedDimName = "UMAP",

   runUMAP = FALSE,

-  useAssay = "logcounts"

+  useAssay = "counts"

 )

 }

 \arguments{

@@ -38,6 +38,6 @@ Plot UMAP results either on already run results or run first and then plot.

 \examples{

 data(scExample, package = "singleCellTK")

 sce <- subsetSCECols(sce, colData = "type != 'EmptyDroplet'")

-sce <- getUMAP(inSCE = sce, useAssay = "counts", reducedDimName = "UMAP")

+sce <- runQuickUMAP(sce)

 plotUMAP(sce)

 }

@@ -35,7 +35,7 @@ data(scExample, package = "singleCellTK")

 sce <- subsetSCECols(sce, colData = "type != 'EmptyDroplet'")

 \dontrun{

 sce <- runDecontX(sce)

-sce <- getUMAP(sce, useAssay = "counts", logNorm = TRUE)

+sce <- runQuickUMAP(sce)

 reportQCTool(inSCE = sce, algorithm = "DecontX")

 }

 }

@@ -67,7 +67,7 @@ Generic Wrapper function for running dimensionality reduction

 Wrapper function to run one of the available dimensionality

 reduction algorithms integrated within SCTK from \code{\link{scaterPCA}},

 \code{\link{runSeuratPCA}}, \code{\link{runSeuratICA}}, \code{\link{getTSNE}},

-\code{\link{runSeuratTSNE}}, \code{\link{getUMAP}} and

+\code{\link{runSeuratTSNE}}, \code{\link{runUMAP}} and

 \code{\link{runSeuratUMAP}}. Users can use an assay by specifying

 \code{useAssay}, use the assay in an altExp by specifying both

 \code{useAltExp} and \code{useAssay}, or use a low-dimensionality

similarity index 73%

rename from man/getUMAP.Rd

rename to man/runUMAP.Rd

@@ -1,17 +1,43 @@

 % Generated by roxygen2: do not edit by hand

-% Please edit documentation in R/getUMAP.R

-\name{getUMAP}

+% Please edit documentation in R/runUMAP.R

+\name{runUMAP}

+\alias{runUMAP}

+\alias{runQuickUMAP}

 \alias{getUMAP}

 \title{Run UMAP embedding with scater method}

 \usage{

+runUMAP(

+  inSCE,

+  useReducedDim = "PCA",

+  useAssay = NULL,

+  useAltExp = NULL,

+  sample = NULL,

+  reducedDimName = "UMAP",

+  logNorm = TRUE,

+  useFeatureSubset = NULL,

+  nTop = 2000,

+  scale = TRUE,

+  pca = TRUE,

+  initialDims = 25,

+  nNeighbors = 30,

+  nIterations = 200,

+  alpha = 1,

+  minDist = 0.01,

+  spread = 1,

+  seed = NULL,

+  BPPARAM = SerialParam()

+)

+

+runQuickUMAP(inSCE, useAssay = "counts", sample = "sample", ...)

+

 getUMAP(

   inSCE,

-  useAssay = "logcounts",

-  useReducedDim = NULL,

+  useReducedDim = "PCA",

+  useAssay = NULL,

   useAltExp = NULL,

   sample = NULL,

   reducedDimName = "UMAP",

-  logNorm = FALSE,

+  logNorm = TRUE,

   useFeatureSubset = NULL,

   nTop = 2000,

   scale = TRUE,

@@ -23,20 +49,20 @@ getUMAP(

   minDist = 0.01,

   spread = 1,

   seed = NULL,

-  BPPARAM = BiocParallel::SerialParam()

+  BPPARAM = SerialParam()

 )

 }

 \arguments{

 \item{inSCE}{Input \linkS4class{SingleCellExperiment} object.}

+\item{useReducedDim}{The low dimension representation to use for UMAP

+computation. If \code{useAltExp} is specified, \code{useReducedDim} has to

+exist in \code{reducedDims(altExp(inSCE, useAltExp))}. Default \code{"PCA"}.}

+

 \item{useAssay}{Assay to use for UMAP computation. If \code{useAltExp} is

 specified, \code{useAssay} has to exist in

 \code{assays(altExp(inSCE, useAltExp))}. Ignored when using

-\code{useReducedDim}. Default \code{"logcounts"}.}

-

-\item{useReducedDim}{The low dimension representation to use for UMAP

-computation. If \code{useAltExp} is specified, \code{useReducedDim} has to

-exist in \code{reducedDims(altExp(inSCE, useAltExp))}. Default \code{NULL}.}

+\code{useReducedDim}. Default \code{NULL}.}

 \item{useAltExp}{The subset to use for UMAP computation, usually for the

 selected variable features. Default \code{NULL}.}

@@ -50,7 +76,7 @@ coordinates obtained from this method. Default \code{"UMAP"}.}

 \item{logNorm}{Whether the counts will need to be log-normalized prior to

 generating the UMAP via \code{\link{scaterlogNormCounts}}. Ignored when using

-\code{useReducedDim}. Default \code{FALSE}.}

+\code{useReducedDim}. Default \code{TRUE}.}

 \item{useFeatureSubset}{Subset of feature to use for dimension reduction. A

 character string indicating a \code{rowData} variable that stores the logical

@@ -97,6 +123,8 @@ Default \code{NULL} will use global seed in use by the R environment.}

 \item{BPPARAM}{A \linkS4class{BiocParallelParam} object specifying whether

 the PCA should be parallelized.}

+

+\item{...}{Parameters passed to \code{runUMAP}}

 }

 \value{

 A \linkS4class{SingleCellExperiment} object with UMAP computation

@@ -104,27 +132,30 @@ updated in \code{reducedDim(inSCE, reducedDimName)}.

 }

 \description{

 Uniform Manifold Approximation and Projection (UMAP) algorithm

-is commonly for 2D visualization of single-cell data. This function wraps the

-scater \code{\link[scater]{calculateUMAP}} function.

-

-With this funciton, users can create UMAP embedding directly from raw count

-matrix, with necessary preprocessing including normalization, scaling,

-dimension reduction all automated. Yet we still recommend having the PCA as

-input, so that the result can match with the clustering based on the same

-input PCA.

+is commonly for 2D visualization of single-cell data. These functions wrap 

+the scater \code{\link[scater]{calculateUMAP}} function.

+

+Users can use \code{runQuickUMAP} to directly create UMAP embedding from raw

+count matrix, with necessary preprocessing including normalization, variable

+feature selection, scaling, dimension reduction all automated. Therefore, 

+\code{useReducedDim} is disabled for \code{runQuickUMAP}. 

+

+In a complete analysis, we still recommend having dimension reduction such as

+PCA created beforehand and select proper numbers of dimensions for using

+\code{runUMAP}, so that the result can match with the clustering based on the

+same input PCA.

 }

 \examples{

 data(scExample, package = "singleCellTK")

 sce <- subsetSCECols(sce, colData = "type != 'EmptyDroplet'")

 # Run from raw counts

-sce <- getUMAP(inSCE = sce, useAssay = "counts", logNorm = TRUE, nTop = 2000,

-               scale = TRUE, pca = TRUE)

+sce <- runQuickUMAP(sce)

 \dontrun{

 # Run from PCA

 sce <- scaterlogNormCounts(sce, "logcounts")

 sce <- runModelGeneVar(sce)

 sce <- scaterPCA(sce, useAssay = "logcounts",

                  useFeatureSubset = "HVG_modelGeneVar2000", scale = TRUE)

-sce <- getUMAP(sce, useReducedDim = "PCA")

+sce <- runUMAP(sce, useReducedDim = "PCA")

 }

 }

@@ -45,32 +45,33 @@ test_that(desc = "Testing scaterPCA", {

 test_that(desc = "Testing scater UMAP", {

     sce <- scaterPCA(sce, useFeatureSubset = "hvg", seed = 12345, reducedDimName = "PCA1")

-    sce <- getUMAP(sce, useReducedDim = "PCA1", reducedDimName = "UMAP1")

+    sce <- runUMAP(sce, useReducedDim = "PCA1", reducedDimName = "UMAP1")

     testthat::expect_true("UMAP1" %in% reducedDimNames(sce))

-    sce <- getUMAP(sce, useAssay = "hvgAltExplogcounts", useAltExp = "hvgAltExp",

+    sce <- runUMAP(sce, useAssay = "hvgAltExplogcounts", useReducedDim = NULL,

+                   useAltExp = "hvgAltExp",

                    reducedDimName = "UMAP2")

     testthat::expect_true("UMAP2" %in% reducedDimNames(sce))

     # TODO: Still some runable conditions

     expect_error({

-        getUMAP(inSCE = 1)

+        runUMAP(inSCE = 1)

     }, "`inSCE` should be a SingleCellExperiment Object.")

     expect_error({

-        getUMAP(sce, useAssay = NULL, useReducedDim = NULL)

+        runUMAP(sce, useAssay = NULL, useReducedDim = NULL)

     }, "Either `useAssay` or `useReducedDim` has to be specified.")

     expect_error({

-        getUMAP(sce, useAltExp = "altexp")

+        runUMAP(sce, useAltExp = "altexp")

     }, "Specified `useAltExp` 'altexp' not found.")

     expect_error({

-        getUMAP(sce, useReducedDim = "TSNE")

+        runUMAP(sce, useReducedDim = "TSNE")

     }, "Specified `useReducedDim` 'TSNE' not found.")

     expect_error({

-        getUMAP(sce, useAssay = "TSNE")

+        runUMAP(sce, useAssay = "TSNE", useReducedDim = NULL)

     }, regexp = "Specified `useAssay` 'TSNE' not found.")

     expect_error({

-        getUMAP(sce, sample = "batch")

+        runUMAP(sce, useReducedDim = "PCA1", sample = "batch")

     }, regexp = "Specified variable 'batch'")

     expect_error({

-        getUMAP(sce, sample = letters)

+        runUMAP(sce, useReducedDim = "PCA1", sample = letters)

     }, regexp = "Invalid variable length")

     p1 <- plotUMAP(sce, reducedDimName = "UMAP1", colorBy = "type", shape = "type")

@@ -100,12 +101,6 @@ test_that(desc = "Testing Rtsne TSNE", {

     expect_error({

         getTSNE(sce, useAltExp = "altexp")

     }, "Specified `useAltExp` 'altexp' not found.")

-    expect_error({

-        getUMAP(sce, useReducedDim = "TSNE")

-    }, "Specified `useReducedDim` 'TSNE' not found.")

-    expect_error({

-        getUMAP(sce, useAssay = "TSNE")

-    }, regexp = "Specified `useAssay` 'TSNE' not found.")

     p1 <- plotTSNE(sce, reducedDimName = "TSNE1", colorBy = "type", shape = "type")

     p2 <- plotTSNE(sce, reducedDimName = "TSNE3", runTSNE = TRUE)

@@ -5,13 +5,8 @@ data(scExample, package = "singleCellTK")

 sceDroplet <- sce

 sce <- subsetSCECols(sce, colData = "type != 'EmptyDroplet'")

 sampleVector <- c(rep("Sample1", 100), rep("Sample2", 95))

-sceres <- getUMAP(inSCE = sce, useAssay = "counts", logNorm = TRUE, sample = sampleVector, nNeighbors = 10, reducedDimName = "UMAP",

-                nIterations = 20, alpha = 1, minDist = 0.01, pca = TRUE, initialDims = 20)

-

-test_that(desc = "Testing getUMAP", {

-        expect_equal(names(reducedDims(sceres)), "UMAP")

-	expect_equal(nrow(reducedDim(sceres, "UMAP")), ncol(sce))

-})

+sceres <- runQuickUMAP(inSCE = sce, sample = sampleVector, nNeighbors = 10,

+                nIterations = 20, alpha = 1, minDist = 0.01, initialDims = 20)

 test_that(desc = "Testing plotSCEScatter functions", {

     p1 <- plotSCEScatter(inSCE = sceres, legendTitle = NULL,