Seurat

https://satijalab.org/seurat
Admin
Seurat is an R package designed for quality control, analysis, and exploration of single-cell...
Tokens:444,016
Snippets:3,800
Trust Score:9.7
Update:2 days ago
Show doc for...
Tokens:
Raw
### Install SeuratData and ifnb dataset

Source: https://satijalab.org/seurat/articles/integration_rpca

Loads the Seurat and SeuratData libraries and installs the 'ifnb' dataset required for the RPCA integration example.

```R
library(Seurat)
library(SeuratData)
# install dataset
InstallData("ifnb")
```

--------------------------------

### Example: Get HVF info from SCTAssay object

Source: https://satijalab.org/seurat/reference/hvfinfo.sctassay

Example usage wrapped in a dontrun block. It runs SCTransform on pbmc_small, then calls HVFInfo on the SCT assay with method 'sct' and prints the first 5 rows.

```r
if (FALSE) { # \dontrun{
# Get the HVF info directly from an SCTAssay object
pbmc_small <- SCTransform(pbmc_small)
HVFInfo(pbmc_small[["SCT"]], method = 'sct')[1:5, ]
} # }
```

--------------------------------

### Load Seurat libraries and example datasets

Source: https://satijalab.org/seurat/articles/essential_commands

Loads Seurat, ggplot2, and SeuratData, installs and loads example datasets (pbmc3k, cbmc, ifnb), and sets the number of threads for parallelization.

```R
library(Seurat)
library(ggplot2)
library(SeuratData)

# install datasets from SeuratData
InstallData("pbmc3k")
InstallData("cbmc")
InstallData("ifnb")

# load in pbmc example
pbmc <- LoadData("pbmc3k")

# load in multimodal example type ?cbmc for more info
cbmc <- LoadData("cbmc")

# load in case/control example type ?ifnb for more info
ifnb <- LoadData("ifnb")

# set the number of threads used for parallelization see ?setThreads for more details
setThreads(4)
```

--------------------------------

### Install pbmcMultiome dataset with SeuratData

Source: https://satijalab.org/seurat/articles/seurat5_atacseq_integration_vignette

Installs the pbmcMultiome dataset from SeuratData. Run this before loading the data.

```R
library(SeuratData)
# install the dataset and load requirements
InstallData("pbmcMultiome")
```

--------------------------------

### Example: Load10X_Spatial usage

Source: https://satijalab.org/seurat/reference/load10x_spatial

Example code showing how to load a Visium spatial dataset. The example is wrapped in if (FALSE) to prevent execution during package checks. It sets the data directory, lists files to verify the H5 file, and calls Load10X_Spatial.

```R
if (FALSE) { # \dontrun{
data_dir <- 'path/to/data/directory'
list.files(data_dir) # Should show filtered_feature_bc_matrix.h5
Load10X_Spatial(data.dir = data_dir)
} # }
```

--------------------------------

### Install and load the bmcite dataset

Source: https://satijalab.org/seurat/articles/weighted_nearest_neighbor_analysis

Installs the bmcite dataset via SeuratData and loads it into the object 'bm'. Requires SeuratData to be installed.

```R
InstallData("bmcite")
bm <- LoadData(ds = "bmcite")
```

--------------------------------

### Install and load BANKSY and SeuratWrappers

Source: https://satijalab.org/seurat/articles/visiumhd_analysis_vignette

Installs BANKSY from GitHub if not already installed, then loads SeuratWrappers and Banksy. Required before running RunBanksy.

```R
if (!requireNamespace("Banksy", quietly = TRUE)) {
  remotes::install_github("prabhakarlab/Banksy@devel")
}
library(SeuratWrappers)
library(Banksy)
```

--------------------------------

### Install and Load Slide-seq Data with SeuratData

Source: https://satijalab.org/seurat/articles/spatial_vignette

Install the ssHippo dataset from SeuratData and load it into a Seurat object. After installation, type ?ssHippo to see the commands used to create the object.

```R
InstallData("ssHippo")
```

```R
slide.seq <- LoadData('ssHippo')
```

--------------------------------

### Install development version of Seurat from GitHub

Source: https://satijalab.org/seurat/articles/install_v5

Installs the development version of Seurat from GitHub. May require restarting R after installation to avoid conflicts.

