@@ -18,6 +18,7 @@ export(celdaUmap)

 export(celda_C)

 export(celda_CG)

 export(celda_G)

+export(celdatosce)

 export(clusterProbability)

 export(clusters)

 export(compareCountMatrix)

@@ -67,6 +68,7 @@ export(sampleLabel)

 export(selectBestModel)

 export(simulateCells)

 export(simulateContamination)

+export(subsetCeldaList)

 export(topRank)

 exportMethods("clusters<-")

 exportMethods("decontXcounts<-")

@@ -83,6 +85,7 @@ exportMethods(celdaUmap)

 exportMethods(celda_C)

 exportMethods(celda_CG)

 exportMethods(celda_G)

+exportMethods(celdatosce)

 exportMethods(clusterProbability)

 exportMethods(clusters)

 exportMethods(countChecksum)

@@ -99,6 +102,7 @@ exportMethods(perplexity)

 exportMethods(resList)

 exportMethods(runParams)

 exportMethods(sampleLabel)

+exportMethods(subsetCeldaList)

 import(Rcpp)

 import(RcppEigen)

 import(SummarizedExperiment)

@@ -11,8 +11,17 @@ setClass(

 ) # z and or y

+setClass("celdaList",

+    slots = c(runParams = "data.frame",

+        resList = "list",

+        countChecksum = "character",

+        perplexity = "matrix",

+        celdaGridSearchParameters = "list")

+)

+

+

 #' @title Get or set the cell cluster labels from a celda

-#'  \link[SingleCellExperiment]{SingleCellExperiment} object or celda model

+#'  \linkS4class{SingleCellExperiment}  object or celda model

 #'  object.

 #' @description Return or set the cell cluster labels determined

 #'  by \link{celda_C} or \link{celda_CG} models.

