deleted file mode 100755

@@ -1,1154 +0,0 @@

-#' @title Celda models

-#' @description List of available Celda models with correpsonding descriptions.

-#' @export

-#' @examples

-#' celda()

-#' @return None

-celda <- function() {

-    message(

-        "celda_C: Clusters the columns of a count matrix containing",

-        " single-cell data into K subpopulations."

-    )

-    message(

-        "celda_G: Clusters the rows of a count matrix containing",

-        " single-cell data into L modules."

-    )

-    message(

-        "celda_CG: Clusters the rows and columns of a count matrix",

-        " containing single-cell data into L modules and K subpopulations,",

-        " respectively."

-    )

-    message(

-        "celdaGridSearch: Run Celda with different combinations of",

-        " parameters and multiple chains in parallel."

-    )

-}

-

-

-#' @title Get log-likelihood history

-#' @description Retrieves the complete log-likelihood from all iterations of

-#'  Gibbs sampling used to generate a celdaModel.

-#' @param celdaMod celdaModel. Options available in `celda::availableModels`.

-#' @return Numeric. The log-likelihood at each step of Gibbs sampling used to

-#'  generate the model.

-#' @examples

-#' data(celdaCGMod)

-#' logLikelihoodHistory(celdaCGMod)

-#' @export

-setGeneric(

-  "logLikelihoodHistory",

-  function(celdaMod) {

-    standardGeneric("logLikelihoodHistory")

-  }

-)

-#' @title Get log-likelihood history

-#' @description Retrieves the complete log-likelihood from all iterations of

-#'  Gibbs sampling used to generate a celdaModel.

-#' @param celdaMod celdaModel. Options available in `celda::availableModels`.

-#' @return Numeric. The log-likelihood at each step of Gibbs sampling used to

-#'  generate the model.

-#' @examples

-#' data(celdaCGMod)

-#' logLikelihoodHistory(celdaCGMod)

-#' @export

-setMethod("logLikelihoodHistory",

-  signature = c(celdaMod = "celdaModel"),

-  function(celdaMod) {

-    celdaMod@completeLogLik

-  }

-)

-

-

-#' @title Get the log-likelihood

-#' @description Retrieves the final log-likelihood from all iterations of Gibbs

-#'  sampling used to generate a celdaModel.

-#' @return Numeric. The log-likelihood at the final step of Gibbs sampling used

-#'  to generate the model.

-#' @param celdaMod A celdaModel object of class celda_C, celda_G, or celda_CG.

-#' @examples

-#' data(celdaCGMod)

-#' bestLogLikelihood(celdaCGMod)

-#' @export

-setGeneric(

-  "bestLogLikelihood",

-  function(celdaMod) {

-    standardGeneric("bestLogLikelihood")

-  }

-)

-#' @title Get the log-likelihood

-#' @description Retrieves the final log-likelihood from all iterations of Gibbs

-#'  sampling used to generate a celdaModel.

-#' @param celdaMod A celdaModel object of class celda_C, celda_G, or celda_CG.

-#' @return Numeric. The log-likelihood at the final step of Gibbs sampling used

-#'  to generate the model.

-#' @examples

-#' data(celdaCGMod)

-#' bestLogLikelihood(celdaCGMod)

-#' @export

-setMethod("bestLogLikelihood",

-  signature = c(celdaMod = "celdaModel"),

-  function(celdaMod) {

-    celdaMod@finalLogLik

-  }

-)

-

-

-setClass("celda_C",

-  representation(sampleLabel = "factor"),

-  contains = "celdaModel"

-)

-

-

-#' @title Get celda model from a celda

-#'  \link[SingleCellExperiment]{SingleCellExperiment} object

-#' @description Return the celda model for \code{sce} returned by

-#'  \link{celda_C}, \link{celda_G} or \link{celda_CG}.

-#' @param sce A \link[SingleCellExperiment]{SingleCellExperiment} object

-#'  returned by \link{celda_C}, \link{celda_G}, or \link{celda_CG}.

-#' @return Character. The celda model. Can be one of "celda_C", "celda_G", or

-#'  "celda_CG".

-#' @examples

-#' data(sceCeldaCG)

-#' celdaModel(sceCeldaCG)

-#' @export

-setGeneric("celdaModel",

-    function(sce) {

-        standardGeneric("celdaModel")

-    })

-#' @rdname celdaModel

-#' @export