```R
# Enter commands in R (or R studio, if installed)
# Install the remotes package
install.packages('remotes')
remotes::install_github(repo = 'satijalab/seurat', ref = 'main')
library(Seurat)
```

--------------------------------

### Basic DoHeatmap example

Source: https://satijalab.org/seurat/reference/doheatmap

Minimal example using the pbmc_small dataset to create a heatmap of feature expression.

```R
data("pbmc_small")
DoHeatmap(object = pbmc_small)
```

--------------------------------

### ExpMean example with output

Source: https://satijalab.org/seurat/reference/expmean

Example of calling ExpMean with a vector c(1, 2, 3) and the resulting output 2.308994.

```r
ExpMean(x = c(1, 2, 3))
#> [1] 2.308994
```

--------------------------------

### NormalizeData example with pbmc_small

Source: https://satijalab.org/seurat/reference/normalizedata

Example usage of NormalizeData on the pbmc_small dataset. The example is wrapped in a dontrun block, so it is not executed by default. It loads the data, prints it, and normalizes it.

```r
if (FALSE) { # \dontrun{
data("pbmc_small")
pbmc_small
pmbc_small <- NormalizeData(object = pbmc_small)
} # }
```

--------------------------------

### Install the ifnb dataset from SeuratData

Source: https://satijalab.org/seurat/articles/integration_introduction

Installs the ifnb dataset package using InstallData(). Required before loading the dataset.

```R
# install dataset
InstallData("ifnb")
```

--------------------------------

### Install BPCells from GitHub

Source: https://satijalab.org/seurat/articles/seurat5_bpcells_interaction_vignette

Installs the BPCells R package from the bnprks GitHub repository using devtools::install_github().

```R
devtools::install_github("bnprks/BPCells")
```

--------------------------------

### ReadVitessce example with remote data

Source: https://satijalab.org/seurat/reference/readvitessce

Example usage of ReadVitessce with remote URLs for counts, coords, and molecules. The example is wrapped in a dontrun block, so it is not executed during package checks. It demonstrates how to read data and then inspect the returned list components.

```r
if (FALSE) { # \dontrun{
coords <- ReadVitessce(
  counts =
     "https://s3.amazonaws.com/vitessce-data/0.0.31/master_release/wang/wang.genes.json",
  coords =
     "https://s3.amazonaws.com/vitessce-data/0.0.31/master_release/wang/wang.cells.json",
  molecules =
     "https://s3.amazonaws.com/vitessce-data/0.0.31/master_release/wang/wang.molecules.json"
)
names(coords)
coords$counts[1:10, 1:10]
head(coords$centroids)
head(coords$segmentations)
head(coords$molecules)
} # }
```

--------------------------------

### ExpVar example with output

Source: https://satijalab.org/seurat/reference/expvar

Example of calling ExpVar with a numeric vector, showing the returned variance in log-space.

```r
ExpVar(x = c(1, 2, 3))
#> [1] 4.403948
```

--------------------------------

### ExpSD example with output

Source: https://satijalab.org/seurat/reference/expsd

Example call to ExpSD with a vector of values, and the resulting standard deviation in log-space.

```r
ExpSD(x = c(1, 2, 3))
#> [1] 2.301323
```

--------------------------------

### Install stxBrain dataset from SeuratData

Source: https://satijalab.org/seurat/articles/spatial_vignette

Installs the stxBrain dataset from SeuratData for easy access to the Visium mouse brain data.

```R
InstallData("stxBrain")
```

--------------------------------

### Example: Prepare pancreas datasets for integration with PrepSCTIntegration

Source: https://satijalab.org/seurat/reference/prepsctintegration