@@ -80,7 +89,7 @@ setReplaceMethod("clusters", signature(x = "SingleCellExperiment"),

 #' @title Get or set the feature module labels from a celda

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

+#'  \linkS4class{SingleCellExperiment}  object.

 #' @description Return or set the feature module cluster labels determined

 #'  by \link{celda_G} or \link{celda_CG} models.

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

@@ -121,7 +130,7 @@ setReplaceMethod("modules", signature(sce = "SingleCellExperiment"),

 #' @title Get or set sample labels from a celda

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

+#'  \linkS4class{SingleCellExperiment}  object

 #' @description Return or set the sample labels for the cells in \code{sce}.

 #' @param x Can be one of

 #'  \itemize{

@@ -244,3 +253,96 @@ setMethod("matrixNames",

         celdaMod@names

     }

 )

+

+

+#' @title Get run parameters from a celda model

+#'  \code{SingleCellExperiment} or \code{celdaList} object

+#' @description Returns details on the clustering parameters and model

+#'  priors from the celdaList object when it was created.

+#' @param x An object of class \linkS4class{SingleCellExperiment}.

+#' @return Data Frame. Contains details on the various K/L parameters, chain

+#'  parameters, seed, and final log-likelihoods derived for each model in the

+#'  provided celdaList.

+#' @export

+setGeneric(

+    "runParams",

+    function(x) {

+        standardGeneric("runParams")

+    }

+)

+

+

+#' @examples

+#' data(sceCeldaCGGridSearch)

+#' runParams(sceCeldaCGGridSearch)

+#' @rdname runParams

+#' @export

+setMethod("runParams",

+    signature(x = "SingleCellExperiment"),

+    function(x) {

+        return(x@metadata$celda_grid_search@runParams)

+    }

+)

+

+

+#' @title Get run parameters from a \code{celdaList} object

+#' @description Returns details on the clustering parameters, and model priors

+#'  from the celdaList object when it was created.

+#' @param x An object of class \code{celdaList}.

+#' @return Data Frame. Contains details on the various K/L parameters, chain

+#'  parameters, seed, and final log-likelihoods derived for each model in the

+#'  provided celdaList.

+#' @examples

+#' data(celdaCGGridSearchRes)

+#' runParams(celdaCGGridSearchRes)

+#' @rdname runParams

+#' @export

+setMethod("runParams",

+    signature(x = "celdaList"),

+    function(x) {

+        return(x@runParams)

+    }

+)

+

+

+#' @title Get final celdaModels from a celda model \code{SCE} or celdaList

+#'  object

+#' @description Returns all celda models generated during a

+#'  \link{celdaGridSearch} run.

+#' @param x An object of class \linkS4class{SingleCellExperiment} or

+#'  \code{celdaList}.

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

+#'  specified in \code{runParams(x)}.

+#' @export

+setGeneric(

+    "resList",

+    function(x) {

+        standardGeneric("resList")

+    }

+)

+

+

+#' @examples

+#' data(sceCeldaCGGridSearch)

+#' celdaCGGridModels <- resList(sceCeldaCGGridSearch)

+#' @rdname resList

+#' @export

+setMethod("resList",

+    signature(x = "SingleCellExperiment"),

+    function(x) {

+        return(x@metadata$celda_grid_search@resList)

+    }

+)

+

+

+#' @examples

+#' data(celdaCGGridSearchRes)

+#' celdaCGGridModels <- resList(celdaCGGridSearchRes)

+#' @rdname resList

+#' @export

+setMethod("resList",

+    signature(x = "celdaList"),

+    function(x) {

+        return(x@resList)

+    }

+)

@@ -1,3 +1,29 @@

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

@@ -113,84 +139,6 @@ setClass("celda_G", contains = "celdaModel")

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

-setClass("celdaList",

-    slots = c(runParams = "data.frame",

-        resList = "list",

-        countChecksum = "character",

-        perplexity = "matrix",

-        celdaGridSearchParameters = "list")

-)

-

-

-#' @title Get run parameters provided to `celdaGridSearch()`

-#' @description Returns details on the clustering parameters, and model priors

-#'  provided to `celdaGridSearch()` when the provided celdaList was

-#'  created.

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

-#' @return Data Frame. Contains details on the various K/L parameters, chain

-#'  parameters, and final log-likelihoods derived for each model in the

-#'  provided celdaList.

-#' @examples

-#' data(celdaCGGridSearchRes)

-#' runParams(celdaCGGridSearchRes)

-#' @export

-setGeneric(

-  "runParams",

-  function(celdaList) {

-    standardGeneric("runParams")

-  }

-)

-#' @title Get run parameters provided to `celdaGridSearch()`

-#' @description Returns details on the clustering parameters, and model priors

-#'  provided to `celdaGridSearch()` when the provided celdaList was

-#'  created.

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

-#' @return Data Frame. Contains details on the various K/L parameters, chain

-#'  parameters, and final log-likelihoods derived for each model in the

-#'  provided celdaList.

-#' @examples

-#' data(celdaCGGridSearchRes)

-#' runParams(celdaCGGridSearchRes)

-#' @export

-setMethod("runParams",

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

-  function(celdaList) {

-    celdaList@runParams

-  }

-)

-

-

-#' @title Get final celdaModels from a celdaList

-#' @description Returns all models generated during a `celdaGridSearch()` run.

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

-#' celdaCGGridModels <- resList(celdaCGGridSearchRes)

-#' @export

-setGeneric(

-  "resList",

-  function(celdaList) {

-    standardGeneric("resList")

-  }

-)

-#' @title Get final celdaModels from a celdaList

-#' @description Returns all models generated during a `celdaGridSearch()` run.

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

-#' celdaCGGridModels <- resList(celdaCGGridSearchRes)

-#' @export

-setMethod("resList",

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

-  function(celdaList) {

-    celdaList@resList

-  }

-)

-

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

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

@@ -404,146 +404,139 @@ setMethod("celdaGridSearch",

 }

-#' ################################################################################

-#' # Methods for manipulating celdaList objects                                  #

-#' ################################################################################

-#' #' @title Subset celda model from SCE object returned from

-#' #'  \code{celdaGridSearch}

-#' #' @description Select a subset of models from a

-#' #'  \linkS4class{SingleCellExperiment} object generated by

-#' #'  \link{celdaGridSearch} that match the criteria in the argument

-#' #'  \code{params}.

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

-#' #'  \code{celdaGridSearch}. Must contain a list named

-#' #'  \code{"celda_grid_search"} in \code{metadata(x)}.

-#' #' @param params List. List of parameters used to subset the matching celda

-#' #'  models in list \code{"celda_grid_search"} in \code{metadata(x)}.

-#' #' @return A new \linkS4class{SingleCellExperiment} object containing

-#' #'  all models matching the

-#' #'  provided criteria in \code{params}. If only one celda model result in the

-#' #'  \code{"celda_grid_search"} slot in \code{metadata(x)} matches

-#' #'  the given criteria, a new \linkS4class{SingleCellExperiment} object

-#' #'  with the matching model stored in the

-#' #'  \link[S4Vectors]{metadata}

-#' #'  \code{"celda_parameters"} slot will be returned. Otherwise, a new

-#' #'  \linkS4class{SingleCellExperiment} object with the subset models stored

-#' #'  in the \link[S4Vectors]{metadata}

-#' #'  \code{"celda_grid_search"} slot will be returned.

-#' #' @seealso \link{celdaGridSearch} can run Celda with multiple parameters and

-#' #'  chains in parallel. \link{selectBestModel} can get the best model for each

-#' #'  combination of parameters.

-#' #' @examples

-#' #' data(celdaCGGridSearchRes)

-#' #' resK5L10 <- subsetCeldaList(celdaCGGridSearchRes,

-#' #'     params = list(K = 5, L = 10))

-#' #' @export

-#' setGeneric("subsetCeldaList", function(x, ...) {

-#'     standardGeneric("subsetCeldaList")})

-#'

-#'

-#' #' @rdname subsetCeldaList

-#' #' @export

-#' setMethod("subsetCeldaList",

-#'     signature(x = "SingleCellExperiment"),

-#'     function(x, params) {

-#'

-#'     ## Check for bad parameter names

-#'     if (!all(names(params) %in% colnames(runParams(celdaList)))) {

-#'         badParams <- setdiff(names(params), colnames(runParams(celdaList)))

-#'         stop(

-#'             "The following elements in 'params' are not columns in runParams",

-#'             " (celdaList) ",

-#'             paste(badParams, collapse = ",")

-#'         )

-#'     }

-#'

-#'     ## Subset 'runParams' based on items in 'params'

-#'     newRunParams <- runParams(celdaList)

-#'     for (i in names(params)) {

-#'         newRunParams <-

-#'             subset(newRunParams, newRunParams[, i] %in% params[[i]])

-#'

-#'         if (nrow(newRunParams) == 0) {

-#'             stop(

-#'                 "No runs matched the criteria given in 'params'. Check",

-#'                 " 'runParams(celdaList)' for complete list of parameters used",

-#'                 " to generate 'celdaList'."

-#'             )

-#'         }

-#'     }

-#'

-#'     ## Get index of selected models, subset celdaList, and return

-#'     ix <- match(newRunParams$index, runParams(celdaList)$index)

-#'     if (length(ix) == 1) {

-#'         return(resList(celdaList)[[ix]])

-#'     } else {

-#'         celdaList@runParams <- as.data.frame(newRunParams)

-#'         celdaList@resList <- resList(celdaList)[ix]

-#'         return(celdaList)

-#'     }

-#' }

+#' @title Subset celda model from SCE object returned from

+#'  \code{celdaGridSearch}

+#' @description Select a subset of models from a

+#'  \linkS4class{SingleCellExperiment} object generated by

+#'  \link{celdaGridSearch} that match the criteria in the argument

+#'  \code{params}.

+#' @param x Can be one of

+#' \itemize{

+#'  \item A \linkS4class{SingleCellExperiment} object returned from

+#'  \code{celdaGridSearch}. Must contain a list named

+#'  \code{"celda_grid_search"} in \code{metadata(x)}.

+#'  \item celdaList object.}

+#' @param params List. List of parameters used to subset the matching celda

+#'  models in list \code{"celda_grid_search"} in \code{metadata(x)}.

+#' @param useAssay A string specifying which \code{assay}

+#'  slot to use if \code{x} is a

+#'  \link[SingleCellExperiment]{SingleCellExperiment} object. Default "counts".

+#' @return One of

+#' \itemize{

+#'  \item A new \linkS4class{SingleCellExperiment} object containing

+#'  all models matching the

+#'  provided criteria in \code{params}. If only one celda model result in the

+#'  \code{"celda_grid_search"} slot in \code{metadata(x)} matches

+#'  the given criteria, a new \linkS4class{SingleCellExperiment} object

+#'  with the matching model stored in the

+#'  \link[S4Vectors]{metadata}

+#'  \code{"celda_parameters"} slot will be returned. Otherwise, a new

+#'  \linkS4class{SingleCellExperiment} object with the subset models stored

+#'  in the \link[S4Vectors]{metadata}

+#'  \code{"celda_grid_search"} slot will be returned.

+#'  \item A new \code{celdaList} object containing all models matching the

+#'  provided criteria in \code{params}. If only one item in the

+#'  \code{celdaList} matches the given criteria, the matching model will be

+#'  returned directly instead of a \code{celdaList} object.}

+#' @seealso \link{celdaGridSearch} can run Celda with multiple parameters and

+#'  chains in parallel. \link{selectBestModel} can get the best model for each

+#'  combination of parameters.

+#' @export

+setGeneric("subsetCeldaList", function(x, ...) {

+    standardGeneric("subsetCeldaList")})

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

-# Methods for manipulating celdaList objects                                  #

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

-#' @title Subset celdaList object from celdaGridSearch

-#' @description Select a subset of models from a `celdaList` object generated

-#'  by `celdaGridSearch()` that match the criteria in the argument `params`.

-#' @param x celdaList Object of class `celdaList`. An object

-#'  containing celda models returned from `celdaGridSearch` in older versions.

-#' @param params List. List of parameters used to subset celdaList.

-#' @return A new `celdaList` object containing all models matching the

-#'  provided criteria in `params`. If only one item in the `celdaList` matches

-#'  the given criteria, the matching model will be returned directly instead of

-#'  a `celdaList` object.

-#' @seealso `celdaGridSearch()` can run Celda with multiple parameters and

-#'  chains in parallel. `selectBestModel()` can get the best model for each

-#'  combination of parameters.

+#' @rdname subsetCeldaList

 #' @examples

-#' data(celdaCGGridSearchRes)

-#' resK5L10 <- .subsetCeldaList(celdaCGGridSearchRes,

-#'   params = list(K = 5, L = 10))

-subsetCeldaList <- function(celdaList, params) {

-  if (!methods::is(celdaList, "celdaList")) {

-    stop("celdaList parameter was not of class celdaList.")

-  }

+#' data(sceCeldaCGGridSearch)

+#' sceK5L10 <- subsetCeldaList(sceCeldaCGGridSearch,

+#'     params = list(K = 5, L = 10))

+#' @export

+setMethod("subsetCeldaList",

+    signature(x = "SingleCellExperiment"),

+    function(x, params, useAssay = "counts") {

+

+        ## Check for bad parameter names

+        if (!all(names(params) %in% colnames(runParams(x)))) {

+            badParams <- setdiff(names(params), colnames(runParams(x)))

+            stop("The following elements in 'params' are not columns in",

+                " runParams (x) ",

+                paste(badParams, collapse = ",")

+            )

+        }

+

+        ## Subset 'runParams' based on items in 'params'

+        newRunParams <- runParams(x)

+        for (i in names(params)) {

+            newRunParams <-

+                subset(newRunParams, newRunParams[, i] %in% params[[i]])

+

+            if (nrow(newRunParams) == 0) {

+                stop(

+                    "No runs matched the criteria given in 'params'. Check",

+                    " 'runParams(x)' for complete list of parameters used",

+                    " to generate 'x'."

+                )

+            }

+        }

+

+        ## Get index of selected models, subset celdaList, and return

+        ix <- match(newRunParams$index, runParams(x)$index)

+        if (length(ix) == 1) {

+            x <- celdatosce(resList(x)[[ix]],

+                SummarizedExperiment::assay(x, i = useAssay))

+        } else {

+            x@metadata$celda_grid_search@runParams <-

+                as.data.frame(newRunParams)

+            x@metadata$celda_grid_search@resList <- resList(x)[ix]

+        }

+        return(x)

+    }

+)

-  ## Check for bad parameter names

-  if (!all(names(params) %in% colnames(runParams(celdaList)))) {

-    badParams <- setdiff(names(params), colnames(runParams(celdaList)))

-    stop(

-      "The following elements in 'params' are not columns in runParams",

-      " (celdaList) ",

-      paste(badParams, collapse = ",")

-    )

-  }

-  ## Subset 'runParams' based on items in 'params'

-  newRunParams <- runParams(celdaList)

-  for (i in names(params)) {

-    newRunParams <-

-      subset(newRunParams, newRunParams[, i] %in% params[[i]])

-

-    if (nrow(newRunParams) == 0) {

-      stop(

-        "No runs matched the criteria given in 'params'. Check",

-        " 'runParams(celdaList)' for complete list of parameters used",

-        " to generate 'celdaList'."

-      )

+#' @rdname subsetCeldaList

+#' @examples

+#' data(celdaCGGridSearchRes)

+#' resK5L10 <- subsetCeldaList(celdaCGGridSearchRes,

+#'     params = list(K = 5, L = 10))

+#' @export

+setMethod("subsetCeldaList",

+    signature(x = "celdaList"),

+    function(x, params) {

+        ## Check for bad parameter names

+        if (!all(names(params) %in% colnames(runParams(x)))) {

+            badParams <- setdiff(names(params), colnames(runParams(x)))

+            stop("The following elements in 'params' are not columns in",

+                " runParams (x) ",

+                paste(badParams, collapse = ",")

+            )

+        }

+

+        ## Subset 'runParams' based on items in 'params'

+        newRunParams <- runParams(x)

+        for (i in names(params)) {

+            newRunParams <-

+                subset(newRunParams, newRunParams[, i] %in% params[[i]])

+

+            if (nrow(newRunParams) == 0) {

+                stop("No runs matched the criteria given in 'params'. Check",

+                    " 'runParams(x)' for complete list of parameters used",

+                    " to generate 'x'.")

+            }

+        }

+

+        ## Get index of selected models, subset celdaList, and return

+        ix <- match(newRunParams$index, runParams(x)$index)

+        if (length(ix) == 1) {

+            return(resList(x)[[ix]])

+        } else {

+            x@runParams <- as.data.frame(newRunParams)

+            x@resList <- resList(x)[ix]

+            return(x)

+        }

     }

-  }

-

-  ## Get index of selected models, subset celdaList, and return

-  ix <- match(newRunParams$index, runParams(celdaList)$index)

-  if (length(ix) == 1) {

-    return(resList(celdaList)[[ix]])

-  } else {

-    celdaList@runParams <- as.data.frame(newRunParams)

-    celdaList@resList <- resList(celdaList)[ix]

-    return(celdaList)

-  }

-}

+)

 #' @title Select best chain within each combination of parameters

@@ -594,33 +587,6 @@ selectBestModel <- function(celdaList, asList = FALSE) {

 }

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

-  )

-}

