biopipen 0.29.2__py3-none-any.whl → 0.30.0__py3-none-any.whl

biopipen/scripts/scrna/SeuratClusterStats-hists.R

@@ -1,7 +1,8 @@
 # Loaded variables: srtfile, outdir, srtobj
 
-hists_defaults <- {{envs.hists_defaults | r: todot="-"}}
-hists <- {{envs.hists | r: todot="-", skip=1}}
+# hists_defaults <- {{envs.hists_defaults | r: todot="-"}}
+# hists <- {{envs.hists | r: todot="-", skip=1}}
+log_info("hists:")
 
 do_one_hists <- function(m, case, odir, h1, each = NULL) {
     ofile <- file.path(odir, paste0(slugify(h1), ifelse(is.null(each), "", paste0("-", slugify(each))), ".png"))
@@ -57,7 +58,7 @@ do_one_hists <- function(m, case, odir, h1, each = NULL) {
 }
 
 if (is.null(hists) || length(hists) == 0) {
-    log_warn("No hists cases specified, skipping ...")
+    log_warn("- no cases specified, skipping ...")
 } else {
 
     for (name in names(hists)) {
@@ -112,12 +113,12 @@ if (is.null(hists) || length(hists) == 0) {
                 h1 = h1
             )
             for (each in eachs) {
-                log_info("Doing hists for: {h1} - {each} ...")
+                log_info("- Case: {h1} - {each} ...")
                 m <- meta %>% filter(!!sym(case$each) == each)
                 do_one_hists(m, case, odir, h1, each)
             }
         } else {
-            log_info("Doing hists for: {h1} ...")
+            log_info("- Case: {h1} ...")
             add_report(
                 list(
                     kind = "descr",

biopipen/scripts/scrna/SeuratClusterStats-ngenes.R

@@ -1,13 +1,14 @@
 # Loaded variables: srtfile, outdir, srtobj
 
-ngenes_defaults <- {{envs.ngenes_defaults | r: todot="-"}}
-ngenes <- {{envs.ngenes | r: todot="-", skip=1}}
+# ngenes_defaults <- {{envs.ngenes_defaults | r: todot="-"}}
+# ngenes <- {{envs.ngenes | r: todot="-", skip=1}}
+log_info("ngenes:")
 
 odir <- file.path(outdir, "ngenes")
 dir.create(odir, recursive=TRUE, showWarnings=FALSE)
 
 do_one_ngenes <- function(name) {
-    log_info("Doing ngenes for: {name}")
+    log_info("- Case: {name}")
 
     case <- list_update(ngenes_defaults, ngenes[[name]])
     case$devpars <- list_update(ngenes_defaults$devpars, case$devpars)

biopipen/scripts/scrna/SeuratClusterStats-stats.R

@@ -1,14 +1,15 @@
 # Loaded variables: srtfile, outdir, srtobj
 library(circlize)
 
-stats_defaults = {{envs.stats_defaults | r: todot="-"}}
-stats = {{envs.stats | r: todot="-", skip=1}}
+# stats_defaults = {{envs.stats_defaults | r: todot="-"}}
+# stats = {{envs.stats | r: todot="-", skip=1}}
+log_info("stats:")
 
 odir = file.path(outdir, "stats")
 dir.create(odir, recursive=TRUE, showWarnings=FALSE)
 
 do_one_stats = function(name) {
-    log_info("Doing stats for: {name}")
+    log_info("- Case: {name}")
 
     case = list_update(stats_defaults, stats[[name]])
     case$devpars = list_update(stats_defaults$devpars, case$devpars)

biopipen/scripts/scrna/SeuratClusterStats.R

@@ -1,6 +1,7 @@
-source("{{biopipen_dir}}/utils/misc.R")
-source("{{biopipen_dir}}/utils/mutate_helpers.R")
-source("{{biopipen_dir}}/utils/plot.R")
+{{ biopipen_dir | joinpaths: "utils", "misc.R" | source_r }}
+{{ biopipen_dir | joinpaths: "utils", "mutate_helpers.R" | source_r }}
+{{ biopipen_dir | joinpaths: "utils", "plot.R" | source_r }}
+
 library(Seurat)
 library(rlang)
 library(dplyr)
@@ -26,19 +27,34 @@ if (!is.null(mutaters) && length(mutaters) > 0) {
         mutate(!!!lapply(mutaters, parse_expr))
 }
 
+############## clustree ##############
+clustrees_defaults <- {{envs.clustrees_defaults | r}}
+clustrees <- {{envs.clustrees | r}}
+{{ biopipen_dir | joinpaths: "scripts", "scrna", "SeuratClusterStats-clustree.R" | source_r }}
+
 ############## stats ##############
-{% include biopipen_dir + "/scripts/scrna/SeuratClusterStats-stats.R" %}
+stats_defaults = {{envs.stats_defaults | r: todot="-"}}
+stats = {{envs.stats | r: todot="-", skip=1}}
+{{ biopipen_dir | joinpaths: "scripts", "scrna", "SeuratClusterStats-stats.R" | source_r }}
 
 ############## hists ##############
-{% include biopipen_dir + "/scripts/scrna/SeuratClusterStats-hists.R" %}
+hists_defaults <- {{envs.hists_defaults | r: todot="-"}}
+hists <- {{envs.hists | r: todot="-", skip=1}}
+{{ biopipen_dir | joinpaths: "scripts", "scrna", "SeuratClusterStats-hists.R" | source_r }}
 
 ############## ngenes ##############
-{% include biopipen_dir + "/scripts/scrna/SeuratClusterStats-ngenes.R" %}
+ngenes_defaults <- {{envs.ngenes_defaults | r: todot="-"}}
+ngenes <- {{envs.ngenes | r: todot="-", skip=1}}
+{{ biopipen_dir | joinpaths: "scripts", "scrna", "SeuratClusterStats-ngenes.R" | source_r }}
 
 ############## features ##############
-{% include biopipen_dir + "/scripts/scrna/SeuratClusterStats-features.R" %}
+features_defaults = {{envs.features_defaults | r: todot="-"}}
+features = {{envs.features | r: todot="-", skip=1}}
+{{ biopipen_dir | joinpaths: "scripts", "scrna", "SeuratClusterStats-features.R" | source_r }}
 
 ############## dimplots ##############
-{% include biopipen_dir + "/scripts/scrna/SeuratClusterStats-dimplots.R" %}
+dimplots_defaults = {{envs.dimplots_defaults | r: todot="-"}}
+dimplots = {{envs.dimplots | r: todot="-", skip=1}}
+{{ biopipen_dir | joinpaths: "scripts", "scrna", "SeuratClusterStats-dimplots.R" | source_r }}
 
 save_report(joboutdir)

biopipen/scripts/scrna/SeuratClustering-common.R

@@ -0,0 +1,213 @@
+
+expand_dims <- function(args, name = "dims") {
+    # Expand dims from 30 to 1:30
+    if (is.numeric(args[[name]]) && length(args[[name]] == 1)) {
+        args[[name]] <- 1:args[[name]]
+    }
+    args
+}
+
+expand_resolution <- function(resolution) {
+    expanded_res <- c()
+    for (res in resolution) {
+        if (is.numeric(res)) {
+            expanded_res <- c(expanded_res, res)
+        } else {
+            # is.character
+            parts <- trimws(unlist(strsplit(res, ",")))
+            for (part in parts) {
+                if (grepl(":", part)) {
+                    ps <- trimws(unlist(strsplit(part, ":")))
+                    if (length(ps) == 2) { ps <- c(ps, 0.1) }
+                    if (length(ps) != 3) {
+                        stop("Invalid resolution format: {part}. Expected 2 or 3 parts separated by ':' for a range.")
+                    }
+                    ps <- as.numeric(ps)
+                    expanded_res <- c(expanded_res, seq(ps[1], ps[2], by = ps[3]))
+                } else {
+                    expanded_res <- c(expanded_res, as.numeric(part))
+                }
+            }
+        }
+    }
+    # keep the last resolution at last
+    rev(unique(rev(round(expanded_res, 2))))
+}
+
+# recode clusters from 0, 1, 2, ... to c1, c2, c3, ...
+recode_clusters <- function(clusters) {
+    recode <- function(x) paste0("c", as.integer(as.character(x)) + 1)
+    clusters <- factor(recode(clusters), levels = recode(levels(clusters)))
+    clusters
+}
+
+run_transformation <- function(sobj) {
+    if (length(envs$ScaleData) == 0 && length(envs$SCTransform) == 0) {
+        log_warn("Skipping ScaleData/SCTransform (neither specified) ...")
+        return(sobj)
+    }
+    if (length(envs$ScaleData) > 0 && length(envs$SCTransform) > 0) {
+        stop("Both envs.ScaleData and envs.SCTransform are specified. Please choose either.")
+    }
+    if (length(envs$ScaleData) > 0) {
+        if (DefaultAssay(sobj) == "SCT") {
+            stop("SCT assay detected, but envs.ScaleData is specified. Use envs.SCTransform instead.")
+        }
+        cached <- get_cached(envs$ScaleData, "ScaleData", cache_dir)
+        if (is.null(cached$data)) {
+            log_info("Running ScaleData ...")
+            sobj <- do_call(ScaleData, c(list(object = sobj), envs$ScaleData))
+            cached$data <- list(assay = sobj@assays$RNA, commands = sobj@commands)
+            save_to_cache(cached, "ScaleData", cache_dir)
+        } else {
+            log_info("Loading cached ScaleData ...")
+            sobj@assays$RNA <- cached$data$assay
+            sobj@commands <- cached$data$commands
+            DefaultAssay(sobj) <- "RNA"
+        }
+    } else if (length(envs$SCTransform) > 0) {
+        if (DefaultAssay(sobj) != "SCT") {
+            stop("SCT assay not detected, but envs.SCTransform is specified. Use envs.ScaleData instead.")
+        }
+        cached <- get_cached(envs$SCTransform, "SCTransform", cache_dir)
+        asssay <- envs$SCTransform$new.assay.name %||% "SCT"
+        if (is.null(cached$data)) {
+            log_info("Running SCTransform ...")
+            sobj <- do_call(SCTransform, c(list(object = sobj), envs$SCTransform))
+            cached$data <- list(assay = sobj@assays$SCT, commands = sobj@commands)
+            save_to_cache(cached, "SCTransform", cache_dir)
+        } else {
+            log_info("Loading cached SCTransform ...")
+            sobj@assays[[assay]] <- cached$data$assay
+            sobj@commands <- cached$data$commands
+            DefaultAssay(sobj) <- assay
+        }
+    }
+    sobj
+}
+
+run_umap <- function(sobj) {
+    cached <- get_cached(
+        list(sobj = sobj, RunUMAP = envs$RunUMAP),
+        "RunUMAP",
+        cache_dir
+    )
+    reduc_name <- envs$RunUMAP$reduction.name %||% "umap"
+    if (is.null(cached$data)) {
+        log_info("Running RunUMAP ...")
+        umap_args <- list_setdefault(
+            envs$RunUMAP,
+            object = sobj,
+            dims = 1:30,
+            reduction = sobj@misc$integrated_new_reduction %||% "pca"
+        )
+        ncells <- ncol(sobj)
+        umap_args$dims <- 1:min(max(umap_args$dims), ncells - 1)
+        umap_method <- envs$RunUMAP$umap.method %||% "uwot"
+        if (umap_method == "uwot" && is.null(envs$RunUMAP$n.neighbors)) {
+            # https://github.com/satijalab/seurat/issues/4312
+            umap_args$n.neighbors <- min(ncells - 1, 30)
+        }
+        sobj <- do_call(RunUMAP, umap_args)
+        cached$data <- list(reduc = sobj@reductions[[reduc_name]], commands = sobj@commands)
+        save_to_cache(cached, "RunUMAP", cache_dir)
+    } else {
+        log_info("Loading cached RunUMAP ...")
+        sobj@reductions[[reduc_name]] <- cached$data$reduc
+        sobj@commands <- cached$data$commands
+    }
+
+    sobj
+}
+
+run_findneighbors <- function(sobj) {
+    cached <- get_cached(
+        list(sobj = sobj, FindNeighbors = envs$FindNeighbors),
+        "FindNeighbors",
+        cache_dir
+    )
+    if (is.null(cached$data)) {
+        log_info("Running FindNeighbors ...")
+        envs$FindNeighbors$object <- sobj
+        envs$FindNeighbors$reduction <- sobj@misc$integrated_new_reduction %||% "pca"
+        sobj <- do_call(FindNeighbors, envs$FindNeighbors)
+        cached$data <- list(graphs = sobj@graphs, commands = sobj@commands)
+        save_to_cache(cached, "FindNeighbors", cache_dir)
+    } else {
+        log_info("Loading cached FindNeighbors ...")
+        sobj@graphs <- cached$data$graphs
+        sobj@commands <- cached$data$commands
+    }
+
+    sobj
+}
+
+run_findclusters <- function(sobj) {
+    cached <- get_cached(
+        list(sobj = sobj, FindClusters = envs$FindClusters),
+        "FindClusters",
+        cache_dir
+    )
+    if (is.null(cached$data)) {
+        findclusters_args <- envs$FindClusters
+        findclusters_args$random.seed <- findclusters_args$random.seed %||% 8525
+        resolution <- findclusters_args$resolution <- expand_resolution(findclusters_args$resolution %||% 0.8)
+        log_info("Running FindClusters at resolution: {paste(resolution, collapse=',')} ...")
+
+        findclusters_args$object <- sobj
+        findclusters_args$cluster.name <- paste0("seurat_clusters.", resolution)
+        sobj <- do_call(FindClusters, findclusters_args)
+
+        for (clname in findclusters_args$cluster.name) {
+            sobj@meta.data[[clname]] <- recode_clusters(sobj@meta.data[[clname]])
+        }
+        sobj@meta.data$seurat_clusters <- recode_clusters(sobj@meta.data$seurat_clusters)
+        Idents(sobj) <- "seurat_clusters"
+
+        ident_table <- table(Idents(sobj))
+        log_info("- Found {length(ident_table)} clusters at resolution {resolution[length(resolution)]}")
+        print(ident_table)
+        cat("\n")
+
+        cached$data <- list(
+            clusters = sobj@meta.data[, c(findclusters_args$cluster.name, "seurat_clusters"), drop = FALSE],
+            commands = sobj@commands
+        )
+        save_to_cache(cached, "FindClusters", cache_dir)
+    } else {
+        log_info("Loading cached FindClusters ...")
+
+        sobj <- AddMetaData(sobj, metadata = cached$data$clusters)
+        Idents(sobj) <- "seurat_clusters"
+        sobj@commands <- cached$data$commands
+    }
+
+    sobj
+}
+
+run_prepsctfindmarkers <- function(sobj) {
+    if (DefaultAssay(sobj) == "SCT") {
+        cached <- get_cached(list(sobj = sobj), "PrepSCTFindMarkers", cache_dir)
+        if (is.null(cached$data)) {
+            # https://github.com/satijalab/seurat/issues/6968
+            log_info("Running PrepSCTFindMarkers ...")
+            sobj <- PrepSCTFindMarkers(sobj)
+            # compose a new SeuratCommand to record it to sobj@commands
+            scommand <- sobj@commands$FindClusters
+            scommand@name <- "PrepSCTFindMarkers"
+            scommand@time.stamp <- Sys.time()
+            scommand@assay.used <- "SCT"
+            scommand@call.string <- "PrepSCTFindMarkers(object = sobj)"
+            scommand@params <- list()
+            sobj@commands$PrepSCTFindMarkers <- scommand
+
+            cached$data <- sobj
+            save_to_cache(cached, "PrepSCTFindMarkers", cache_dir)
+        } else {
+            log_info("Loading cached PrepSCTFindMarkers ...")
+            sobj <- cached$data
+        }
+    }
+
+    sobj
+}

biopipen/scripts/scrna/SeuratClustering.R

@@ -1,5 +1,5 @@
-source("{{biopipen_dir}}/utils/misc.R")
-source("{{biopipen_dir}}/utils/caching.R")
+{{ biopipen_dir | joinpaths: "utils", "misc.R" | source_r }}
+{{ biopipen_dir | joinpaths: "utils", "caching.R" | source_r }}
 
 library(Seurat)
 library(future)
@@ -7,7 +7,6 @@ library(rlang)
 library(tidyr)
 library(dplyr)
 library(digest)
-library(clustree)
 
 set.seed(8525)
 
@@ -24,16 +23,10 @@ options(str = strOptions(vec.len = 5, digits.d = 5))
 options(future.globals.maxSize = 80000 * 1024^2)
 plan(strategy = "multicore", workers = envs$ncores)
 
-.expand_dims <- function(args, name = "dims") {
-    # Expand dims from 30 to 1:30
-    if (is.numeric(args[[name]]) && length(args[[name]] == 1)) {
-        args[[name]] <- 1:args[[name]]
-    }
-    args
-}
+{{ biopipen_dir | joinpaths: "scripts", "scrna", "SeuratClustering-common.R" | source_r }}
 
-envs$RunUMAP <- .expand_dims(envs$RunUMAP)
-envs$FindNeighbors <- .expand_dims(envs$FindNeighbors)
+envs$RunUMAP <- expand_dims(envs$RunUMAP)
+envs$FindNeighbors <- expand_dims(envs$FindNeighbors)
 
 log_info("Reading Seurat object ...")
 sobj <- readRDS(srtfile)
@@ -53,164 +46,11 @@ if (is.character(envs$cache)) {
     writeLines(sobj_sig, file.path(cache_dir, "signature.txt"))
 }
 
-if (length(envs$ScaleData) > 0) {
-    if (DefaultAssay(sobj) == "SCT") {
-        stop("SCT assay detected, but ScaleData is specified. Use SCTransform instead.")
-    }
-    cached <- get_cached(envs$ScaleData, "ScaleData", cache_dir)
-    if (is.null(cached$data)) {
-        log_info("Running ScaleData ...")
-        envs$ScaleData$object <- sobj
-        sobj <- do_call(ScaleData, envs$ScaleData)
-        cached$data <- list(assay = sobj@assays$RNA, commands = sobj@commands)
-        save_to_cache(cached, "ScaleData", cache_dir)
-    } else {
-        log_info("Loading cached ScaleData ...")
-        sobj@assays$RNA <- cached$data$assay
-        sobj@commands <- cached$data$commands
-        DefaultAssay(sobj) <- "RNA"
-    }
-} else if (length(envs$SCTransform) > 0) {
-    if (DefaultAssay(sobj) != "SCT") {
-        stop("SCT assay not detected, but SCTransform is specified. Use ScaleData instead.")
-    }
-    cached <- get_cached(envs$SCTransform, "SCTransform", cache_dir)
-    asssay <- envs$SCTransform$new.assay.name %||% "SCT"
-    if (is.null(cached$data)) {
-        log_info("Running SCTransform ...")
-        envs$SCTransform$object <- sobj
-        sobj <- do_call(SCTransform, envs$SCTransform)
-        cached$data <- list(assay = sobj@assays$SCT, commands = sobj@commands)
-        save_to_cache(cached, "SCTransform", cache_dir)
-    } else {
-        log_info("Loading cached SCTransform ...")
-        sobj@assays[[assay]] <- cached$data$assay
-        sobj@commands <- cached$data$commands
-        DefaultAssay(sobj) <- assay
-    }
-}
-
-cached <- get_cached(envs$RunUMAP, "RunUMAP", cache_dir)
-reduc_name <- envs$RunUMAP$reduction.name %||% "umap"
-if (is.null(cached$data)) {
-    log_info("Running RunUMAP ...")
-    umap_args <- list_setdefault(
-        envs$RunUMAP,
-        object = sobj,
-        dims = 1:30,
-        reduction = sobj@misc$integrated_new_reduction %||% "pca"
-    )
-    ncells <- ncol(sobj)
-    umap_args$dims <- 1:min(max(umap_args$dims), ncells - 1)
-    umap_method <- envs$RunUMAP$umap.method %||% "uwot"
-    if (umap_method == "uwot" && is.null(envs$RunUMAP$n.neighbors)) {
-        # https://github.com/satijalab/seurat/issues/4312
-        umap_args$n.neighbors <- min(ncells - 1, 30)
-    }
-    sobj <- do_call(RunUMAP, umap_args)
-    cached$data <- list(reduc = sobj@reductions[[reduc_name]], commands = sobj@commands)
-    save_to_cache(cached, "RunUMAP", cache_dir)
-} else {
-    log_info("Loading cached RunUMAP ...")
-    sobj@reductions[[reduc_name]] <- cached$data$reduc
-    sobj@commands <- cached$data$commands
-}
-
-cached <- get_cached(envs$FindNeighbors, "FindNeighbors", cache_dir)
-if (is.null(cached$data)) {
-    log_info("Running FindNeighbors ...")
-    envs$FindNeighbors$object <- sobj
-    envs$FindNeighbors$reduction <- sobj@misc$integrated_new_reduction %||% "pca"
-    sobj <- do_call(FindNeighbors, envs$FindNeighbors)
-    cached$data <- list(graphs = sobj@graphs, commands = sobj@commands)
-    save_to_cache(cached, "FindNeighbors", cache_dir)
-} else {
-    log_info("Loading cached FindNeighbors ...")
-    sobj@graphs <- cached$data$graphs
-    sobj@commands <- cached$data$commands
-}
-
-envs$FindClusters$random.seed <- envs$FindClusters$random.seed %||% 8525
-expand_resolution <- function(resolution) {
-    expanded_res <- c()
-    for (res in resolution) {
-        if (is.numeric(res)) {
-            expanded_res <- c(expanded_res, res)
-        } else {
-            # is.character
-            parts <- trimws(unlist(strsplit(res, ",")))
-            for (part in parts) {
-                if (grepl(":", part)) {
-                    parts <- trimws(unlist(strsplit(part, ":")))
-                    if (length(parts) == 2) { parts <- c(parts, 0.1) }
-                    if (length(parts) != 3) {
-                        stop("Invalid resolution format: {part}. Expected 2 or 3 parts separated by ':' for a range.")
-                    }
-                    parts <- as.numeric(parts)
-                    expanded_res <- c(expanded_res, seq(parts[1], parts[2], by = parts[3]))
-                } else {
-                    expanded_res <- c(expanded_res, as.numeric(part))
-                }
-            }
-        }
-    }
-    # keep the last resolution at last
-    rev(unique(rev(expanded_res)))
-}
-resolution <- envs$FindClusters$resolution <- expand_resolution(envs$FindClusters$resolution %||% 0.8)
-log_info("Running FindClusters at resolution: {paste(resolution, collapse=',')} ...")
-
-envs$FindClusters$object <- sobj
-sobj <- do_call(FindClusters, envs$FindClusters)
-
-# recode clusters from 0, 1, 2, ... to c1, c2, c3, ...
-recode_clusters <- function(clusters) {
-    recode <- function(x) paste0("c", as.integer(as.character(x)) + 1)
-    clusters <- factor(recode(clusters), levels = recode(levels(clusters)))
-    clusters
-}
-
-graph_name <- envs$FindClusters$graph.name %||% paste0(DefaultAssay(sobj), "_snn_res.")
-for (res in resolution) {
-    cluster_name <- paste0(graph_name, res)
-    new_cluster_name <- paste0("seurat_clusters.", res)
-    sobj@meta.data[[new_cluster_name]] <- recode_clusters(sobj@meta.data[[cluster_name]])
-}
-sobj@meta.data$seurat_clusters <- recode_clusters(sobj@meta.data$seurat_clusters)
-Idents(sobj) <- "seurat_clusters"
-
-ident_table <- table(Idents(sobj))
-log_info("- Found {length(ident_table)} clusters at resolution {resolution[length(resolution)]}")
-print(ident_table)
-cat("\n")
-
-# plot the tree
-if (length(resolution) > 1) {
-    log_info("Plotting clustree ...")
-    png(
-        file.path(joboutdir, "clustree.png"),
-        res = envs$clustree_devpars$res,
-        width = envs$clustree_devpars$width,
-        height = envs$clustree_devpars$height
-    )
-    p <- clustree(sobj, prefix = "seurat_clusters.")
-    print(p)
-    dev.off()
-}
-
-if (DefaultAssay(sobj) == "SCT") {
-        # https://github.com/satijalab/seurat/issues/6968
-    log_info("Running PrepSCTFindMarkers ...")
-    sobj <- PrepSCTFindMarkers(sobj)
-    # compose a new SeuratCommand to record it to sobj@commands
-    scommand <- sobj@commands$FindClusters
-    scommand@name <- "PrepSCTFindMarkers"
-    scommand@time.stamp <- Sys.time()
-    scommand@assay.used <- "SCT"
-    scommand@call.string <- "PrepSCTFindMarkers(object = sobj)"
-    scommand@params <- list()
-    sobj@commands$PrepSCTFindMarkers <- scommand
-}
+sobj <- run_transformation(sobj)
+sobj <- run_umap(sobj)
+sobj <- run_findneighbors(sobj)
+sobj <- run_findclusters(sobj)
+sobj <- run_prepsctfindmarkers(sobj)
 
 log_info("Saving results ...")
 saveRDS(sobj, file = rdsfile)