-setMethod("celdaModel",

-    signature(sce = "SingleCellExperiment"),

-    function(sce) {

-        tryCatch(

-            if (S4Vectors::metadata(sce)$celda_parameters$model %in%

-                    c("celda_C", "celda_G", "celda_CG")) {

-                return(S4Vectors::metadata(sce)$celda_parameters$model)

-            } else {

-                stop("S4Vectors::metadata(sce)$celda_parameters$model must be",

-                    " one of 'celda_C', 'celda_G', or 'celda_CG'")

-            },

-            error = function(e) {

-                message("S4Vectors::metadata(sce)$celda_parameters$model must",

-                    " exist! Try running celda model (celda_C, celda_CG, or",

-                    " celda_G) first.")

-                stop(e)

-            })

-    })

-setClass("celda_G", contains = "celdaModel")

-

-setClass("celda_CG", contains = c("celda_C", "celda_G"))

-

-

-#' @title Get perplexity for every model in a celdaList

-#' @description Returns perplexity for each model in a celdaList as calculated

-#'  by `perplexity().`

-#' @param celdaList An object of class celdaList.

-#' @return List. Contains one celdaModel object for each of the parameters

-#'  specified in the `runParams()` of the provided celda list.

-#' @examples

-#' data(celdaCGGridSearchRes)

-#' celdaCGGridModelPerplexities <- celdaPerplexity(celdaCGGridSearchRes)

-#' @export

-setGeneric(

-  "celdaPerplexity",

-  function(celdaList) {

-    standardGeneric("celdaPerplexity")

-  }

-)

-#' @title Get perplexity for every model in a celdaList

-#' @description Returns perplexity for each model in a celdaList as calculated

-#'  by `perplexity().`

-#' @param celdaList An object of class celdaList.

-#' @return List. Contains one celdaModel object for each of the parameters

-#'  specified in the `runParams()` of the provided celda list.

-#' @examples

-#' data(celdaCGGridSearchRes)

-#' celdaCGGridModelPerplexities <- celdaPerplexity(celdaCGGridSearchRes)

-#' @export

-setMethod("celdaPerplexity",

-  signature = c(celdaList = "celdaList"),

-  function(celdaList) {

-    celdaList@perplexity

-  }

-)

-

-

-#' @title Append two celdaList objects

-#' @description Returns a single celdaList representing the combination of two

-#'  provided celdaList objects.

-#' @return A celdaList object. This object contains all resList entries and

-#'  runParam records from both lists.

-#' @param list1 A celda_list object

-#' @param list2 A celda_list object to be joined with list_1

-#' @examples

-#' data(celdaCGGridSearchRes)

-#' appendedList <- appendCeldaList(

-#'   celdaCGGridSearchRes,

-#'   celdaCGGridSearchRes

-#' )

-#' @importFrom methods new

-#' @export

-appendCeldaList <- function(list1, list2) {

-  if (!is.element("celdaList", class(list1)) |

-    !is.element("celdaList", class(list2))) {

-    stop("Both parameters to appendCeldaList must be of class celdaList.")

-  }

-  if (!(countChecksum(list1) == countChecksum(list2))) {

-    warning(

-      "Provided lists have different countChecksums and may have",

-      " been generated from different count matrices. Using checksum",

-      " from first list..."

-    )

-  }

-  newList <- methods::new(

-    "celdaList",

-    runParams = rbind(runParams(list1), runParams(list2)),

-    resList = c(resList(list1), resList(list2)),

-    countChecksum = countChecksum(list1),

-    perplexity = matrix(nrow = 0, ncol = 0)

-  )

-  return(newList)

-}

-

-

-#' @title Get the MD5 hash of the count matrix from the celdaList

-#' @description Returns the MD5 hash of the count matrix used to generate the

-#'  celdaList.

-#' @param celdaList An object of class celdaList.

-#' @return A character string of length 32 containing the MD5 digest of

-#'  the count matrix.

-#' @examples

-#' data(celdaCGGridSearchRes)

-#' countChecksum <- countChecksum(celdaCGGridSearchRes)

-#' @export

-setGeneric(

-  "countChecksum",

-  function(celdaList) {

-    standardGeneric("countChecksum")

-  }

-)

-#' @title Get the MD5 hash of the count matrix from the celdaList

-#' @description Returns the MD5 hash of the count matrix used to generate the

-#'  celdaList.

-#' @param celdaList An object of class celdaList.

-#' @return A character string of length 32 containing the MD5 digest of

-#'  the count matrix.

-#' @examples

-#' data(celdaCGGridSearchRes)

