@@ -75,35 +75,21 @@ getTSNE <- function(inSCE, useAssay = "logcounts", useReducedDim = NULL,

                     nIterations = 1000, numThreads = 1, seed = NULL){

   params <- as.list(environment())

   params$inSCE <- NULL

-  # input class check

-  if (!inherits(inSCE, "SingleCellExperiment")){

-    stop("Please use a SingleCellExperiment object")

-  }

-  # matrix specification check

-  # When useReducedDim, never useAssay;

-  # when useAltExp, useAssay/reducedDim from there

-  if (is.null(useAssay) && is.null(useReducedDim)) {

-    stop("`useAssay` and `useReducedDim` cannot be NULL at the same time.")

-  }

+  # Note: useMat = list(useAssay = useAssay, ...)

+  # `.selectSCEMatrix()` does the check and corrects the conditions

+  # When using useReducedDim, useAssay will be ignored

+  useMat <- .selectSCEMatrix(inSCE, useAssay = useAssay,

+                             useReducedDim = useReducedDim,

+                             useAltExp = useAltExp,

+                             returnMatrix = FALSE)$names

+  params$useAssay <- useMat$useAssay

+  useAssay <- useMat$useAssay

+

   if (!is.null(useAltExp)) {

-    if (!useAltExp %in% SingleCellExperiment::altExpNames(inSCE)) {

-      stop("Specified `useAltExp` not found.")

-    }

     sce <- SingleCellExperiment::altExp(inSCE, useAltExp)

   } else {

     sce <- inSCE

   }

-  if (!is.null(useReducedDim)) {

-    useAssay <- NULL

-    if (!useReducedDim %in% SingleCellExperiment::reducedDimNames(sce)) {

-      stop("Specified `useReducedDim` not found.")

-    }

-  } else {

-    # In this case, there is definitely `useAssay` specified

-    if (!useAssay %in% SummarizedExperiment::assayNames(sce)) {

-      stop("Specified `useAssay` not found.")

-    }

-  }

   if (!is.null(useAssay)) {

     if (isTRUE(logNorm)) {

@@ -119,9 +105,9 @@ getTSNE <- function(inSCE, useAssay = "logcounts", useReducedDim = NULL,

       if (!is.null(nTop) && nTop < nrow(sce)) {

         suppressMessages({

           sce <- runFeatureSelection(sce, useAssay, method = "modelGeneVar")

+          sce <- setTopHVG(sce, method = "modelGeneVar", hvgNumber = nTop,

+                           featureSubsetName = "tsneHVG")

         })

-        sce <- setTopHVG(sce, method = "modelGeneVar", hvgNumber = nTop,

-                         featureSubsetName = "tsneHVG")

         sce <- subsetSCERows(sce, rowData = "tsneHVG", returnAsAltExp = FALSE)

       }

     }

@@ -1,39 +1,39 @@

 #' Run UMAP embedding with scater method

-#' @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. 

-#' 

+#' @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 

+#' 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.

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

 #' @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{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 

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

 #' exist in \code{reducedDims(altExp(inSCE, useAltExp))}. 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.

-#' If given a single character, will take the annotation from \code{colData}. 

+#' If given a single character, will take the annotation from \code{colData}.

 #' Default \code{NULL}.

 #' @param reducedDimName A name to store the results of the UMAP embedding

 #' 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}.

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

+#' @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 

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

 #' \code{inSCE}. Default \code{NULL}.

 #' @param nTop Automatically detect this number of variable features to use for

-#' dimension reduction. Ignored when using \code{useReducedDim} or using 

+#' dimension reduction. Ignored when using \code{useReducedDim} or using

 #' \code{useFeatureSubset}. Default \code{2000}.

-#' @param scale Whether \code{useAssay} matrix will need to be standardized. 

+#' @param scale Whether \code{useAssay} matrix will need to be standardized.

 #' Default \code{TRUE}.

 #' @param pca Logical. Whether to perform dimension reduction with PCA before

 #' UMAP. Ignored when using \code{useReducedDim}. Default \code{TRUE}.

@@ -53,12 +53,12 @@

 #' result on a more even dispersal of points. Default \code{0.01}. See

 #' \code{\link[scater]{calculateUMAP}} for more information.

 #' @param spread The effective scale of embedded points. In combination with

-#' \code{minDist}, this determines how clustered/clumped the embedded points 

-#' are. Default \code{1}. See \code{\link[scater]{calculateUMAP}} for more 

+#' \code{minDist}, this determines how clustered/clumped the embedded points

+#' are. Default \code{1}. See \code{\link[scater]{calculateUMAP}} for more

 #' information.

-#' @param seed Random seed for reproducibility of UMAP results. 

+#' @param seed Random seed for reproducibility of UMAP results.

 #' Default \code{NULL} will use global seed in use by the R environment.

-#' @param BPPARAM A \linkS4class{BiocParallelParam} object specifying whether 

+#' @param BPPARAM A \linkS4class{BiocParallelParam} object specifying whether

 #' the PCA should be parallelized.

 #' @return A \linkS4class{SingleCellExperiment} object with UMAP computation

 #' updated in \code{reducedDim(inSCE, reducedDimName)}.

@@ -73,67 +73,35 @@

 #' # Run from PCA

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

 #' sce <- runModelGeneVar(sce)

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

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

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

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

 #' }

 #' @importFrom S4Vectors metadata<-

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

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

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

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

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

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

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

+                    logNorm = FALSE, 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()) {

   params <- as.list(environment())

   params$inSCE <- NULL

   params$BPPARAM <- NULL

-  # input class check

-  if (!inherits(inSCE, "SingleCellExperiment")){

-    stop("Please use a SingleCellExperiment object")

-  }

-  # matrix specification check

-  # When useReducedDim, never useAssay; 

-  # when useAltExp, useAssay/reducedDim from there

-  if (is.null(useAssay) && is.null(useReducedDim)) {

-    stop("`useAssay` and `useReducedDim` cannot be NULL at the same time.")

-  } 

-  if (!is.null(useAltExp)) {

-    if (!useAltExp %in% SingleCellExperiment::altExpNames(inSCE)) {

-      stop("Specified `useAltExp` not found.")

-    }

-    sce <- SingleCellExperiment::altExp(inSCE, useAltExp)

-  } else {

-    sce <- inSCE

-  }

-  if (!is.null(useReducedDim)) {

-    useAssay <- NULL

-    if (!useReducedDim %in% SingleCellExperiment::reducedDimNames(sce)) {

-      stop("Specified `useReducedDim` not found.")

-    }

-  } else {

-    # In this case, there is definitely `useAssay` specified

-    if (!useAssay %in% SummarizedExperiment::assayNames(sce)) {

-      stop("Specified `useAssay` not found.")

-    }

-  }

-  # Check sample variable

-  if(!is.null(sample)) {

-    if (is.character(sample) && length(sample) == 1) {

-      if (!sample %in% names(SummarizedExperiment::colData(inSCE))) {

-        stop("Given sample annotation '", sample, "' not found.")

-      }

-      sample <- SummarizedExperiment::colData(inSCE)[[sample]]

-    } else if (length(sample) > 1) {

-      if(length(sample) != ncol(inSCE)) {

-        stop("'sample' must be the same length as the number of columns in ", 

-             "'inSCE'")

-      }

-    }

-  } else {

-    sample = rep(1, ncol(inSCE))

-  }

+  # Note: useMat = list(useAssay = useAssay, ...)

+  # `.selectSCEMatrix()` does the check and corrects the conditions

+  # When using useReducedDim, useAssay will be ignored

+  useMat <- .selectSCEMatrix(inSCE, useAssay = useAssay,

+                             useReducedDim = useReducedDim,

+                             useAltExp = useAltExp,

+                             returnMatrix = FALSE)$names

+  params$useAssay <- useMat$useAssay

+  useAssay <- useMat$useAssay

+  if (!is.null(useAltExp)) sce <- SingleCellExperiment::altExp(inSCE, useAltExp)

+  else sce <- inSCE

+  sample <- .manageCellVar(inSCE, sample)

+  if (is.null(sample)) sample <- rep(1, ncol(inSCE))

   samples <- unique(sample)

-  umapDims = matrix(nrow = ncol(inSCE), ncol = 2)

+  umapDims <- matrix(nrow = ncol(inSCE), ncol = 2)

   # Start looping for each sample

   for (i in seq_along(samples)){

     sceSampleInd <- sample == samples[i]

@@ -146,13 +114,13 @@ getUMAP <- function(inSCE, useAssay = "logcounts", useReducedDim = NULL,

         useAssayTemp = "ScaterLogNormCounts"

       }

     }

-    subset_row <- .parseUseFeatureSubset(inSCE, useFeatureSubset, 

+    subset_row <- .parseUseFeatureSubset(inSCE, useFeatureSubset,

                                          altExpObj = sce, returnType = "logic")

-    # initialDims passed to `pca` of scran::calculateUMAP. 

+    # initialDims passed to `pca` of scran::calculateUMAP.

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

       initialDims <- NULL

     }

-    

+

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

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

                    samples[i], "'."))

@@ -163,8 +131,8 @@ getUMAP <- function(inSCE, useAssay = "logcounts", useReducedDim = NULL,

                                        learning_rate = alpha,

                                        min_dist = minDist, spread = spread,

                                        n_sgd_threads = 1, pca = initialDims,

-                                       n_epochs = nIterations, 

-                                       subset_row = subset_row, ntop = nTop, 

+                                       n_epochs = nIterations,

+                                       subset_row = subset_row, ntop = nTop,

                                        BPPARAM = BPPARAM)

     })

     if (is.null(rownames(sceSample))) {

@@ -55,9 +55,8 @@

                 "matType. Force using user specification.")

       }

       matType <- ifelse(is.null(matType), bcInfo$matType, matType)