Complete example workflow from the documentation. It loads the panc8 dataset, splits it by tech, performs SCTransform normalization, selects integration features, calls PrepSCTIntegration, and then runs FindIntegrationAnchors and IntegrateData. The example is wrapped in if (FALSE) { # \dontrun{ ... } # } to prevent execution during package checks.

```r
if (FALSE) { # \dontrun{
# to install the SeuratData package see https://github.com/satijalab/seurat-data
library(SeuratData)
data("panc8")

# panc8 is a merged Seurat object containing 8 separate pancreas datasets
# split the object by dataset and take the first 2 to integrate
pancreas.list <- SplitObject(panc8, split.by = "tech")[1:2]

# perform SCTransform normalization
pancreas.list <- lapply(X = pancreas.list, FUN = SCTransform)

# select integration features and prep step
features <- SelectIntegrationFeatures(pancreas.list)
pancreas.list <- PrepSCTIntegration(
  pancreas.list,
  anchor.features = features
)

# downstream integration steps
anchors <- FindIntegrationAnchors(
  pancreas.list,
  normalization.method = "SCT",
  anchor.features = features
)
pancreas.integrated <- IntegrateData(anchors, normalization.method = "SCT")
} # }
```

--------------------------------

### Create data directory and navigate into it

Source: https://satijalab.org/seurat/articles/visiumhd_analysis_cell_segmentations

Creates a directory named 'visium_hd_human_kidney' and changes into it to prepare for downloading the Visium HD dataset.

```bash
mkdir -p visium_hd_human_kidney
cd visium_hd_human_kidney
```

--------------------------------

### BuildClusterTree usage example with pbmc_small

Source: https://satijalab.org/seurat/reference/buildclustertree

Example wrapped in if(FALSE) and dontrun, requiring the 'ape' package. It loads pbmc_small, builds the cluster tree, and retrieves the result via Tool().

```r
if (FALSE) { # \dontrun{
if (requireNamespace("ape", quietly = TRUE)) {
  data("pbmc_small")
  pbmc_small
  pbmc_small <- BuildClusterTree(object = pbmc_small)
  Tool(object = pbmc_small, slot = 'BuildClusterTree')
}
} # }
```

--------------------------------

### LabelPoints example with pbmc_small

Source: https://satijalab.org/seurat/reference/labelpoints

Example usage of LabelPoints on a Seurat object. It loads the pbmc_small dataset, gets top features and cells from PCA, creates a FeatureScatter plot, and labels the top cells.

```r
data("pbmc_small")
ff <- TopFeatures(object = pbmc_small[['pca']])
cc <- TopCells(object = pbmc_small[['pca']])
plot <- FeatureScatter(object = pbmc_small, feature1 = ff[1], feature2 = ff[2])
LabelPoints(plot = plot, points = cc)
```

--------------------------------

### Example usage with pbmc_small

Source: https://satijalab.org/seurat/reference/vizdimloadings

Example of calling VizDimLoadings on the pbmc_small dataset. The output shows warnings that the requested number of features exceeds the available items, which are automatically set to 20.

```r
data("pbmc_small")
VizDimLoadings(object = pbmc_small)
#> Warning: Requested number is larger than the number of available items (20). Setting to 20.
#> Warning: Requested number is larger than the number of available items (20). Setting to 20.
#> Warning: Requested number is larger than the number of available items (20). Setting to 20.
#> Warning: Requested number is larger than the number of available items (20). Setting to 20.
#> Warning: Requested number is larger than the number of available items (20). Setting to 20.
```

--------------------------------

### Get cell names with Cells() and colnames()

Source: https://satijalab.org/seurat/articles/seurat5_essential_commands

Shows how to get cell names of the default assay with Cells() and across the entire object with colnames(). The example subsets the RNA assay to create an RNAsub assay and sets it as default.

```R
pbmc3k[["RNAsub"]] <- subset(pbmc3k[["RNA"]], cells = colnames(pbmc3k)[1:100])
DefaultAssay(pbmc3k) <- 'RNAsub'
length(Cells(pbmc3k))
length(colnames(pbmc3k))
```

--------------------------------

### ReadMtx usage example for local and remote files

Source: https://satijalab.org/seurat/reference/readmtx

Example usage of ReadMtx for local files and remote URLs. The local example reads gzipped files and creates a Seurat object. The remote example reads from HTTP URLs. Note the example is wrapped in a dontrun block.

```r
if (FALSE) { # \dontrun{
# For local files:

expression_matrix <- ReadMtx(
  mtx = "count_matrix.mtx.gz", features = "features.tsv.gz",
  cells = "barcodes.tsv.gz"
)
seurat_object <- CreateSeuratObject(counts = expression_matrix)

# For remote files:

expression_matrix <- ReadMtx(mtx = "http://localhost/matrix.mtx",
cells = "http://localhost/barcodes.tsv",
features = "http://localhost/genes.tsv")
seurat_object <- CreateSeuratObject(counts = data)
} # }
```

--------------------------------

### Example: Prepare merged SCT object and run FindMarkers

Source: https://satijalab.org/seurat/reference/prepsctfindmarkers

Complete workflow: create two SCT objects, merge them, apply PrepSCTFindMarkers, then run FindMarkers on the full merged object and on a subset. The output messages show SCTransform progress and the 'Minimum UMI unchanged' note.

```r
data("pbmc_small")
pbmc_small1 <- SCTransform(object = pbmc_small, variable.features.n = 20, vst.flavor="v1")
#> Running SCTransform on assay: RNA
#> Calculating cell attributes from input UMI matrix: log_umi
#> Variance stabilizing transformation of count matrix of size 220 by 80
#> Model formula is y ~ log_umi
#> Get Negative Binomial regression parameters per gene
#> Using 220 genes, 80 cells
#> Skip calculation of full residual matrix
#> Calculating gene attributes
#> Wall clock passed: Time difference of 1.37565 secs
#> 
Computing: [========================================] 100% (done)                         
#> Place corrected count matrix in counts slot
#> Set default assay to SCT
pbmc_small2 <- SCTransform(object = pbmc_small, variable.features.n = 20, vst.flavor="v1")
#> Running SCTransform on assay: RNA
#> Calculating cell attributes from input UMI matrix: log_umi
#> Variance stabilizing transformation of count matrix of size 220 by 80
#> Model formula is y ~ log_umi
#> Get Negative Binomial regression parameters per gene
#> Using 220 genes, 80 cells
#> Skip calculation of full residual matrix
#> Calculating gene attributes
#> Wall clock passed: Time difference of 1.219658 secs
#> 
Computing: [========================================] 100% (done)                         
#> Place corrected count matrix in counts slot
#> Set default assay to SCT
pbmc_merged <- merge(x = pbmc_small1, y = pbmc_small2)
#> Warning: Some cell names are duplicated across objects provided. Renaming to enforce unique cell names.
pbmc_merged <- PrepSCTFindMarkers(object = pbmc_merged)
#> Minimum UMI unchanged. Skipping re-correction.
markers <- FindMarkers(
  object = pbmc_merged,
  ident.1 = "0",
  ident.2 = "1",
  assay = "SCT"
)
pbmc_subset <- subset(pbmc_merged, idents = c("0", "1"))
markers_subset <- FindMarkers(
  object = pbmc_subset,
  ident.1 = "0",
  ident.2 = "1",
  assay = "SCT",
  recorrect_umi = FALSE
)
```

--------------------------------

### Install and load spacexr for RCTD

Source: https://satijalab.org/seurat/articles/visiumhd_analysis_vignette

Installs the spacexr package from GitHub if not already installed, then loads it. This is required to run RCTD deconvolution.

```R
if (!requireNamespace("spacexr", quietly = TRUE)) {
  devtools::install_github("dmcable/spacexr", build_vignettes = FALSE)
}
library(spacexr)
```

--------------------------------

### MinMax example with matrix

Source: https://satijalab.org/seurat/reference/minmax

Creates a random matrix and applies MinMax with min=4 and max=5, showing the input and output matrices.

```r
mat <- matrix(data = rbinom(n = 25, size = 20, prob = 0.2 ), nrow = 5)
mat
#>      [,1] [,2] [,3] [,4] [,5]
#> [1,]    7    2    6    1    1
#> [2,]    6    2    2    7    5
#> [3,]    7    5    3    2    4
#> [4,]    7    3    1    2    4
#> [5,]    6    1    5    2    2
MinMax(data = mat, min = 4, max = 5)
#>      [,1] [,2] [,3] [,4] [,5]
#> [1,]    5    4    5    4    4
#> [2,]    5    4    4    5    5
#> [3,]    5    5    4    4    4
#> [4,]    5    4    4    4    4
#> [5,]    5    4    5    4    4
```

--------------------------------

### Example: BuildClusterTree and PlotClusterTree

Source: https://satijalab.org/seurat/reference/plotclustertree

Example usage that builds a cluster tree on the pbmc_small dataset and plots it. Wrapped in a dontrun block and requires the ape package.

```r
if (FALSE) { # \dontrun{
if (requireNamespace("ape", quietly = TRUE)) {
  data("pbmc_small")
  pbmc_small <- BuildClusterTree(object = pbmc_small)
  PlotClusterTree(object = pbmc_small)
}
} # }
```

--------------------------------

### Install and load AzimuthAPI for Pan-human Azimuth

Source: https://satijalab.org/seurat/articles/visiumhd_analysis_cell_segmentations

Installs the AzimuthAPI package from GitHub if not already installed, then loads it. Required for accessing Pan-human Azimuth in R.

```R
if (!requireNamespace("AzimuthAPI", quietly = TRUE)) {
  remotes::install_github("satijalab/AzimuthAPI")
}

library(AzimuthAPI)
```

--------------------------------

### Example: PCASigGenes with pbmc_small

Source: https://satijalab.org/seurat/reference/pcasiggenes

Loads the pbmc_small dataset and calls PCASigGenes with pcs.use = 1:2. The output shows the resulting significant genes.

```R
data("pbmc_small")
PCASigGenes(pbmc_small, pcs.use = 1:2)
#>  [1] "PPBP"     "VDAC3"    "CD1C"     "AKR1C3"   "PF4"      "MYL9"    
#>  [7] "GNLY"     "TREML1"   "CA2"      "SDPR"     "PGRMC1"   "S100A8"  
#> [13] "TUBB1"    "HLA-DQA1" "PARVB"    "RUFY1"    "HLA-DPB1" "S100A9"  
```

--------------------------------

### Install PBMC 3k dataset with SeuratData

Source: https://satijalab.org/seurat/articles/visualization_vignette

Installs the pbmc3k dataset package using SeuratData::InstallData(). Required before loading the data.

```R
SeuratData::InstallData("pbmc3k")
```

--------------------------------

### RPCA Integration Workflow with Preprocessing and Variations

Source: https://satijalab.org/seurat/reference/rpcaintegration

Complete workflow for RPCA integration in Seurat, starting with preprocessing (LoadData, split, NormalizeData, FindVariableFeatures, ScaleData, RunPCA) and then running IntegrateLayers with RPCAIntegration. Includes reference-based integration using the first layer as reference, modifying k.anchor to 20, and integrating SCTransformed data. All examples are wrapped in if (FALSE) { # \dontrun{ ... } # } to prevent execution during R CMD check.

```R
if (FALSE) { # \dontrun{
# Preprocessing
obj <- SeuratData::LoadData("pbmcsca")
obj[["RNA"]] <- split(obj[["RNA"]], f = obj$Method)
obj <- NormalizeData(obj)
obj <- FindVariableFeatures(obj)
obj <- ScaleData(obj)
obj <- RunPCA(obj)

# After preprocessing, we run integration
obj <- IntegrateLayers(object = obj, method = RPCAIntegration,
  orig.reduction = "pca", new.reduction = 'integrated.rpca',
  verbose = FALSE)

# Reference-based Integration
# Here, we use the first layer as a reference for integraion
# Thus, we only identify anchors between the reference and the rest of the datasets,
# saving computational resources
obj <- IntegrateLayers(object = obj, method = RPCAIntegration,
  orig.reduction = "pca", new.reduction = 'integrated.rpca',
  reference = 1, verbose = FALSE)

# Modifying parameters
# We can also specify parameters such as `k.anchor` to increase the strength of
# integration
obj <- IntegrateLayers(object = obj, method = RPCAIntegration,
  orig.reduction = "pca", new.reduction = 'integrated.rpca',
  k.anchor = 20, verbose = FALSE)

# Integrating SCTransformed data
obj <- SCTransform(object = obj)
obj <- IntegrateLayers(object = obj, method = RPCAIntegration,
  orig.reduction = "pca", new.reduction = 'integrated.rpca',
  assay = "SCT", verbose = FALSE)
} # }
```

--------------------------------

### FindConservedMarkers example usage

Source: https://satijalab.org/seurat/reference/findconservedmarkers

Example usage of FindConservedMarkers on the pbmc_small dataset. It creates a simulated grouping variable and then finds conserved markers between clusters 0 and 1. The example is wrapped in a dontrun block.

```r
if (FALSE) { # \dontrun{
data("pbmc_small")
pbmc_small
# Create a simulated grouping variable
pbmc_small[['groups']] <- sample(x = c('g1', 'g2'), size = ncol(x = pbmc_small), replace = TRUE)
FindConservedMarkers(pbmc_small, ident.1 = 0, ident.2 = 1, grouping.var = "groups")
} # }
```

--------------------------------

### SplitObject example with pbmc_small

Source: https://satijalab.org/seurat/reference/splitobject

Demonstrates splitting the pbmc_small dataset by a custom metadata attribute 'group'. The example assigns random groups to cells, adds the metadata, and then splits the object into a list of subsetted objects.

```R
data("pbmc_small")
# Assign the test object a three level attribute
groups <- sample(c("group1", "group2", "group3"), size = 80, replace = TRUE)
names(groups) <- colnames(pbmc_small)
pbmc_small <- AddMetaData(object = pbmc_small, metadata = groups, col.name = "group")
obj.list <- SplitObject(pbmc_small, split.by = "group")
```

--------------------------------

### Output of head(pbmc@meta.data, 5)

Source: https://satijalab.org/seurat/articles/pbmc3k_tutorial.html

Example output from the head() command, showing the metadata table with columns orig.ident, nCount_RNA, nFeature_RNA, and percent.mt for the first five cells.

```text
##                  orig.ident nCount_RNA nFeature_RNA percent.mt
## AAACATACAACCAC-1     pbmc3k       2419          779  3.0177759
## AAACATTGAGCTAC-1     pbmc3k       4903         1352  3.7935958
## AAACATTGATCAGC-1     pbmc3k       3147         1129  0.8897363
## AAACCGTGCTTCCG-1     pbmc3k       2639          960  1.7430845
## AAACCGTGTATGCG-1     pbmc3k        980          521  1.2244898
```

--------------------------------

### HTOHeatmap example usage

Source: https://satijalab.org/seurat/reference/htoheatmap

Example of running HTOHeatmap after HTODemux. The example is wrapped in a dontrun block, indicating it is not executed during package checks. It assumes 'object' is a Seurat object with HTO data already processed.

```r
if (FALSE) { # \dontrun{
object <- HTODemux(object)
HTOHeatmap(object)
} # }
```

--------------------------------

### Example: Using GetTransferPredictions after TransferData

Source: https://satijalab.org/seurat/reference/gettransferpredictions

Example usage wrapped in a dontrun block. It transfers predictions using TransferData, stores the prediction assay, and then adds the predicted identity to the query object. The example is not run by default.

```r
if (FALSE) { # \dontrun{
  prediction.assay <- TransferData(anchorset = anchors, refdata = reference$class)
  query[["predictions"]] <- prediction.assay
  query$predicted.id <- GetTransferPredictions(query)
} # }
```

--------------------------------

### FilterSlideSeq example usage

Source: https://satijalab.org/seurat/reference/filterslideseq

Example of using FilterSlideSeq on the ssHippo dataset from SeuratData. It loads the data, filters beads with a radius of 2300, and notes that the radius may need adjustment. The example is wrapped in a dontrun block.

```r
if (FALSE) { # \dontrun{
# This example uses the ssHippo dataset which you can download
# using the SeuratData package.
library(SeuratData)
data('ssHippo')
# perform filtering of beads
ssHippo.filtered <- FilterSlideSeq(ssHippo, radius = 2300)
# This radius looks to small so increase and repeat until satisfied
} # }
```

--------------------------------

### Harmony integration example with preprocessing and parameter modification

Source: https://satijalab.org/seurat/reference/harmonyintegration

Example workflow for integrating layers with Harmony. It includes preprocessing steps (loading data, splitting, normalizing, finding variable features, scaling, PCA), then calls IntegrateLayers with HarmonyIntegration. It also shows modifying the theta parameter and integrating SCTransformed data. This example is wrapped in a dontrun block and requires the harmony package.

```r
if (FALSE) { # \dontrun{
# Preprocessing
obj <- SeuratData::LoadData("pbmcsca")
obj[["RNA"]] <- split(obj[["RNA"]], f = obj$Method)
obj <- NormalizeData(obj)
obj <- FindVariableFeatures(obj)
obj <- ScaleData(obj)
obj <- RunPCA(obj)

# After preprocessing, we integrate layers with added parameters specific to Harmony:
obj <- IntegrateLayers(object = obj, method = HarmonyIntegration, orig.reduction = "pca",
  new.reduction = 'harmony', verbose = FALSE)

# Modifying Parameters
# We can also add arguments specific to Harmony such as theta, to give more diverse clusters
obj <- IntegrateLayers(object = obj, method = HarmonyIntegration, orig.reduction = "pca",
  new.reduction = 'harmony', verbose = FALSE, theta = 3)
# Integrating SCTransformed data
obj <- SCTransform(object = obj)
obj <- IntegrateLayers(object = obj, method = HarmonyIntegration,
  orig.reduction = "pca", new.reduction = 'harmony',
  assay = "SCT", verbose = FALSE)
} # }
```

--------------------------------

### VlnPlot usage examples

Source: https://satijalab.org/seurat/reference/vlnplot

Example code showing how to create violin plots with VlnPlot. The first example plots PC_1, the second plots LYZ split by groups, and includes a message about the changed default behavior of split.by.

```r
data("pbmc_small")
VlnPlot(object = pbmc_small, features = 'PC_1')

VlnPlot(object = pbmc_small, features = 'LYZ', split.by = 'groups')
#> The default behaviour of split.by has changed.
#> Separate violin plots are now plotted side-by-side.
#> To restore the old behaviour of a single split violin,
#> set split.plot = TRUE.
#>       
#> This message will be shown once per session.
```

--------------------------------

### RunCCA example with pbmc_small

Source: https://satijalab.org/seurat/reference/runcca

Example usage of RunCCA on the pbmc_small dataset. It splits the object into two subsets, assigns group labels, runs CCA, and prints the results. This example is wrapped in a dontrun block, so it is not executed automatically.

```r
if (FALSE) { # \dontrun{
data("pbmc_small")
pbmc_small
# As CCA requires two datasets, we will split our test object into two just for this example
pbmc1 <- subset(pbmc_small, cells = colnames(pbmc_small)[1:40])
pbmc2 <- subset(pbmc_small, cells = colnames(x = pbmc_small)[41:80])
pbmc1[["group"]] <- "group1"
pbmc2[["group"]] <- "group2"
pbmc_cca <- RunCCA(object1 = pbmc1, object2 = pbmc2)
# Print results
print(x = pbmc_cca[["cca"]])
} # }
```

--------------------------------

### PrepSCTIntegration()

Source: https://satijalab.org/seurat/reference/

Prepare an object list normalized with sctransform for integration.

```APIDOC
## PrepSCTIntegration()

### Description
Prepare an object list normalized with sctransform for integration.

### Usage
PrepSCTIntegration(object.list, ...)

### Arguments
- **object.list** (list of Seurat objects) - Required - A list of Seurat objects.
- **...** - Optional - Additional arguments passed to the function.

### Value
Returns a list of Seurat objects prepared for integration.
```

--------------------------------

### Basic VariableFeaturePlot example

Source: https://satijalab.org/seurat/reference/variablefeatureplot

Example usage of VariableFeaturePlot with the pbmc_small dataset. Loads the data and creates the plot.

```R
data("pbmc_small")
VariableFeaturePlot(object = pbmc_small)
```

--------------------------------

### TopFeatures example with pbmc_small

Source: https://satijalab.org/seurat/reference/topfeatures

Demonstrates calling TopFeatures on the PCA reduction of the pbmc_small dataset, first without projection and then with projected = TRUE. The output shows the top 20 features for dimension 1.

```r
data("pbmc_small")
pbmc_small
#> An object of class Seurat 
#> 230 features across 80 samples within 1 assay 
#> Active assay: RNA (230 features, 20 variable features)
#>  3 layers present: counts, data, scale.data
#>  2 dimensional reductions calculated: pca, tsne
TopFeatures(object = pbmc_small[["pca"]], dim = 1)
#>  [1] "HLA-DPB1"      "HLA-DQA1"      "S100A9"        "S100A8"       
#>  [5] "GNLY"          "RP11-290F20.3" "CD1C"          "AKR1C3"       
#>  [9] "IGLL5"         "VDAC3"         "PARVB"         "RUFY1"        
#> [13] "PGRMC1"        "MYL9"          "TREML1"        "CA2"          
#> [17] "TUBB1"         "PPBP"          "PF4"           "SDPR"         
# After projection:
TopFeatures(object = pbmc_small[["pca"]], dim = 1,  projected = TRUE)
#>  [1] "HLA-DPB1"      "HLA-DQA1"      "S100A9"        "S100A8"       
#>  [5] "GNLY"          "RP11-290F20.3" "CD1C"          "AKR1C3"       
#>  [9] "IGLL5"         "VDAC3"         "PARVB"         "RUFY1"        
#> [13] "PGRMC1"        "MYL9"          "TREML1"        "CA2"          
#> [17] "TUBB1"         "PPBP"          "PF4"           "SDPR"         
```
Tokens:
Raw