-#' countChecksum <- countChecksum(celdaCGGridSearchRes)

-#' @export

-setMethod("countChecksum",

-  signature = c(celdaList = "celdaList"),

-  function(celdaList) {

-    celdaList@countChecksum

-  }

-)

-

-###############################################################################

-# Generics

-###############################################################################

-

-

-#' @title Plot celda Heatmap

-#' @description Render a stylable heatmap of count data based on celda

-#'  clustering results.

-#' @param sce A \link[SingleCellExperiment]{SingleCellExperiment} object

-#'  returned by \link{celda_C}, \link{celda_G}, or \link{celda_CG}.

-#' @param useAssay A string specifying which \link[SummarizedExperiment]{assay}

-#'  slot to use. Default "counts".

-#' @param featureIx Integer vector. Select features for display in heatmap. If

-#'  NULL, no subsetting will be performed. Default NULL. \strong{Only used for

-#'  \code{sce} containing celda_C model result returned by \link{celda_C}.}

-#' @param nfeatures Integer. Maximum number of features to select for each

-#'  gene module. Default 25. \strong{Only used for \code{sce} containing

-#'  celda_CG or celda_G model results returned by \link{celda_CG} or

-#'  \link{celda_G}.}

-#' @param ... Additional parameters passed to \link{plotHeatmap}.

-#' @seealso `celdaTsne()` for generating 2-dimensional tSNE coordinates

-#' @examples

-#' data(sceCeldaCG)

-#' celdaHeatmap(sceCeldaCG)

-#' @return list A list containing dendrogram information and the heatmap grob

-#' @export

-setGeneric("celdaHeatmap",

-    function(sce, ...) {

-        standardGeneric("celdaHeatmap")

-    })

-

-

-#' @export

-#' @rdname celdaHeatmap

-setMethod("celdaHeatmap", signature(sce = "SingleCellExperiment"),

-    function(sce, useAssay = "counts", featureIx = NULL, nfeatures = 25, ...) {

-        if (celdaModel(sce) == "celda_C") {

-            g <- .celdaHeatmapCelda_C(sce = sce,

-                useAssay = useAssay,

-                featureIx = featureIx,

-                ...)

-            return(g)

-        } else if (celdaModel(sce) == "celda_CG") {

-            g <- .celdaHeatmapCelda_CG(sce = sce,

-                useAssay = useAssay,

-                nfeatures = nfeatures,

-                ...)

-            return(g)

-        } else if (celdaModel(sce) == "celda_G") {

-            g <- .celdaHeatmapCelda_G(sce = sce,

-                useAssay = useAssay,

-                nfeatures = nfeatures,

-                ...)

-            return(g)

-        } else {

-            stop("S4Vectors::metadata(sce)$celda_parameters$model must be",

-                " one of 'celda_C', 'celda_G', or 'celda_CG'")

-        }

-    })

-

-

-#' @title Calculate the Log-likelihood of a celda model

-#' @description Calculate the log-likelihood for cell population

-#'  and feature module cluster assignments on the count matrix, per celda model.

-#' @param x A \linkS4class{SingleCellExperiment} object returned by

-#'  \link{celda_C}, \link{celda_G}, or \link{celda_CG}, with the matrix

-#'  located in the \code{useAssay} assay slot.

-#'  Rows represent features and columns represent cells.

-#' @param useAssay A string specifying which \link[SummarizedExperiment]{assay}

-#'  slot to use. Default "counts".

-#' @param celdaMod celda model object. Ignored if \code{x} is a

-#'  \linkS4class{SingleCellExperiment} object.

-#' @return The log-likelihood of the cluster assignment for the

-#'  provided \linkS4class{SingleCellExperiment}.

-#' @seealso `celda_C()` for clustering cells

-#' @export

-setGeneric("logLikelihood",

-    function(x, ...) {

-        standardGeneric("logLikelihood")

-    })

-

-

-#' @rdname logLikelihood

-#' @examples

-#' data(sceCeldaC, sceCeldaCG)

-#' loglikC <- logLikelihood(sceCeldaC)

-#' loglikCG <- logLikelihood(sceCeldaCG)

-#' @export

