@@ -50,6 +50,7 @@ export(plotDimReduceFeature)

 export(plotDimReduceGrid)

 export(plotDimReduceModule)

 export(plotGridSearchPerplexity)

+export(plotGridSearchPerplexityDiff)

 export(plotHeatmap)

 export(plotMarkerDendro)

 export(plotMarkerHeatmap)

@@ -106,6 +107,7 @@ exportMethods(plotDimReduceFeature)

 exportMethods(plotDimReduceGrid)

 exportMethods(plotDimReduceModule)

 exportMethods(plotGridSearchPerplexity)

+exportMethods(plotGridSearchPerplexityDiff)

 exportMethods(recursiveSplitCell)

 exportMethods(recursiveSplitModule)

 exportMethods(resList)

@@ -413,14 +413,15 @@ setMethod("celdaGridSearch",

 #' @param x Can be one of

 #' \itemize{

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

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

+#'  \code{celdaGridSearch}, \code{recursiveSplitModule},

+#'  or \code{recursiveSplitCell}. 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".

+#'  \linkS4class{SingleCellExperiment} object. Default "counts".

 #' @return One of

 #' \itemize{

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

@@ -472,19 +473,16 @@ setMethod("subsetCeldaList",

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

             if (nrow(newRunParams) == 0) {

-                stop(

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

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

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

-                    " to generate 'x'."

-                )

+                    " 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))

+            x <- .subsetCeldaListSCE(x, ix)

         } else {

             x@metadata$celda_grid_search@runParams <-

                 as.data.frame(newRunParams)

@@ -543,9 +541,13 @@ setMethod("subsetCeldaList",

 #' @description Select the chain with the best log likelihood for each

 #'  combination of tested parameters from a \code{SCE} object gererated by

 #'  \link{celdaGridSearch} or from a \code{celdaList} object.

-#' @param x Object of class \linkS4class{SingleCellExperiment} or

-#'  \code{celdaList}. An object containing celda

-#'  models returned from \link{celdaGridSearch}.

+#' @param x Can be one of

+#' \itemize{

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

+#'  \code{celdaGridSearch}, \code{recursiveSplitModule},

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

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

+#'  \item celdaList object.}

 #' @param asList \code{TRUE} or \code{FALSE}. Whether to return the

 #'  best model as a

 #'  \code{celdaList} object or not. If \code{FALSE}, return the best model as a

@@ -595,8 +597,7 @@ setMethod("selectBestModel", signature(x = "SingleCellExperiment"),

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

         if (nrow(newRunParams) == 1 & !asList) {

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

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

+            x <- .subsetCeldaListSCE(x, ix)

         } else {

             x@metadata$celda_grid_search@runParams <-

                 as.data.frame(newRunParams)

@@ -670,3 +671,60 @@ setMethod("selectBestModel", signature(x = "celdaList"),

             logfilePrefix = logfilePrefix)

     return(sce)

 }

+

+

+.subsetCeldaListSCE <- function (x, ix) {

+    cgsparam <- x@metadata$celda_grid_search@celdaGridSearchParameters

+    if (cgsparam$model == "celda_c") {

+        x <- .createSCEceldaC(celdaCMod = resList(x)[[ix]],

+            sce = x,

+            xClass = cgsparam$xClass,

+            useAssay = cgsparam$useAssay,

+            algorithm = cgsparam$algorithm,

+            stopIter = cgsparam$stopIter,

+            maxIter = cgsparam$maxIter,

+            splitOnIter = cgsparam$splitOnIter,

+            splitOnLast = cgsparam$splitOnLast,

+            nchains = cgsparam$nchains,

+            zInitialize = cgsparamp[["zInitialize"]],

+            zInit = cgsparamp[["zInit"]],

+            logfile = cgsparamp$logfile,

+            verbose = cgsparamp$verbose)

+    } else if (cgsparam$model == "celda_G") {

+        x <- .createSCEceldaG(celdaGMod = resList(x)[[ix]],

+            sce = x,

+            xClass = cgsparam$xClass,

+            useAssay = cgsparam$useAssay,

+            stopIter = cgsparam$stopIter,

+            maxIter = cgsparam$maxIter,

+            splitOnIter = cgsparam$splitOnIter,

+            splitOnLast = cgsparam$splitOnLast,

+            nchains = cgsparam$nchains,

+            yInitialize = cgsparam[["yInitialize"]],

+            yInit = cgsparam[["yInit"]],

+            logfile = cgsparam$logfile,

+            verbose = cgsparam$verbose)

+    } else if (cgsparam$model == "celda_CG") {

+        x <- .createSCEceldaCG(celdaCGMod = resList(x)[[ix]],

+            sce = x,

+            xClass = cgsparam$xClass,

+            useAssay = cgsparam$useAssay,

+            algorithm = cgsparam$algorithm,

+            stopIter = cgsparam$stopIter,

+            maxIter = cgsparam$maxIter,

+            splitOnIter = cgsparam$splitOnIter,

+            splitOnLast = cgsparam$splitOnLast,

+            nchains = cgsparam$nchains,

+            zInitialize = cgsparam[["zInitialize"]],

+            yInitialize = cgsparam[["yInitialize"]],

+            zInit = cgsparam[["zInit"]],

+            yInit = cgsparam[["yInit"]],

+            logfile = cgsparam$logfile,

+            verbose = cgsparam$verbose)

+    } else {

+        stop("S4Vectors::metadata(X)$celda_grid_search@",

+            "celdaGridSearchParameters$model must be",

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

+    }

+    return(x)

+}

@@ -356,6 +356,7 @@ distinctColors <- function(n,

 .processCounts <- function(counts) {

+  counts <- as.matrix(counts)

   if (typeof(counts) != "integer") {

     counts <- round(counts)

     storage.mode(counts) <- "integer"

@@ -132,8 +132,13 @@ setMethod("resamplePerplexity",

 #' @title Visualize perplexity of a list of celda models

 #' @description Visualize perplexity of every model in a celdaList, by unique

 #'  K/L combinations

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

-#'  \link{celdaGridSearch} or an object of class \code{celdaList}.

+#' @param x Can be one of

+#' \itemize{

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

+#'  \code{celdaGridSearch}, \code{recursiveSplitModule},

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

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

+#'  \item celdaList object.}

 #' @param sep Numeric. Breaks in the x axis of the resulting plot.

 #' @return A ggplot plot object showing perplexity as a function of clustering

 #'  parameters.

@@ -379,3 +384,266 @@ setMethod("plotGridSearchPerplexity",

   }, integer(nrow(countMatrix)))

   return(resample)

 }

+

+

+#' @title Visualize perplexity differences of a list of celda models

+#' @description Visualize perplexity differences of every model in a celdaList,

+#'  by unique K/L combinations.

+#' @param x Can be one of

+#' \itemize{

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

+#'  \code{celdaGridSearch}, \code{recursiveSplitModule},

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

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

+#'  \item celdaList object.}

+#' @param sep Numeric. Breaks in the x axis of the resulting plot.

+#' @return A ggplot plot object showing perplexity diferences as a function of

+#'  clustering parameters.

+#' @export

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

+    standardGeneric("plotGridSearchPerplexityDiff")})

+

+

+#' @rdname plotGridSearchPerplexityDiff

+#' @examples

+#' data(sceCeldaCGGridSearch)

+#' sce <- resamplePerplexity(sceCeldaCGGridSearch)

+#' plotGridSearchPerplexityDiff(sce)

+#' @export

+setMethod("plotGridSearchPerplexityDiff",

+    signature(x = "SingleCellExperiment"),

+    function(x, sep = 1) {

+        model <- x@metadata$celda_grid_search@celdaGridSearchParameters$model

+        celdaList <- S4Vectors::metadata(x)$celda_grid_search

+

+        if (model == "celda_c") {

+            g <- .plotGridSearchPerplexityDiffC(celdaList, sep)

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

+            g <- .plotGridSearchPerplexityDiffG(celdaList, sep)

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

+            g <- .plotGridSearchPerplexityDiffCG(celdaList, sep)

+        } else {

+            stop("S4Vectors::metadata(X)$celda_grid_search@",

+                "celdaGridSearchParameters$model must be",

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

+        }

+        return(g)

+    }

+)

+

+

+#' @rdname plotGridSearchPerplexityDiff

+#' @examples

+#' data(celdaCGSim, celdaCGGridSearchRes)

+#' ## Run various combinations of parameters with 'celdaGridSearch'

+#' celdaCGGridSearchRes <- resamplePerplexity(

+#'   celdaCGSim$counts,

+#'   celdaCGGridSearchRes)

+#' plotGridSearchPerplexityDiff(celdaCGGridSearchRes)

+#' @export

+setMethod("plotGridSearchPerplexityDiff",

+    signature(x = "celdaList"),

+    function(x, sep = 1) {

+        g <- do.call(paste0(".plotGridSearchPerplexityDiff",

+            unlist(strsplit(as.character(class(resList(x)[[1]])), "_"))[[2]]),

+            args = list(x, sep))

+        return(g)

+    }

+)

+

+

+.plotGridSearchPerplexityDiffCG <- function(celdaList, sep) {

+    if (!all(c("K", "L") %in% colnames(runParams(celdaList)))) {

+        stop("runParams(celdaList) needs K and L columns.")

+    }

+    if (is.null(celdaPerplexity(celdaList))) {

+        stop("No perplexity measurements available. First run",

+            " 'resamplePerplexity' with celdaList object.")

+    }

+

+    ix1 <- rep(seq(nrow(celdaPerplexity(celdaList))),

+        each = ncol(celdaPerplexity(celdaList)))

+    ix2 <- rep(seq(ncol(celdaPerplexity(celdaList))),

+        nrow(celdaPerplexity(celdaList)))

+    dt <- data.table::data.table(runParams(celdaList)[ix1, ],

+        perplexity = celdaPerplexity(celdaList)[cbind(ix1, ix2)])

+    dt$K <- as.factor(dt$K)

+    dt$L <- as.factor(dt$L)

+

+    if (nlevels(dt$K) > 1) {

+        for (i in seq(nlevels(dt$L))) {

+            for (j in seq(2, nlevels(dt$K))) {

+                p1 <- dt[K == levels(dt$K)[j - 1] & L == levels(dt$L)[i],

+                    perplexity]

+                p2 <- dt[K == levels(dt$K)[j] & L == levels(dt$L)[i],

+                    perplexity]

+                dt[K == levels(dt$K)[j] & L == levels(dt$L)[i],

+                    perpdiffK := p2 - p1]

+            }

+        }

+

+        diffMeansByK <- data.table::data.table(stats::aggregate(dt$perpdiffK,

+            by = list(dt$K, dt$L),

+            FUN = mean))

+        colnames(diffMeansByK) <- c("K", "L", "meanperpdiffK")

+        diffMeansByK$K <- as.factor(diffMeansByK$K)

+        diffMeansByK$L <- as.factor(diffMeansByK$L)

+

+        plot <- ggplot2::ggplot(dt[!is.na(perpdiffK), ],

+            ggplot2::aes_string(x = "K",

+                y = "perpdiffK")) +

+            ggplot2::geom_jitter(height = 0, width = 0.1,

+                ggplot2::aes_string(color = "L")) +

+            ggplot2::scale_color_discrete(name = "L") +

+            ggplot2::geom_path(data = diffMeansByK[!is.na(meanperpdiffK), ],

+                ggplot2::aes_string(

+                x = "K",

+                y = "meanperpdiffK", group = "L", color = "L")) +

+            ggplot2::ylab("Perplexity difference compared to previous K") +

+            ggplot2::xlab("K") +

+            ggplot2::scale_x_discrete(breaks = seq(as.integer(levels(dt$K))[2],

+                max(as.integer(levels(dt$K))), sep)) +

+            ggplot2::theme_bw()

+    } else if (nlevels(dt$L) > 1) {

+        for (i in seq(nlevels(dt$K))) {

+            for (j in seq(2, nlevels(dt$L))) {

+                p1 <- dt[K == levels(dt$K)[i] & L == levels(dt$L)[j - 1],

+                    perplexity]

+                p2 <- dt[K == levels(dt$K)[i] & L == levels(dt$L)[j],

+                    perplexity]

+                dt[K == levels(dt$K)[i] & L == levels(dt$L)[j],

+                    perpdiffL := p2 - p1]

+            }

+        }

+

+        diffMeansByL <- data.table::data.table(stats::aggregate(dt$perpdiffL,

+            by = list(dt$K, dt$L),

+            FUN = mean))

+        colnames(diffMeansByL) <- c("K", "L", "meanperpdiffL")

+        diffMeansByL$K <- as.factor(diffMeansByL$K)

+        diffMeansByK$L <- as.factor(diffMeansByL$L)

+

+        plot <- ggplot2::ggplot(dt[!is.na(perpdiffL), ],

+                ggplot2::aes_string(x = "L", y = "perpdiffL")) +

+            ggplot2::geom_jitter(height = 0, width = 0.1,

+                ggplot2::aes_string(color = "K")) +

+            ggplot2::scale_color_discrete(name = "K") +

+            ggplot2::geom_path(

+                data = diffMeansByL[!is.na(meanperpdiffL), ],

+                ggplot2::aes_string(

+                    x = "L", y = "meanperpdiffL", group = "K", color = "K")) +

+            ggplot2::ylab("Perplexity difference compared to previous L") +

+            ggplot2::xlab("L") +

+            ggplot2::scale_x_discrete(breaks = seq(as.integer(levels(dt$L))[2],

+                    max(as.integer(levels(dt$L))), sep)) +

+            ggplot2::theme_bw()

+    } else {

+        stop("Only one combination of K and L available! Unable to calculate",

+            " perplexity differences.")

+    }

+

+    return(plot)

+}

+

+

+.plotGridSearchPerplexityceldaC <- function(celdaList, sep) {

+    if (!all(c("K") %in% colnames(runParams(celdaList)))) {

+        stop("runParams(celdaList) needs the column K.")

+    }

+    if (is.null(celdaPerplexity(celdaList))) {

+        stop(

+            "No perplexity measurements available. First run",

+            " 'resamplePerplexity' with celdaList object."

+        )

+    }

+

+    ix1 <- rep(seq(nrow(celdaPerplexity(celdaList))),

+        each = ncol(celdaPerplexity(celdaList)))

+    ix2 <- rep(seq(ncol(celdaPerplexity(celdaList))),

+        nrow(celdaPerplexity(celdaList)))

+    dt <- data.table::data.table(runParams(celdaList)[ix1, ],

+        perplexity = celdaPerplexity(celdaList)[cbind(ix1, ix2)])

+    dt$K <- as.factor(dt$K)

+

+    if (nlevels(dt$K) > 1) {

+        for (i in seq(2, nlevels(dt$K))) {

+            p1 <- dt[K == levels(dt$K)[i - 1], perplexity]

+            p2 <- dt[K == levels(dt$K)[i], perplexity]

+            dt[K == levels(dt$K)[i], perpdiffK := p2 - p1]

+        }

+

+        diffMeansByK <- data.table::data.table(stats::aggregate(dt$perpdiffK,

+            by = list(dt$K),

+            FUN = mean))

+        colnames(diffMeansByK) <- c("K", "meanperpdiffK")

+        diffMeansByK$K <- as.factor(diffMeansByK$K)

+

+        plot <- ggplot2::ggplot(dt[!is.na(perpdiffK), ],

+            ggplot2::aes_string(x = "K",

+                y = "perpdiffK")) +

+            ggplot2::geom_jitter(height = 0, width = 0.1) +

+            ggplot2::geom_path(data = diffMeansByK[!is.na(meanperpdiffK), ],

+                ggplot2::aes_string(x = "K", y = "meanperpdiffK", group = 1)) +

+            ggplot2::ylab("Perplexity difference compared to previous K") +

+            ggplot2::xlab("K") +

+            ggplot2::scale_x_discrete(breaks = seq(as.integer(levels(dt$K))[2],

+                max(as.integer(levels(dt$K))), sep)) +

+            ggplot2::theme_bw()

+    } else {

+        stop("Only one unique K value available! Unable to calculate",

+            " perplexity differences.")

+    }

+    return(plot)

+}

+

+

+.plotGridSearchPerplexityceldaG <- function(celdaList, sep) {

+    if (!all(c("L") %in% colnames(runParams(celdaList)))) {

+        stop("runParams(celdaList) needs the column L.")

+    }

+    if (length(celdaPerplexity(celdaList)) == 0) {

+        stop(

+            "No perplexity measurements available. First run",

+            " 'resamplePerplexity' with celdaList object."

+        )

+    }

+

+    ix1 <- rep(seq(nrow(celdaPerplexity(celdaList))),

+        each = ncol(celdaPerplexity(celdaList)))

+    ix2 <- rep(seq(ncol(celdaPerplexity(celdaList))),

+        nrow(celdaPerplexity(celdaList)))

+    dt <- data.table::data.table(runParams(celdaList)[ix1, ],

+        perplexity = celdaPerplexity(celdaList)[cbind(ix1, ix2)])

+    dt$L <- as.factor(dt$L)

+

+    if (nlevels(dt$L) > 1) {

+        for (i in seq(2, nlevels(dt$L))) {

+            p1 <- dt[L == levels(dt$L)[i - 1], perplexity]

+            p2 <- dt[L == levels(dt$L)[i], perplexity]

+            dt[L == levels(dt$L)[i], perpdiffL := p2 - p1]

+        }

+

+        diffMeansByL <- data.table::data.table(stats::aggregate(dt$perpdiffL,

+            by = list(dt$L),

+            FUN = mean))

+        colnames(diffMeansByL) <- c("L", "meanperpdiffL")

+        diffMeansByL$L <- as.factor(diffMeansByL$L)

+

+        plot <- ggplot2::ggplot(dt[!is.na(perpdiffL), ],

+            ggplot2::aes_string(x = "L",

+                y = "perpdiffL")) +

+            ggplot2::geom_jitter(height = 0, width = 0.1) +

+            ggplot2::geom_path(data = diffMeansByL[!is.na(meanperpdiffL), ],

+                ggplot2::aes_string(x = "L", y = "meanperpdiffL", group = 1)) +

+            ggplot2::ylab("Perplexity difference compared to previous L") +

+            ggplot2::xlab("L") +

+            ggplot2::scale_x_discrete(breaks = seq(as.integer(levels(dt$L))[2],

+                max(as.integer(levels(dt$L))), sep)) +

+            ggplot2::theme_bw()

+    } else {

+        stop("Only one unique L value available! Unable to calculate",

+            " perplexity differences.")

+    }

+    return(plot)

+}

+

@@ -13,8 +13,13 @@ plotGridSearchPerplexity(x, ...)

 \S4method{plotGridSearchPerplexity}{celdaList}(x, sep = 1)

 }

 \arguments{

-\item{x}{A \linkS4class{SingleCellExperiment} object returned from

-\link{celdaGridSearch} or an object of class \code{celdaList}.}

+\item{x}{Can be one of

+\itemize{

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

+ \code{celdaGridSearch}, \code{recursiveSplitModule},

+ or \code{recursiveSplitCell}. Must contain a list named

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

+ \item celdaList object.}}

 \item{sep}{Numeric. Breaks in the x axis of the resulting plot.}

 }

new file mode 100644

@@ -0,0 +1,44 @@

+% Generated by roxygen2: do not edit by hand

+% Please edit documentation in R/model_performance.R

+\name{plotGridSearchPerplexityDiff}

+\alias{plotGridSearchPerplexityDiff}

+\alias{plotGridSearchPerplexityDiff,SingleCellExperiment-method}

+\alias{plotGridSearchPerplexityDiff,celdaList-method}

+\title{Visualize perplexity differences of a list of celda models}

+\usage{

+plotGridSearchPerplexityDiff(x, ...)

+

+\S4method{plotGridSearchPerplexityDiff}{SingleCellExperiment}(x, sep = 1)

+

+\S4method{plotGridSearchPerplexityDiff}{celdaList}(x, sep = 1)

+}

+\arguments{

+\item{x}{Can be one of

+\itemize{

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

+ \code{celdaGridSearch}, \code{recursiveSplitModule},

+ or \code{recursiveSplitCell}. Must contain a list named

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

+ \item celdaList object.}}

+

+\item{sep}{Numeric. Breaks in the x axis of the resulting plot.}

+}

+\value{

+A ggplot plot object showing perplexity diferences as a function of

+ clustering parameters.

+}

+\description{

+Visualize perplexity differences of every model in a celdaList,

+ by unique K/L combinations.

+}

+\examples{

+data(sceCeldaCGGridSearch)

+sce <- resamplePerplexity(sceCeldaCGGridSearch)

+plotGridSearchPerplexityDiff(sce)

+data(celdaCGSim, celdaCGGridSearchRes)

+## Run various combinations of parameters with 'celdaGridSearch'

+celdaCGGridSearchRes <- resamplePerplexity(

+  celdaCGSim$counts,

+  celdaCGGridSearchRes)

+plotGridSearchPerplexityDiff(celdaCGGridSearchRes)

+}

@@ -13,9 +13,13 @@ selectBestModel(x, ...)

 \S4method{selectBestModel}{celdaList}(x, asList = FALSE)

 }

 \arguments{

-\item{x}{Object of class \linkS4class{SingleCellExperiment} or

-\code{celdaList}. An object containing celda

-models returned from \link{celdaGridSearch}.}

+\item{x}{Can be one of

+\itemize{

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

+ \code{celdaGridSearch}, \code{recursiveSplitModule},

+ or \code{recursiveSplitCell}. Must contain a list named

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

+ \item celdaList object.}}

 \item{asList}{\code{TRUE} or \code{FALSE}. Whether to return the

 best model as a

@@ -17,7 +17,8 @@ subsetCeldaList(x, ...)

 \item{x}{Can be one of

 \itemize{

  \item A \linkS4class{SingleCellExperiment} object returned from

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

+ \code{celdaGridSearch}, \code{recursiveSplitModule},

+ or \code{recursiveSplitCell}. Must contain a list named

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

  \item celdaList object.}}

@@ -26,7 +27,7 @@ models in list \code{"celda_grid_search"} in \code{metadata(x)}.}

 \item{useAssay}{A string specifying which \code{assay}

 slot to use if \code{x} is a

-\link[SingleCellExperiment]{SingleCellExperiment} object. Default "counts".}

+\linkS4class{SingleCellExperiment} object. Default "counts".}

 }

 \value{

 One of