-

-

 .createSCEceldaGridSearch <- function(celdaList,

     sce,

     xClass,

@@ -245,7 +245,6 @@ setMethod("celda_C",

         maxIter = maxIter,

         splitOnIter = splitOnIter,

         splitOnLast = splitOnLast,

-        seed = seed,

         nchains = nchains,

         zInitialize = zInitialize,

         zInit = zInit,

@@ -1053,29 +1052,7 @@ setMethod("celda_C",

 .reorderCeldaC <- function(counts, res) {

   if (params(res)$K > 2 & isTRUE(length(unique(res@clusters$z)) > 1)) {

     res@clusters$z <- as.integer(as.factor(res@clusters$z))

-

-    xClass <- "matrix"

-    useAssay <- NULL

-    sce <- SingleCellExperiment::SingleCellExperiment(

-        assays = list(counts = counts))

-

-    sce <- .createSCEceldaC(celdaCMod = res,

-        sce = sce,

-        xClass = xClass,

-        useAssay = useAssay,

-        algorithm = NULL,

-        stopIter = NULL,

-        maxIter = NULL,

-        splitOnIter = NULL,

-        splitOnLast = NULL,

-        seed = NULL,

-        nchains = NULL,

-        zInitialize = NULL,

-        zInit = NULL,

-        logfile = NULL,

-        verbose = NULL)

-

-    fm <- factorizeMatrix(sce, useAssay = "counts")

+    fm <- factorizeMatrix(counts, res)

     uniqueZ <- sort(unique(res@clusters$z))

     d <- .cosineDist(fm$posterior$module[, uniqueZ])

     h <- stats::hclust(d, method = "complete")

@@ -1231,7 +1208,6 @@ setMethod("celda_C",

     maxIter,

     splitOnIter,

     splitOnLast,

-    seed,

     nchains,

     zInitialize,

     zInit,

@@ -1252,7 +1228,7 @@ setMethod("celda_C",

         maxIter = maxIter,

         splitOnIter = splitOnIter,

         splitOnLast = splitOnLast,

-        seed = seed,

+        seed = celdaCMod@params$seed,

         nchains = nchains,

         zInitialize = zInitialize,

         countChecksum = celdaCMod@params$countChecksum,

@@ -299,7 +299,6 @@ setMethod("celda_CG",

         maxIter = maxIter,

         splitOnIter = splitOnIter,

         splitOnLast = splitOnLast,

-        seed = seed,

         nchains = nchains,

         zInitialize = zInitialize,

         yInitialize = yInitialize,

@@ -1319,34 +1318,10 @@ setMethod("celda_CG",

 .reorderCeldaCG <- function(counts, res) {

-

-    xClass <- "matrix"

-    useAssay <- NULL

-    sce <- SingleCellExperiment::SingleCellExperiment(

-        assays = list(counts = counts))

-

-    sce <- .createSCEceldaCG(celdaCGMod = res,

-        sce = sce,

-        xClass = xClass,

-        useAssay = useAssay,

-        algorithm = NULL,

-        stopIter = NULL,

-        maxIter = NULL,

-        splitOnIter = NULL,

-        splitOnLast = NULL,

-        seed = NULL,

-        nchains = NULL,

-        zInitialize = NULL,

-        yInitialize = NULL,

-        zInit = NULL,

-        yInit = NULL,

-        logfile = NULL,

-        verbose = NULL)

-

     # Reorder K

     if (params(res)$K > 2 & isTRUE(length(unique(res@clusters$z)) > 1)) {

         res@clusters$z <- as.integer(as.factor(res@clusters$z))

-        fm <- factorizeMatrix(sce, useAssay = "counts", type = "posterior")

+        fm <- factorizeMatrix(counts, res, type = "posterior")

         uniqueZ <- sort(unique(res@clusters$z))

         d <- .cosineDist(fm$posterior$cellPopulation[, uniqueZ])

         h <- stats::hclust(d, method = "complete")

@@ -1357,7 +1332,7 @@ setMethod("celda_CG",

     # Reorder L

     if (params(res)$L > 2 & isTRUE(length(unique(res@clusters$y)) > 1)) {

         res@clusters$y <- as.integer(as.factor(res@clusters$y))

-        fm <- factorizeMatrix(sce, useAssay = "counts", type = "posterior")

+        fm <- factorizeMatrix(counts, res, type = "posterior")

         uniqueY <- sort(unique(res@clusters$y))

         cs <- prop.table(t(fm$posterior$cellPopulation[uniqueY, ]), 2)

         d <- .cosineDist(cs)

@@ -1617,7 +1592,6 @@ setMethod("celda_CG",

     maxIter,

     splitOnIter,

     splitOnLast,

-    seed,

     nchains,

     zInitialize,

     yInitialize,

@@ -1643,7 +1617,7 @@ setMethod("celda_CG",

         maxIter = maxIter,

         splitOnIter = splitOnIter,

         splitOnLast = splitOnLast,

-        seed = seed,

+        seed = celdaCGMod@params$seed,

         nchains = nchains,

         zInitialize = zInitialize,

         yInitialize = yInitialize,

@@ -224,7 +224,6 @@ setMethod("celda_G",

         maxIter = maxIter,

         splitOnIter = splitOnIter,

         splitOnLast = splitOnLast,

-        seed = seed,

         nchains = nchains,

         yInitialize = yInitialize,

         yInit = yInit,

@@ -1034,28 +1033,7 @@ setMethod("celda_G",

 .reorderCeldaG <- function(counts, res) {

     if (params(res)$L > 2 & isTRUE(length(unique(res@clusters$y)) > 1)) {

         res@clusters$y <- as.integer(as.factor(res@clusters$y))

-

-        xClass <- "matrix"

-        useAssay <- NULL

-        sce <- SingleCellExperiment::SingleCellExperiment(

-            assays = list(counts = counts))

-

-        sce <- .createSCEceldaG(celdaGMod = res,

-            sce = sce,

-            xClass = xClass,

-            useAssay = useAssay,

-            stopIter = NULL,

-            maxIter = NULL,

-            splitOnIter = NULL,

-            splitOnLast = NULL,

-            seed = NULL,

-            nchains = NULL,

-            yInitialize = NULL,

-            yInit = NULL,

-            logfile = NULL,

-            verbose = NULL)

-

-        fm <- factorizeMatrix(sce, useAssay = "counts")

+        fm <- factorizeMatrix(counts, res)

         uniqueY <- sort(unique(res@clusters$y))

         cs <- prop.table(t(fm$posterior$cell[uniqueY, ]), 2)

         d <- .cosineDist(cs)

@@ -1068,7 +1046,6 @@ setMethod("celda_G",

 .celdaHeatmapCelda_G <- function(sce, useAssay, nfeatures, ...) {

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

-

     fm <- factorizeMatrix(sce = sce, useAssay = useAssay, type = "proportion")

     top <- celda::topRank(fm$proportions$module, n = nfeatures)

     ix <- unlist(top$index)

@@ -1126,7 +1103,6 @@ setMethod("celda_G",

     maxIter,

     splitOnIter,

     splitOnLast,

-    seed,

     nchains,

     yInitialize,

     yInit,

@@ -1146,7 +1122,7 @@ setMethod("celda_G",

         maxIter = maxIter,

         splitOnIter = splitOnIter,

         splitOnLast = splitOnLast,

-        seed = seed,

+        seed = celdaGMod@params$seed,

         nchains = nchains,

         yInitialize = yInitialize,

         countChecksum = celdaGMod@params$countChecksum,

@@ -257,6 +257,8 @@ compareCountMatrix <- function(counts,

       " the count matrix used to generate the provided celda result."

     )

   } else if (!res && !errorOnMismatch) {

+    warning("There was a mismatch between the provided count matrix and",

+        " the count matrix used to generate the provided celda result.")

     return(FALSE)

   }

 }

new file mode 100644

@@ -0,0 +1,126 @@

+

+#' @title Convert old celda model object to \code{SCE} object

+#' @description Convert a old celda model object (\code{celda_C},

+#'  \code{celda_G}, or \code{celda_CG} object) to a

+#'  \linkS4class{SingleCellExperiment} object containing celda model

+#'  information in \code{metadata} slot. Counts matrix is stored in the

+#'  \code{"counts"} assay slot in \code{assays}.

+#' @param celdaModel A celda model object generated using older versions of

+#'  \code{celda}.

+#' @param counts A numeric \link{matrix} of counts used to generate

+#'  \code{celdaModel}. Dimensions and MD5 checksum will be checked by

+#'  \link{compareCountMatrix}.

+#' @return A \linkS4class{SingleCellExperiment} object. Function

+#'  parameter settings are stored in the \link[S4Vectors]{metadata}

+#'  \code{"celda_parameters"} slot.

+#'  Columns \code{celda_sample_label} and \code{celda_cell_cluster} in

+#'  \link[SummarizedExperiment]{colData} contain sample labels and celda cell

+#'  population clusters. Column \code{celda_feature_module} in

+#'  \link[SummarizedExperiment]{rowData} contain feature modules.

+

+#' @export

+setGeneric("celdatosce", function(celdaModel, counts) {

+    standardGeneric("celdatosce")})

+

+

+#' @rdname celdatosce

+#' @examples

+#' data(celdaCMod, celdaCSim)

+#' sce <- celdatosce(celdaCMod, celdaCSim$counts)

+#' @export

+setMethod("celdatosce",

+    signature(celdaModel = "celda_C"),

+    function(celdaModel, counts) {

+        compareCountMatrix(counts, celdaModel, errorOnMismatch = FALSE)

+

+        xClass <- "matrix"

+        useAssay <- NULL

+        sce <- SingleCellExperiment::SingleCellExperiment(

+            assays = list(counts = counts))

+

+        sce <- .createSCEceldaC(celdaCMod = celdaModel,

+            sce = sce,

+            xClass = xClass,

+            useAssay = useAssay,

+            algorithm = NULL,

+            stopIter = NULL,

+            maxIter = NULL,

+            splitOnIter = NULL,

+            splitOnLast = NULL,

+            nchains = NULL,

+            zInitialize = NULL,

+            zInit = NULL,

+            logfile = NULL,

+            verbose = NULL)

+        return(sce)

+    }

+)

+

+

+#' @rdname celdatosce

+#' @examples

+#' data(celdaGMod, celdaGSim)

+#' sce <- celdatosce(celdaGMod, celdaGSim$counts)

+#' @export

+setMethod("celdatosce",

+    signature(celdaModel = "celda_G"),

+    function(celdaModel, counts) {

+        compareCountMatrix(counts, celdaModel, errorOnMismatch = FALSE)

+

+        xClass <- "matrix"

+        useAssay <- NULL

+        sce <- SingleCellExperiment::SingleCellExperiment(

+            assays = list(counts = counts))

+

+        sce <- .createSCEceldaG(celdaGMod = celdaModel,

+            sce = sce,

+            xClass = xClass,

+            useAssay = useAssay,

+            stopIter = NULL,

+            maxIter = NULL,

+            splitOnIter = NULL,

+            splitOnLast = NULL,

+            nchains = NULL,

+            yInitialize = NULL,

+            yInit = NULL,

+            logfile = NULL,

+            verbose = NULL)