-setMethod("logLikelihood", signature(x = "SingleCellExperiment"),

-    function(x, useAssay = "counts") {

-

-        counts <- SummarizedExperiment::assay(x, i = useAssay)

-        sampleLabel <- sampleLabel(x)

-        z <- celdaClusters(x)

-        y <- celdaModules(x)

-        K <- S4Vectors::metadata(x)$celda_parameters$K

-        L <- S4Vectors::metadata(x)$celda_parameters$L

-        alpha <- S4Vectors::metadata(x)$celda_parameters$alpha

-        beta <- S4Vectors::metadata(x)$celda_parameters$beta

-        delta = S4Vectors::metadata(x)$celda_parameters$delta

-        gamma = S4Vectors::metadata(x)$celda_parameters$gamma

-

-        if (celdaModel(x) == "celda_C") {

-            ll <- .logLikelihoodcelda_C(counts = counts,

-                sampleLabel = sampleLabel,

-                z = z,

-                K = K,

-                alpha = alpha,

-                beta = beta)

-        } else if (celdaModel(x) == "celda_CG") {

-            ll <- .logLikelihoodcelda_CG(counts = counts,

-                sampleLabel = sampleLabel,

-                z = z,

-                y = y,

-                K = K,

-                L = L,

-                alpha = alpha,

-                beta = beta,

-                delta = delta,

-                gamma = gamma)

-        } else if (celdaModel(x) == "celda_G") {

-            ll <- .logLikelihoodcelda_G(counts = counts,

-                y = y,

-                L = L,

-                beta = beta,

-                delta = delta,

-                gamma = gamma)

-        } else {

-            stop("S4Vectors::metadata(x)$celda_parameters$model must be",

-                " one of 'celda_C', 'celda_G', or 'celda_CG'!")

-        }

-        return(ll)

-    }

-)

-

-

-#' @rdname logLikelihood

-#' @export

-setMethod("logLikelihood", signature(x = "matrix", celdaMod = "celda_C"),

-    function(x, celdaMod) {

-        sampleLabel <- sampleLabel(celdaMod)

-        z = celdaClusters(celdaMod)$z

-        K = params(celdaMod)$K

-        alpha = params(celdaMod)$alpha

-        beta = params(celdaMod)$beta

-

-        ll <- .logLikelihoodcelda_C(counts = x,

-            sampleLabel = sampleLabel,

-            z = z,

-            K = K,

-            alpha = alpha,

-            beta = beta)

-        return(ll)

-    }

-)

-

-

-#' @rdname logLikelihood

-#' @export

-setMethod("logLikelihood", signature(x = "matrix", celdaMod = "celda_G"),

-    function(x, celdaMod) {

-        y <- celdaClusters(celdaMod)$y

-        L <- params(celdaMod)$L

-        beta = params(celdaMod)$beta

-        delta = params(celdaMod)$delta

-        gamma = params(celdaMod)$gamma

-

-        ll <- .logLikelihoodcelda_G(counts = x,

-            y = y,

-            L = L,

-            beta = beta,

-            delta = delta,

-            gamma = gamma)

-        return(ll)

-    }

-)

-

-

-#' @rdname logLikelihood

-#' @export

-setMethod("logLikelihood", signature(x = "matrix", celdaMod = "celda_CG"),

-    function(x, celdaMod) {

-        sampleLabel <- sampleLabel(celdaMod)

-        z <- celdaClusters(celdaMod)$z

-        y <- celdaClusters(celdaMod)$y

-        K <- params(celdaMod)$K

-        L <- params(celdaMod)$L

-        alpha = params(celdaMod)$alpha

-        beta = params(celdaMod)$beta

-        delta = params(celdaMod)$delta

-        gamma = params(celdaMod)$gamma

-

-        ll <- .logLikelihoodcelda_CG(counts = x,

-            sampleLabel = sampleLabel,

-            z = z,

-            y = y,

-            K = K,

-            L = L,

-            alpha = alpha,

-            beta = beta,

-            delta = delta,

-            gamma = gamma)

-        return(ll)

-    }

-)

-

-

-#' @title Get the conditional probabilities of cell in subpopulations from celda

-#'  model

-#' @description Calculate the conditional probability of each cell belonging to

-#'  each subpopulation given all other cell cluster assignments and/or

-#'  each feature belonging to each module given all other feature cluster

-#'  assignments in a celda model.

-#' @param sce A \linkS4class{SingleCellExperiment} object returned by

-#'  \link{celda_C}, \link{celda_G}, or \link{celda_CG}, with the matrix

-#'  located in the \code{useAssay} assay slot.

-#'  Rows represent features and columns represent cells.

-#' @param useAssay A string specifying which \link[SummarizedExperiment]{assay}

-#'  slot to use. Default "counts".

-#' @param log Logical. If \code{FALSE}, then the normalized conditional