-      batch <- ifelse(is.null(batch), bcInfo$batch, batch)

+      if (is.null(batch)) batch <- bcInfo$batch

       if (is.null(condition)) condition <- bcInfo$condition

-      #condition <- ifelse(is.null(condition), bcInfo$condition, condition)

     }

   }

   return(list(origAssay = origAssay,

@@ -94,7 +93,7 @@

 #' @return An object of class \code{"gtable"}, combining four \code{ggplot}s.

 #' @examples

 #' data("sceBatches")

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

+#' logcounts(sceBatches) <- log1p(counts(sceBatches))

 #' sceBatches <- runLimmaBC(sceBatches)

 #' plotBatchCorrCompare(sceBatches, "LIMMA", condition = "cell_type")

 #' @export

@@ -232,59 +231,33 @@ plotBatchCorrCompare <- function(inSCE, corrMat, batch = NULL, condition = NULL,

 #'                   condition = "cell_type")

 plotBatchVariance <- function(inSCE, useAssay = NULL, useReddim = NULL,

                               useAltExp = NULL, batch = 'batch',

-                              condition=NULL, title = NULL) {

-  if(!inherits(inSCE, 'SingleCellExperiment')){

-    stop("'inSCE' must inherit from 'SingleCellExperiment'.")

-  }

-  if(is.null(useAssay) + is.null(useReddim) + is.null(useAltExp) != 2){

-    stop("One and only one of `useAssay`, `useReddim`, ",

-         "`usAltExp` has to be specified.")

-  }

-  if(!is.null(useAssay)){

-    if(!useAssay %in% SummarizedExperiment::assayNames(inSCE)){

-      stop("'useAssay' not found in 'inSCE'.")

-    }

-    mat <- SummarizedExperiment::assay(inSCE, useAssay)

-  }

-  if(!is.null(useReddim)){

-    if(!useReddim %in% SingleCellExperiment::reducedDimNames(inSCE)){

-      stop("'useReddim not found in 'inSCE'.")

-    }

-    mat <- t(SingleCellExperiment::reducedDim(inSCE, useReddim))

-  }

-  if(!is.null(useAltExp)){

-    if(!useAltExp %in% SingleCellExperiment::altExpNames(inSCE)){

-      stop("'useAltExp not found in 'inSCE'.")

-    }

-    ae <- SingleCellExperiment::altExp(inSCE, useAltExp)

-    mat <- SummarizedExperiment::assay(ae)

-  }

+                              condition = NULL, title = NULL) {

+  useMat <- .selectSCEMatrix(inSCE, useAssay = useAssay,

+                             useReducedDim = useReddim, useAltExp = useAltExp,

+                             returnMatrix = TRUE, cellAsCol = TRUE)

+  mat <- useMat$mat

   if(is.null(batch)){

     stop("Batch annotation has to be given.")

-  } else{

-    if(!batch %in% names(SummarizedExperiment::colData(inSCE))){

-      stop("'batch' not found in 'inSCE'.")

-    }

   }

+  batchCol <- .manageCellVar(inSCE, var = batch, as.factor = TRUE)

   if(!inherits(mat, 'matrix')){

     mat <- as.matrix(mat)

   }

-  batchCol <- SummarizedExperiment::colData(inSCE)[, batch]

-  nlb <- nlevels(as.factor(batchCol))

+  nlb <- nlevels(batchCol)

   if (nlb <= 1){

     stop("No more than one batch found in specified annotation")

   } else {

-    batchMod <- stats::model.matrix(~as.factor(batchCol))

+    batchMod <- stats::model.matrix(~batchCol)

   }

   if (is.null(condition)){

     condMod <- matrix(rep(1, ncol(mat)), ncol = 1)

   } else {

-    condCol <- SingleCellExperiment::colData(inSCE)[, condition]

-    nlc <- nlevels(as.factor(condCol))

+    condCol <- .manageCellVar(inSCE, var = condition, as.factor = TRUE)

+    nlc <- nlevels(condCol)

     if (nlc <= 1){

       condMod <- matrix(rep(1, ncol(mat)), ncol = 1)

     } else {

-      condMod <- stats::model.matrix(~as.factor(condCol))

+      condMod <- stats::model.matrix(~condCol)

     }

   }

   mod <- cbind(condMod, batchMod[, -1])

@@ -3,12 +3,12 @@

 #' BBKNN, an extremely fast graph-based data integration algorithm. It modifies

 #' the neighbourhood construction step to produce a graph that is balanced

 #' across all batches of the data.

-#' @param inSCE \linkS4class{SingleCellExperiment} inherited object. Required.

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

 #' @param useAssay A single character indicating the name of the assay requiring

 #' batch correction. Default \code{"logcounts"}.

-#' @param batch A single character indicating a field in

-#' \code{\link{colData}} that annotates the batches.

-#' Default \code{"batch"}.

+#' @param batch A single character indicating a field in \code{colData} that

+#' annotates the batches of each cell; or a vector/factor with the same length

+#' as the number of cells. Default \code{"batch"}.

 #' @param reducedDimName A single character. The name for the corrected

 #' low-dimensional representation. Will be saved to \code{reducedDim(inSCE)}.

 #' Default \code{"BBKNN"}.

@@ -24,17 +24,12 @@

 #' @examples

 #' \dontrun{

 #' data('sceBatches', package = 'singleCellTK')

-#' logcounts(sceBatches) <- log(counts(sceBatches) + 1)

-#' sceBatches.small <- sample(sceBatches, 20)

-#' sceCorr <- runBBKNN(sceBatches.small, useAssay = "logcounts",

-#'                     nComponents = 10)

+#' logcounts(sceBatches) <- log1p(counts(sceBatches))

+#' sceBatches <- runBBKNN(sceBatches, useAssay = "logcounts",

+#'                        nComponents = 10)

 #' }

 runBBKNN <-function(inSCE, useAssay = 'logcounts', batch = 'batch',

                     reducedDimName = 'BBKNN', nComponents = 50L){

-  ## Input check

-  if(!inherits(inSCE, "SingleCellExperiment")){

-    stop("\"inSCE\" should be a SingleCellExperiment Object.")

-  }

   if(!reticulate::py_module_available(module = "bbknn")){

     warning("Cannot find python module 'bbknn', please install Conda and",

             " run sctkPythonInstallConda() or run ",

@@ -48,15 +43,16 @@ runBBKNN <-function(inSCE, useAssay = 'logcounts', batch = 'batch',

             " to select the correct Python environment.")

     return(inSCE)

   }

-  if(!batch %in% names(SummarizedExperiment::colData(inSCE))){

-    stop(paste("\"batch\" name:", batch, "not found"))

-  }

+  useAssay <- .selectSCEMatrix(inSCE, useAssay = useAssay,

+                               returnMatrix = FALSE)$names$useAssay

+  batchVec <- .manageCellVar(inSCE, batch, as.factor = FALSE)

   reducedDimName <- gsub(' ', '_', reducedDimName)

   nComponents <- as.integer(nComponents)

   ## Run algorithm

   adata <- .sce2adata(inSCE, useAssay = useAssay)

+  adata$obs[["batch"]] <- batchVec

   sc$tl$pca(adata, n_comps = nComponents)

-  bbknn$bbknn(adata, batch_key = batch, n_pcs = nComponents)

+  bbknn$bbknn(adata, batch_key = "batch", n_pcs = nComponents)

   sc$tl$umap(adata, n_components = nComponents)

   bbknnUmap <- adata$obsm[["X_umap"]]

   SingleCellExperiment::reducedDim(inSCE, reducedDimName) <- bbknnUmap

@@ -84,7 +80,7 @@ runBBKNN <-function(inSCE, useAssay = 'logcounts', batch = 'batch',

 #' informative covariates could still be useful. If the cell types are unknown

 #' and are expected to be unbalanced, it is recommended to set \code{useSVA}

 #' to \code{TRUE}.

-#' @param inSCE \linkS4class{SingleCellExperiment} inherited object. Required.

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

 #' @param useAssay A single character indicating the name of the assay requiring

 #' batch correction. Default \code{"counts"}.

 #' @param batch A single character indicating a field in

@@ -198,69 +194,76 @@ runComBatSeq <- function(inSCE, useAssay = "counts", batch = 'batch',

 #'

 #' fastMNN is a variant of the classic MNN method, modified for speed and more

 #' robust performance. For introduction of MNN, see \code{\link{runMNNCorrect}}.

-#' @param inSCE  inherited object. Required.

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

 #' @param useAssay A single character indicating the name of the assay requiring

-#' batch correction. Default \code{"logcounts"}. Alternatively, see

-#' \code{pcInput} parameter.

-#' @param batch A single character indicating a field in

-#' \code{\link{colData}} that annotates the batches.

-#' Default \code{"batch"}.

+#' batch correction. Default \code{"logcounts"}.

+#' @param useReducedDim A single character indicating the dimension reduction

+#' used for batch correction. Will ignore \code{useAssay} when using.

+#' Default \code{NULL}.

+#' @param batch A single character indicating a field in \code{colData} that

+#' annotates the batches of each cell; or a vector/factor with the same length

+#' as the number of cells. Default \code{"batch"}.

 #' @param reducedDimName A single character. The name for the corrected

-#' low-dimensional representation. Will be saved to \code{reducedDim(inSCE)}.

-#' Default \code{"fastMNN"}.

-#' @param pcInput A logical scalar. Whether to use a low-dimension matrix for

-#' batch effect correction. If \code{TRUE}, \code{useAssay} will be searched

-#' from \code{reducedDimNames(inSCE)}. Default \code{FALSE}.

+#' low-dimensional representation. Default \code{"fastMNN"}.

+#' @param k An integer scalar specifying the number of nearest neighbors to

+#' consider when identifying MNNs. See "See Also". Default \code{20}.

+#' @param propK A numeric scalar in (0, 1) specifying the proportion of cells in

+#' each dataset to use for mutual nearest neighbor searching. See "See Also".

+#' Default \code{NULL}.

+#' @param ndist A numeric scalar specifying the threshold beyond which

+#' neighbours are to be ignored when computing correction vectors. See "See

+#' Also". Default \code{3}.

+#' @param minBatchSkip Numeric scalar specifying the minimum relative magnitude

+#' of the batch effect, below which no correction will be performed at a given

+#' merge step. See "See Also". Default \code{0}.

+#' @param cosNorm A logical scalar indicating whether cosine normalization

+#' should be performed on \code{useAssay} prior to PCA. See "See Also". Default

+#' \code{TRUE}.

+#' @param nComponents An integer scalar specifying the number of dimensions to

+#' produce. See "See Also". Default \code{50}.

+#' @param weights The weighting scheme to use. Passed to

+#' \code{\link[batchelor]{multiBatchPCA}}. Default \code{NULL}.

+#' @param BPPARAM A \linkS4class{BiocParallelParam} object specifying whether

+#' the SVD should be parallelized.

 #' @return The input \linkS4class{SingleCellExperiment} object with

 #' \code{reducedDim(inSCE, reducedDimName)} updated.

+#' @seealso \code{\link[batchelor]{fastMNN}} for using \code{useAssay}, and

+#' \code{\link[batchelor]{reducedMNN}} for using \code{useReducedDim}

 #' @export

 #' @references Lun ATL, et al., 2016

 #' @examples

 #' data('sceBatches', package = 'singleCellTK')

-#' logcounts(sceBatches) <- log(counts(sceBatches) + 1)

-#' sceCorr <- runFastMNN(sceBatches, useAssay = 'logcounts', pcInput = FALSE)

-runFastMNN <- function(inSCE, useAssay = "logcounts",

-                       reducedDimName = "fastMNN", batch = 'batch',

-                       pcInput = FALSE){

-  ## Input check

-  if(!inherits(inSCE, "SingleCellExperiment")){

-    stop("\"inSCE\" should be a SingleCellExperiment Object.")

-  }

-  if(isTRUE(pcInput)){

-    if(!(useAssay %in% SingleCellExperiment::reducedDimNames(inSCE))) {

-      stop(paste("\"useAssay\" (reducedDim) name: ", useAssay, " not found."))

-    }

-  } else {

-    if(!(useAssay %in% SummarizedExperiment::assayNames(inSCE))) {

-      stop(paste("\"useAssay\" (assay) name: ", useAssay, " not found."))

-    }

-  }

-

-  if(!(batch %in% names(SummarizedExperiment::colData(inSCE)))){

-    stop(paste("\"batch name:", batch, "not found."))

-  }

+#' logcounts(sceBatches) <- log1p(counts(sceBatches))

+#' sceCorr <- runFastMNN(sceBatches, useAssay = 'logcounts')

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

+                       batch = 'batch', reducedDimName = "fastMNN", k = 20,

+                       propK = NULL, ndist = 3, minBatchSkip = 0,

+                       cosNorm = TRUE, nComponents = 50, weights = NULL,

+                       BPPARAM = BiocParallel::SerialParam()){

+  useMat <- .selectSCEMatrix(inSCE, useAssay = useAssay,

+                             useReducedDim = useReducedDim,

+                             returnMatrix = TRUE)

+  mat <- useMat$mat

+  batchVec <- .manageCellVar(inSCE, batch, as.factor = TRUE)

   reducedDimName <- gsub(' ', '_', reducedDimName)

-  ## Run algorithm

-  batches <- list()

-  batchCol <- SummarizedExperiment::colData(inSCE)[[batch]]

-  batchFactor <- as.factor(batchCol)

-

-  if(pcInput){

-    mat <- SingleCellExperiment::reducedDim(inSCE, useAssay)

-    redMNN <- batchelor::reducedMNN(mat, batch = batchFactor)

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

+    redMNN <- batchelor::reducedMNN(mat, batch = batchVec, BPPARAM = BPPARAM,

+                                    k = k, prop.k = propK, ndist = ndist,

+                                    min.batch.skip = minBatchSkip)

     newRedDim <- redMNN$corrected

   } else {

-    mat <- SummarizedExperiment::assay(inSCE, useAssay)

-    mnnSCE <- batchelor::fastMNN(mat, batch = batchFactor)

+    mnnSCE <- batchelor::fastMNN(mat, batch = batchVec, BPPARAM = BPPARAM, k = k,

+                                 prop.k = propK, ndist = ndist,

+                                 min.batch.skip = minBatchSkip,

+                                 cos.norm = cosNorm, d = nComponents,

+                                 weights = weights)

     newRedDim <- SingleCellExperiment::reducedDim(mnnSCE, 'corrected')

   }

   SingleCellExperiment::reducedDim(inSCE, reducedDimName) <- newRedDim

-  S4Vectors::metadata(inSCE)$batchCorr[[reducedDimName]] <- list(useAssay = useAssay,

-                                                            origLogged = TRUE,

-                                                            method = "fastMNN",

-                                                            matType = "reducedDim",

-                                                            batch = batch)

+  S4Vectors::metadata(inSCE)$batchCorr[[reducedDimName]] <-

+    list(useAssay = useAssay, origLogged = TRUE, method = "fastMNN",

+         matType = "reducedDim", batch = batch)

   return(inSCE)

 }

@@ -268,15 +271,15 @@ runFastMNN <- function(inSCE, useAssay = "logcounts",

 #' @description Harmony is an algorithm that projects cells into a shared

 #' embedding in which cells group by cell type rather than dataset-specific

 #' conditions.

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

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

 #' @param useAssay A single character indicating the name of the assay requiring

 #' batch correction. Default \code{"logcounts"}.

 #' @param useReducedDim A single character indicating the name of the reducedDim

 #' used to be corrected. Specifying this will ignore \code{useAssay}. Default

 #' \code{NULL}.

-#' @param batch A single character indicating a field in

-#' \code{\link{colData}} that annotates the batches.

-#' Default \code{"batch"}.

+#' @param batch A single character indicating a field in \code{colData} that

+#' annotates the batches of each cell; or a vector/factor with the same length

+#' as the number of cells. Default \code{"batch"}.

 #' @param reducedDimName A single character. The name for the corrected

 #' low-dimensional representation. Will be saved to \code{reducedDim(inSCE)}.

 #' Default \code{"HARMONY"}.

@@ -307,7 +310,7 @@ runFastMNN <- function(inSCE, useAssay = "logcounts",

 #' @references Ilya Korsunsky, et al., 2019

 #' @examples

 #' data('sceBatches', package = 'singleCellTK')

-#' logcounts(sceBatches) <- log(counts(sceBatches) + 1)

+#' logcounts(sceBatches) <- log1p(counts(sceBatches))

 #' sceCorr <- runHarmony(sceBatches)

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

                        batch = "batch", reducedDimName = "HARMONY",

@@ -320,15 +323,15 @@ runHarmony <- function(inSCE, useAssay = "logcounts", useReducedDim = NULL,

          call. = FALSE)

   }

   ## Input check

-  matrixSelect <- .selectSCEMatrix(inSCE, useAssay, useReducedDim,

-                                   useAltExp = NULL, returnMatrix = TRUE)

-  batch <- .manageCellVar(inSCE, batch, as.factor = TRUE)

+  useMat <- .selectSCEMatrix(inSCE, useAssay, useReducedDim,

+                             useAltExp = NULL, returnMatrix = TRUE)

+  batchVec <- .manageCellVar(inSCE, batch, as.factor = TRUE)

   reducedDimName <- gsub(' ', '_', reducedDimName)

   ## Run algorithm

   message(Sys.Date(), " ... Running harmony batch correction")

-  mat <- matrixSelect$mat

-  do_pca <- ifelse(is.null(matrixSelect$names$useReducedDim), TRUE, FALSE)

-  if (!is.null(matrixSelect$names$useReducedDim)) {

+  mat <- useMat$mat

+  do_pca <- ifelse(is.null(useMat$names$useReducedDim), TRUE, FALSE)

+  if (!is.null(useMat$names$useReducedDim)) {

     if (nComponents > ncol(mat)) {

       warning("Specified number of components more than available, ",

               "using all (", ncol(mat), ") components.")

@@ -336,12 +339,15 @@ runHarmony <- function(inSCE, useAssay = "logcounts", useReducedDim = NULL,

     }

     mat <- mat[,seq(nComponents)]

   }

-  h <- harmony::HarmonyMatrix(data_mat = mat, meta_data = batch,

+  h <- harmony::HarmonyMatrix(data_mat = mat, meta_data = batchVec,

                               do_pca = do_pca, npcs = nComponents,

                               lambda = lambda, theta = theta,

                               sigma = sigma, max.iter.harmony = nIter,

                               verbose = verbose, return_object = FALSE, ...)

   SingleCellExperiment::reducedDim(inSCE, reducedDimName) <- h

+  S4Vectors::metadata(inSCE)$batchCorr[[reducedDimName]] <-

+    list(useAssay = useAssay, origLogged = TRUE, method = "harmony",

+         matType = "reducedDim", batch = batch)

   return(inSCE)

 }

@@ -349,7 +355,7 @@ runHarmony <- function(inSCE, useAssay = "logcounts", useReducedDim = NULL,

 # #'

 # #' LIGER relies on integrative non-negative matrix factorization to identify

 # #' shared and dataset-specific factors.

-# #' @param inSCE \linkS4class{SingleCellExperiment} inherited object. Required.

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

 # #' @param useAssay A single character indicating the name of the assay requiring

 # #' batch correction. Default \code{"logcounts"}.

 # #' @param batch A single character indicating a field in

@@ -427,12 +433,12 @@ runHarmony <- function(inSCE, useAssay = "logcounts", useReducedDim = NULL,

 #'

 #' Limma's batch effect removal function fits a linear model to the data, then

 #' removes the component due to the batch effects.

-#' @param inSCE \linkS4class{SingleCellExperiment} inherited object. Required.

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

 #' @param useAssay A single character indicating the name of the assay requiring

 #' batch correction. Default \code{"logcounts"}.

-#' @param batch A single character indicating a field in

-#' \code{\link{colData}} that annotates the batches.

-#' Default \code{"batch"}.

+#' @param batch A single character indicating a field in \code{colData} that

+#' annotates the batches of each cell; or a vector/factor with the same length

+#' as the number of cells. Default \code{"batch"}.

 #' @param assayName A single characeter. The name for the corrected assay. Will

 #' be saved to \code{\link{assay}}. Default

 #' \code{"LIMMA"}.

@@ -442,30 +448,19 @@ runHarmony <- function(inSCE, useAssay = "logcounts", useReducedDim = NULL,

 #' @references Gordon K Smyth, et al., 2003

 #' @examples

 #' data('sceBatches', package = 'singleCellTK')

-#' logcounts(sceBatches) <- log(counts(sceBatches) + 1)

+#' logcounts(sceBatches) <- log1p(counts(sceBatches))

 #' sceCorr <- runLimmaBC(sceBatches)

 runLimmaBC <- function(inSCE, useAssay = "logcounts", assayName = "LIMMA",

                        batch = "batch") {

   ## Input check

-  if(!inherits(inSCE, "SingleCellExperiment")){

-    stop("\"inSCE\" should be a SingleCellExperiment Object.")

-  }

-  if(!useAssay %in% SummarizedExperiment::assayNames(inSCE)) {

-    stop(paste("\"useAssay\" (assay) name: ", useAssay, " not found."))

-  }

-  if(!batch %in% names(SummarizedExperiment::colData(inSCE))){

-    stop(paste("\"batch\" name:", batch, "not found."))

-  }

-

+  useMat <- .selectSCEMatrix(inSCE, useAssay = useAssay, returnMatrix = TRUE)

+  mat <- useMat$mat

+  batchVec <- .manageCellVar(inSCE, batch, as.factor = TRUE)

   assayName <- gsub(' ', '_', assayName)

-

   ## Run algorithm

   ## One more check for the batch names

-  batchCol <- SummarizedExperiment::colData(inSCE)[[batch]]

-  mat <- SummarizedExperiment::assay(inSCE, useAssay)

-  newMat <- limma::removeBatchEffect(mat, batch = batchCol)

+  newMat <- limma::removeBatchEffect(mat, batch = batchVec)

   expData(inSCE, assayName, tag = "batchCorrected", altExp = FALSE) <- newMat

-  #SummarizedExperiment::assay(inSCE, assayName) <- newMat

   S4Vectors::metadata(inSCE)$batchCorr[[assayName]] <- list(useAssay = useAssay,

                                                             origLogged = TRUE,

                                                             method = "Limma",

@@ -482,57 +477,61 @@ runLimmaBC <- function(inSCE, useAssay = "logcounts", assayName = "LIMMA",

 #' does so by identifying pairs of MNN in the high-dimensional log-expression

 #' space. For each MNN pair, a pairwise correction vector is computed by

 #' applying a Gaussian smoothing kernel with bandwidth `sigma`.

-#' @param inSCE \linkS4class{SingleCellExperiment} inherited object. Required.

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

 #' @param useAssay A single character indicating the name of the assay requiring

 #' batch correction. Default \code{"logcounts"}.

-#' @param batch A single character indicating a field in

-#' \code{\link{colData}} that annotates the batches.

-#' Default \code{"batch"}.

-#' @param k An integer. Specifies the number of nearest neighbours to

-#' consider when defining MNN pairs. This should be interpreted as the minimum

-#' frequency of each cell type or state in each batch. Larger values will

-#' improve the precision of the correction by increasing the number of MNN

-#' pairs, at the cost of reducing accuracy by allowing MNN pairs to form between

-#' cells of different type. Default \code{20L}.

-#' @param sigma A Numeric scalar. Specifies how much information is

-#' shared between MNN pairs when computing the batch effect. Larger values will

-#' share more information, approaching a global correction for all cells in the

-#' same batch. Smaller values allow the correction to vary across cell types,

-#' which may be more accurate but comes at the cost of precision. Default

-#' \code{0.1}.

+#' @param batch A single character indicating a field in \code{colData} that

+#' annotates the batches of each cell; or a vector/factor with the same length

+#' as the number of cells. Default \code{"batch"}.

 #' @param assayName A single characeter. The name for the corrected assay. Will

 #' be saved to \code{\link{assay}}. Default

 #' \code{"MNN"}.

+#' @param k An integer scalar specifying the number of nearest neighbors to

+#' consider when identifying MNNs. See "See Also". Default \code{20}.

+#' @param propK A numeric scalar in (0, 1) specifying the proportion of cells in

+#' each dataset to use for mutual nearest neighbor searching. See "See Also".

+#' Default \code{NULL}.

+#' @param sigma A numeric scalar specifying the bandwidth of the Gaussian

+#' smoothing kernel used to compute the correction vector for each cell. See

+#' "See Also". Default \code{0.1}.

+#' @param cosNormIn A logical scalar indicating whether cosine normalization

+#' should be performed on the input data prior to calculating distances between

+#' cells. See "See Also". Default \code{TRUE}.

+#' @param cosNormOut A logical scalar indicating whether cosine normalization

+#' should be performed prior to computing corrected expression values. See "See

+#' Also". Default \code{TRUE}.

+#' @param varAdj A logical scalar indicating whether variance adjustment should

+#' be performed on the correction vectors. See "See Also". Default \code{TRUE}.

+#' @param BPPARAM A \linkS4class{BiocParallelParam} object specifying whether

+#' the PCA and nearest-neighbor searches should be parallelized.

 #' @return The input \linkS4class{SingleCellExperiment} object with

 #' \code{assay(inSCE, assayName)} updated.

+#' @seealso \code{\link[batchelor]{mnnCorrect}}

 #' @export

-#' @references Lun ATL, et al., 2016 & 2018

+#' @references Haghverdi L, Lun ATL, et. al., 2018

 #' @examples

 #' data('sceBatches', package = 'singleCellTK')

-#' logcounts(sceBatches) <- log(counts(sceBatches) + 1)

+#' logcounts(sceBatches) <- log1p(counts(sceBatches))

 #' sceCorr <- runMNNCorrect(sceBatches)

 runMNNCorrect <- function(inSCE, useAssay = 'logcounts', batch = 'batch',

-                          assayName = 'MNN', k = 20L, sigma = 0.1){

+                          assayName = 'MNN', k = 20L, propK = NULL,

+                          sigma = 0.1, cosNormIn = TRUE, cosNormOut = TRUE,

+                          varAdj = TRUE, BPPARAM = BiocParallel::SerialParam()){

   ## Input check

-  if(!inherits(inSCE, "SingleCellExperiment")){

-    stop("\"inSCE\" should be a SingleCellExperiment Object.")

-  }

-  if(!useAssay %in% SummarizedExperiment::assayNames(inSCE)) {

-    stop(paste("\"useAssay\" (assay) name: ", useAssay, " not found."))

-  }

-  if(!batch %in% names(SummarizedExperiment::colData(inSCE))){

-    stop(paste("\"batch name:", batch, "not found."))

-  }

+  useMat <- .selectSCEMatrix(inSCE, useAssay = useAssay, returnMatrix = TRUE)

+  mat <- useMat$mat

+  batchVec <- .manageCellVar(inSCE, batch, as.factor = TRUE)

   assayName <- gsub(' ', '_', assayName)

   k <- as.integer(k)

   ## Run algorithm

-  batchCol <- SummarizedExperiment::colData(inSCE)[[batch]]

-  batchFactor <- as.factor(batchCol)

-  mnnSCE <- batchelor::mnnCorrect(inSCE, assay.type = useAssay,

-                                  batch = batchFactor, k = k, sigma = sigma)

-  corrected <- SummarizedExperiment::assay(mnnSCE, 'corrected')

-  expData(inSCE, assayName, tag = "batchCorrected", altExp = FALSE) <- corrected

+  corr.sce <- batchelor::mnnCorrect(mat, batch = batchVec, k = k,

+                                    prop.k = propK, sigma = sigma,

+                                    cos.norm.in = cosNormIn,

+                                    cos.norm.out = cosNormOut, var.adj = varAdj,

+                                    BPPARAM = BPPARAM)

+  expData(inSCE, assayName, tag = "batchCorrected", altExp = FALSE) <-

+    SummarizedExperiment::assay(corr.sce, "corrected")

   S4Vectors::metadata(inSCE)$batchCorr[[assayName]] <- list(useAssay = useAssay,

                                                             origLogged = TRUE,

                                                             method = "MNN",

@@ -547,22 +546,24 @@ runMNNCorrect <- function(inSCE, useAssay = 'logcounts', batch = 'batch',

 #' SCANORAMA is analogous to computer vision algorithms for panorama stitching

 #' that identify images with overlapping content and merge these into a larger

 #' panorama.

-#' @param inSCE \linkS4class{SingleCellExperiment} inherited object. Required.

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

 #' @param useAssay A single character indicating the name of the assay requiring

 #' batch correction. Scanorama requires a transformed normalized expression

 #' assay. Default \code{"logcounts"}.

-#' @param batch A single character indicating a field in

-#' \code{\link{colData}} that annotates the batches.

-#' Default \code{"batch"}.

+#' @param batch A single character indicating a field in \code{colData} that

+#' annotates the batches of each cell; or a vector/factor with the same length

+#' as the number of cells. Default \code{"batch"}.

+#' @param assayName A single characeter. The name for the corrected assay. Will

+#' be saved to \code{\link{assay}}. Default

+#' \code{"SCANORAMA"}.

 #' @param SIGMA A numeric scalar. Algorithmic parameter, correction smoothing

 #' parameter on Gaussian kernel. Default \code{15}.

 #' @param ALPHA A numeric scalar. Algorithmic parameter, alignment score

 #' minimum cutoff. Default \code{0.1}.

 #' @param KNN An integer. Algorithmic parameter, number of nearest neighbors to

-#' use for matching. Default \code{20L}.

-#' @param assayName A single characeter. The name for the corrected assay. Will

-#' be saved to \code{\link{assay}}. Default

-#' \code{"SCANORAMA"}.

+#' use for matching. Default \code{20}.

+#' @param approx Boolean. Use approximate nearest neighbors, greatly speeds up

+#' matching runtime. Default \code{TRUE}.

 #' @return The input \linkS4class{SingleCellExperiment} object with

 #' \code{assay(inSCE, assayName)} updated.

 #' @export

@@ -570,16 +571,13 @@ runMNNCorrect <- function(inSCE, useAssay = 'logcounts', batch = 'batch',

 #' @examples

 #' \dontrun{

 #' data('sceBatches', package = 'singleCellTK')

-#' sceBatches <- scaterlogNormCounts(sceBatches)

+#' logcounts(sceBatches) <- log1p(counts(sceBatches))

 #' sceCorr <- runSCANORAMA(sceBatches, "ScaterLogNormCounts")

 #' }

 runSCANORAMA <- function(inSCE, useAssay = 'logcounts', batch = 'batch',

-                         SIGMA = 15, ALPHA = 0.1, KNN = 20L,

-                         assayName = 'SCANORAMA'){

+                         assayName = 'SCANORAMA', SIGMA = 15, ALPHA = 0.1,

+                         KNN = 20, approx = TRUE){

   ## Input check

-  if(!inherits(inSCE, "SingleCellExperiment")){

-    stop("\"inSCE\" should be a SingleCellExperiment Object.")

-  }

   if(!reticulate::py_module_available(module = "scanorama")){

     warning("Cannot find python module 'scanorama', please install Conda and",

             " run sctkPythonInstallConda() or run ",

@@ -593,31 +591,27 @@ runSCANORAMA <- function(inSCE, useAssay = 'logcounts', batch = 'batch',

             " to select the correct Python environment.")

     return(inSCE)

   }

-  if(!useAssay %in% SummarizedExperiment::assayNames(inSCE)) {

-    stop(paste("\"useAssay\" (assay) name: ", useAssay, " not found"))

-  }

-  if(!batch %in% names(SummarizedExperiment::colData(inSCE))){

-    stop(paste("\"batch\" name:", batch, "not found"))

-  }

+  useMat <- .selectSCEMatrix(inSCE, useAssay = useAssay)

+  batchVec <- .manageCellVar(inSCE, batch)

   assayName <- gsub(' ', '_', assayName)

   adata <- .sce2adata(inSCE, useAssay)

+  adata$obs[["batch"]] <- batchVec

   py <- reticulate::py

   py$adata <- adata

-  py$batch <- batch

   py$sigma <- SIGMA

   py$alpha <- ALPHA

   py$KNN <- as.integer(KNN)

   reticulate::py_run_string('

 import numpy as np

 import scanorama

-batches = list(set(adata.obs[batch]))

-adatas = [adata[adata.obs[batch] == b,] for b in batches]

-datasets_full = [a.X.toarray() for a in adatas]

+batches = list(set(adata.obs["batch"]))

+adatas = [adata[adata.obs["batch"] == b,] for b in batches]

+datasets_full = [a.X for a in adatas]

 genes_list = [a.var_names.to_list() for a in adatas]

 corrected, genes = scanorama.correct(datasets_full, genes_list, sigma=sigma,

                                      alpha=alpha, knn=KNN)

 corrected = [m.toarray() for m in corrected]

-cellOrders = [adata.obs[batch] == b for b in batches]

+cellOrders = [adata.obs["batch"] == b for b in batches]

 integrated = np.zeros(adata.shape)

 integrated[:,:] = np.NAN

 for i in range(len(batches)):

@@ -632,6 +626,9 @@ integrated = integrated[:, orderIdx]

   rownames(mat) <- rownames(inSCE)

   colnames(mat) <- colnames(inSCE)

   expData(inSCE, assayName, tag = "batchCorrected", altExp = FALSE) <- mat

+  S4Vectors::metadata(inSCE)$batchCorr[[assayName]] <-

+    list(useAssay = useAssay,  origLogged = TRUE, method = "Scanorama",

+         matType = "assay", batch = batch)

   return(inSCE)

 }

@@ -640,12 +637,16 @@ integrated = integrated[:, orderIdx]

 #' The scMerge method leverages factor analysis, stably expressed genes (SEGs)

 #' and (pseudo-) replicates to remove unwanted variations and merge multiple

 #' scRNA-Seq data.

-#' @param inSCE \linkS4class{SingleCellExperiment} inherited object. Required.

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

 #' @param useAssay A single character indicating the name of the assay requiring

 #' batch correction. Default \code{"logcounts"}.

 #' @param batch A single character indicating a field in

 #' \code{\link{colData}} that annotates the batches.

 #' Default \code{"batch"}.

+#' @param assayName A single characeter. The name for the corrected assay. Will

+#' be saved to \code{\link{assay}}. Default \code{"scMerge"}.

+#' @param hvgExprs A single characeter. The assay that to be used for highly

+#' variable genes identification. Default \code{"counts"}.

 #' @param kmeansK An integer vector. Indicating the kmeans' K-value for each

 #' batch (i.e. how many subclusters in each batch should exist), in order to

 #' construct pseudo-replicates. The length of code{kmeansK} needs to be the same

@@ -656,14 +657,12 @@ integrated = integrated[:, orderIdx]

 #' \code{'cell_type'}.

 #' @param seg A vector of gene names or indices that specifies SEG (Stably