-#'  probabilities will be returned. If \code{TRUE}, then the unnormalized log

-#'  probabilities will be returned. Default \code{FALSE}.

-#' @examples

-#' data(sceCeldaCG)

-#' clusterProb <- clusterProbability(sceCeldaCG, log = TRUE)

-#' @return A list containging a matrix for the conditional cell subpopulation

-#'  cluster and/or feature module probabilities.

-#' @export

-setGeneric("clusterProbability",

-    function(sce, ...) {

-        standardGeneric("clusterProbability")

-    })

-

-

-#' @seealso `celda_C()` for clustering cells

-#' @examples

-#' data(sceCeldaC)

-#' clusterProb <- clusterProbability(sceCeldaC)

-#' @rdname clusterProbability

-#' @export

-setMethod("clusterProbability", signature(sce = "SingleCellExperiment"),

-    function(sce, useAssay = "counts", log = FALSE) {

-

-        if (celdaModel(sce) == "celda_C") {

-            cp <- .clusterProbabilityCeldaC(sce = sce,

-                useAssay = useAssay,

-                log = log)

-            return(cp)

-        } else if (celdaModel(sce) == "celda_CG") {

-            cp <- .clusterProbabilityCeldaCG(sce = sce,

-                useAssay = useAssay,

-                log = log)

-            return(cp)

-        } else if (celdaModel(sce) == "celda_G") {

-            cp <- .clusterProbabilityCeldaG(sce = sce,

-                useAssay = useAssay,

-                log = log)

-            return(cp)

-        } else {

-            stop("S4Vectors::metadata(sce)$celda_parameters$model must be",

-                " one of 'celda_C', 'celda_G', or 'celda_CG'!")

-        }

-    })

-

-

-#' @title Simulate count data from the celda generative models.

-#' @description This function generates a \linkS4class{SingleCellExperiment}

-#'  containing a simulated counts matrix in the \code{"counts"} assay slot, as

-#'  well as various parameters used in the simulation which can be

-#'  useful for running celda and are stored in \code{metadata} slot. The user

-#'  must provide the desired model (one of celda_C, celda_G, celda_CG) as well

-#'  as any desired tuning parameters for those model's simulation functions

-#'  as detailed below.

-#' @param model Character. Options available in \code{celda::availableModels}.

-#'  Can be one of \code{"celda_CG"}, \code{"celda_C"}, or \code{"celda_G"}.

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

-#' @param S Integer. Number of samples to simulate. Default 5. Only used if

-#'  \code{model} is one of \code{"celda_CG"} or \code{"celda_C"}.

-#' @param CRange Integer vector. A vector of length 2 that specifies the lower

-#'  and upper bounds of the number of cells to be generated in each sample.

-#'  Default c(50, 100). Only used if

-#'  \code{model} is one of \code{"celda_CG"} or \code{"celda_C"}.

-#' @param NRange Integer vector. A vector of length 2 that specifies the lower

-#'  and upper bounds of the number of counts generated for each cell. Default

-#'  c(500, 1000).

-#' @param C Integer. Number of cells to simulate. Default 100. Only used if

-#'  \code{model} is \code{"celda_G"}.

-#' @param G Integer. The total number of features to be simulated. Default 100.

-#' @param K Integer. Number of cell populations. Default 5. Only used if

-#'  \code{model} is one of \code{"celda_CG"} or \code{"celda_C"}.

-#' @param L Integer. Number of feature modules. Default 10. Only used if

-#'  \code{model} is one of \code{"celda_CG"} or \code{"celda_G"}.

-#' @param alpha Numeric. Concentration parameter for Theta. Adds a pseudocount

-#'  to each cell population in each sample. Default 1. Only used if

-#'  \code{model} is one of \code{"celda_CG"} or \code{"celda_C"}.

-#' @param beta Numeric. Concentration parameter for Phi. Adds a pseudocount to

-#'  each feature module in each cell population. Default 1.

-#' @param gamma Numeric. Concentration parameter for Eta. Adds a pseudocount to

-#'  the number of features in each module. Default 5. Only used if

-#'  \code{model} is one of \code{"celda_CG"} or \code{"celda_G"}.

-#' @param delta Numeric. Concentration parameter for Psi. Adds a pseudocount to

-#'  each feature in each module. Default 1. Only used if

-#'  \code{model} is one of \code{"celda_CG"} or \code{"celda_G"}.

-#' @param seed Integer. Passed to \link[withr]{with_seed}. For reproducibility,

-#'  a default value of 12345 is used. If NULL, no calls to

-#'  \link[withr]{with_seed} are made.

-#' @return A \link[SingleCellExperiment]{SingleCellExperiment} object with

-#'  simulated count matrix stored in the "counts" assay slot. Function

-#'  parameter settings are stored in the \link[S4Vectors]{metadata} slot. For

-#'  \code{"celda_CG"} and \code{"celda_C"} models,

-#'  columns \code{celda_sample_label} and \code{celda_cell_cluster} in

-#'  \link[SummarizedExperiment]{colData} contain simulated sample labels and

-#'  cell population clusters. For \code{"celda_CG"} and \code{"celda_G"}

-#'  models, column \code{celda_feature_module} in

-#'  \link[SummarizedExperiment]{rowData} contains simulated gene modules.

-#' @examples

-#' sce <- simulateCells()

-#' @export

-simulateCells <- function(

-    model = c("celda_CG", "celda_C", "celda_G"),

-    S = 5,

-    CRange = c(50, 100),

-    NRange = c(500, 1000),

-    C = 100,

-    G = 100,

-    K = 5,

-    L = 10,

-    alpha = 1,

-    beta = 1,

-    gamma = 5,

-    delta = 1,

-    seed = 12345) {

-

-    model <- match.arg(model)

-

-    if (model == "celda_C") {

-        sce <- .simulateCellsMaincelda_C(model = model,

-            S = S,

-            CRange = CRange,

-            NRange = NRange,

-            G = G,

-            K = K,

-            alpha = alpha,

-            beta = beta,

-            seed = seed)

-    } else if (model == "celda_CG") {

-        sce <- .simulateCellsMaincelda_CG(

-            model = model,

-            S = S,

-            CRange = CRange,

-            NRange = NRange,

-            G = G,

-            K = K,

-            L = L,

-            alpha = alpha,

-            beta = beta,

-            gamma = gamma,

-            delta = delta,

-            seed = seed)

-    } else if (model == "celda_G") {

-        sce <- .simulateCellsMaincelda_G(

-            model = model,

-            C = C,

-            L = L,

-            NRange = NRange,

-            G = G,

-            beta = beta,

-            delta = delta,

-            gamma = gamma,

-            seed = seed)

-    } else {

-        stop("'model' must be one of 'celda_C', 'celda_G', or 'celda_CG'")

-    }

-

-    return(sce)

-}

-

-

-#' @title Renders probability and relative expression heatmaps to visualize the

-#'  relationship between feature modules and cell populations.

-#' @description It is often useful to visualize to what degree each feature

-#' influences each cell cluster. This can also be useful for identifying

-#' features which may be redundant or unassociated with cell clustering.

-#' @param counts Integer matrix. Rows represent features and columns represent

-#'  cells. This matrix should be the same as the one used to generate

-#'  `celdaMod`.

-#' @param celdaMod Celda object of class "celda_C" or "celda_CG".

-#' @param ... Additional parameters.

-#' @examples

-#' data(celdaCGSim, celdaCGMod)

-#' celdaProbabilityMap(celdaCGSim$counts, celdaCGMod)

-#' @return A grob containing the specified plots

-#' @export

-setGeneric("celdaProbabilityMap",

-  signature = "celdaMod",

-  function(counts, celdaMod, ...) {

-    standardGeneric("celdaProbabilityMap")

-  }

-)

-

-

-#' @title Embeds cells in two dimensions using tSNE based on celda_CG results.

-#' @param counts Integer matrix. Rows represent features and columns represent

-#'  cells. This matrix should be the same as the one used to generate

-#'  `celdaMod`.

-#' @param celdaMod Celda object of class `celda_CG`.

-#' @param maxCells Integer. Maximum number of cells to plot. Cells will be

-#'  randomly subsampled if ncol(counts) > maxCells. Larger numbers of cells

-#'  requires more memory. Default \code{25000}.

-#' @param minClusterSize Integer. Do not subsample cell clusters below this

-#'  threshold. Default \code{100}.

-#' @param initialDims integer. The number of dimensions that should be retained

-#'  in the initial PCA step. Default \code{20}.

-#' @param modules Integer vector. Determines which features modules to use for

-#'  tSNE. If NULL, all modules will be used. Default NULL.

-#' @param perplexity Numeric. Perplexity parameter for tSNE. Default \code{20}.

-#' @param maxIter Integer. Maximum number of iterations in tSNE generation.

-#'  Default \code{2500}.

-#' @param ... Additional parameters.

-#' @return Numeric Matrix of dimension `ncol(counts)` x 2, colums representing

-#'  the "X" and "Y" coordinates in the data's t-SNE represetation.

-#' @examples

-#' data(celdaCGSim, celdaCGMod)

-#' tsneRes <- celdaTsne(celdaCGSim$counts, celdaCGMod)

-#' @export

-setGeneric("celdaTsne",

-  signature = "celdaMod",

-  function(counts,

-           celdaMod,

-           maxCells = 25000,

-           minClusterSize = 100,

-           initialDims = 20,

-           modules = NULL,

-           perplexity = 20,

-           maxIter = 2500,

-           ...) {

-    # counts = processCounts(counts)

-    # compareCountMatrix(counts, celdaMod)

-    standardGeneric("celdaTsne")

-  }

-)

-

-

-#' @title Embeds cells in two dimensions using umap.

-#' @param counts Integer matrix. Rows represent features and columns represent

-#'  cells. This matrix should be the same as the one used to generate

-#'  `celdaMod`.

-#' @param celdaMod Celda object of class `celda_CG`.

-#' @param maxCells Integer. Maximum number of cells to plot. Cells will be

-#'  randomly subsampled if ncol(counts) > maxCells. Larger numbers of cells

-#'  requires more memory. Default 25000.

-#' @param minClusterSize Integer. Do not subsample cell clusters below this

-#'  threshold. Default 100.

-#' @param modules Integer vector. Determines which features modules to use for

-#'  tSNE. If NULL, all modules will be used. Default NULL.

-#' @param seed Integer. Passed to \link[withr]{with_seed}. For reproducibility,

-#'  a default value of 12345 is used. If NULL, no calls to

-#'  \link[withr]{with_seed} are made.

-#'  the UMAP algorithm.

-#' @param ... Additional parameters to `uwot::umap`

-#' @return A two column matrix of UMAP coordinates#' @examples

-#' data(celdaCGSim, celdaCGMod)

-#' umapRes <- celdaUmap(celdaCGSim$counts, celdaCGMod)

-#' @export

-setGeneric("celdaUmap",

-  signature = "celdaMod",

-  function(counts,

-           celdaMod,

-           maxCells = NULL,

-           minClusterSize = 100,

-           modules = NULL,

-           seed = 12345,

-           ...) {

-    standardGeneric("celdaUmap")

-  }

-)

-

-

-#' @title Obtain the gene module of a gene of interest

-#' @description This function will output the corresponding feature module for

-#'  a specified vector of genes from a celda_CG or celda_G celdaModel.

-#'  \code{feature} must match the rownames of \code{sce}.

-#' @param sce A \linkS4class{SingleCellExperiment} object returned by

-#'  \link{celda_G}, or \link{celda_CG}, with the matrix

-#'  located in the \code{useAssay} assay slot.

-#'  Rows represent features and columns represent cells.

-#' @param feature Character vector. Identify feature modules for the specified

-#'  feature names. \code{feature} must match the rownames of \code{sce}.

-#' @param exactMatch Logical. Whether to look for exactMatch of the gene name

-#'  within counts matrix. Default \code{TRUE}.

-#' @return List. Each entry corresponds to the feature module determined for

-#' the provided features.

-#' @export

-setGeneric("featureModuleLookup",

-    function(sce, ...) {standardGeneric("featureModuleLookup")})

-

-

-#' @examples

-#' data(sceCeldaCG)

-#' module <- featureModuleLookup(sce = sceCeldaCG,

-#'     feature = c("Gene_1", "Gene_XXX"))

-#' @export

-#' @rdname featureModuleLookup

-setMethod("featureModuleLookup", signature(sce = "SingleCellExperiment"),

-    function(sce,

-        feature,

-        exactMatch = TRUE) {

-

-        if (celdaModel(sce) == "celda_CG") {

-            featureList <- .featureModuleLookupCG(sce = sce, feature = feature,

-                exactMatch = exactMatch)

-        } else if (celdaModel(sce) == "celda_G") {

-            featureList <- .featureModuleLookupG(sce = sce, feature = feature,

-                exactMatch = exactMatch)

-        } else {

-            stop("S4Vectors::metadata(sce)$celda_parameters$model must be",

-                " one of 'celda_G', or 'celda_CG'")

-        }

-        return(featureList)

-    }

-)

-

-

-.featureModuleLookupCG <- function(sce,

-    feature,

-    exactMatch) {

-

-    list <- list()

-    if (!isTRUE(exactMatch)) {

-        featureGrep <- c()

-        for (x in seq(length(feature))) {

-            featureGrep <- c(featureGrep, rownames(sce)[grep(

-                feature[x],

-                rownames(sce)

-            )])

-        }

-        feature <- featureGrep

-    }

-    for (x in seq(length(feature))) {

-        if (feature[x] %in% rownames(sce)) {

-            list[x] <- celdaModules(sce)[which(rownames(sce) ==

-                    feature[x])]

-        } else {

-            list[x] <- paste0(

-                "No feature was identified matching '",

-                feature[x],

-                "'."

-            )

-        }

-    }

-    names(list) <- feature

-    return(list)

-}

-

-

-.featureModuleLookupG <- function(sce, feature, exactMatch) {

-    if (!isTRUE(exactMatch)) {

-        feature <- unlist(lapply(

-            seq(length(feature)),

-            function(x) {

-                rownames(sce)[grep(feature[x], rownames(sce))]

-            }

-        ))

-    }

-

-    featList <- lapply(

-        seq(length(feature)),

-        function(x) {

-            if (feature[x] %in% rownames(sce)) {

-                return(celdaModules(sce)[which(rownames(sce) ==

-                        feature[x])])

-            } else {

-                return(paste0(

-                    "No feature was identified matching '",

-                    feature[x],

-                    "'."

-                ))

-            }

-        }

-    )

-    names(featList) <- feature

-    return(featList)

-}

-

-

-#' @title Uniform Manifold Approximation and Projection (UMAP) dimension

-#'  reduction for celda \code{sce} object

-#' @description Embeds cells in two dimensions using \link[uwot]{umap} based on

-#'  a celda model. For celda_C \code{sce} objects, PCA on the normalized counts

-#'  is used to reduce the number of features before applying UMAP. For celda_CG

-#'  \code{sce} object, UMAP is run on module probabilities to reduce the number

-#'  of features instead of using PCA. Module probabilities are square-root

-#'  transformed before applying UMAP.

-#' @param sce A \link[SingleCellExperiment]{SingleCellExperiment} object

-#'  returned by \link{celda_C}, \link{celda_G}, or \link{celda_CG}.

-#' @param useAssay A string specifying which \link[SummarizedExperiment]{assay}

-#'  slot to use. Default "counts".

-#' @param maxCells Integer. Maximum number of cells to plot. Cells will be

-#'  randomly subsampled if \code{ncol(sce) > maxCells}. Larger numbers of cells

-#'  requires more memory. If NULL, no subsampling will be performed.

-#'  Default NULL.

-#' @param minClusterSize Integer. Do not subsample cell clusters below this

-#'  threshold. Default 100.

-#' @param modules Integer vector. Determines which features modules to use for

-#'  UMAP. If NULL, all modules will be used. Default NULL.

-#' @param seed Integer. Passed to \link[withr]{with_seed}. For reproducibility,

-#'  a default value of 12345 is used. If NULL, no calls to

-#'  \link[withr]{with_seed} are made.

-#' @param nNeighbors The size of local neighborhood used for

-#'   manifold approximation. Larger values result in more global

-#'   views of the manifold, while smaller values result in more

-#'   local data being preserved. Default 30.

-#'   See \link[uwot]{umap} for more information.

-#' @param minDist The effective minimum distance between embedded points.

-#'   Smaller values will result in a more clustered/clumped

-#'   embedding where nearby points on the manifold are drawn

-#'   closer together, while larger values will result on a more

-#'   even dispersal of points. Default 0.75.

-#'   See \link[uwot]{umap} for more information.

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

-#'  \code{min_dist}, this determines how clustered/clumped the

-#'   embedded points are. Default 1. See \link[uwot]{umap} for more information.

-#' @param pca Logical. Whether to perform

-#' dimensionality reduction with PCA before UMAP. Only works for celda_C

-#'  \code{sce} objects.

-#' @param initialDims Integer. Number of dimensions from PCA to use as

-#' input in UMAP. Default 50. Only works for celda_C \code{sce} objects.

-#' @param cores Number of threads to use. Default 1.

-#' @param ... Additional parameters to pass to \link[uwot]{umap}.

-#' @examples

-#' data(sceCeldaCG)

-#' umapRes <- celdaUmap(sceCeldaCG)

-#' @return \code{sce} with UMAP coordinates

-#'  (columns "celda_UMAP1" & "celda_UMAP2") added to