+00c816c)32f800c)docs(version): Automatic development release (0548007)
docs: Adding changelog (34b1e0b)
docs(version): Automatic development release (184b4f9)
docs(version): Automatic development release (b8b41d3)
docs(version): Automatic development release (f420a3b)
docs(version): Automatic development release (8b5cc98)
Update test files for Harmony and Annotation, add GitHub page image (5c19124)
fix: add skip on CI for harmony (3268a82)
fix: Suppress warning for celldex, move CI handle for test Harmony, a… (30de884)
Update CD (76e59b4)
docs: Adding changelog (7c5bcf2)
Update repo structure for CD implementation (ca27382)
Update repo structure for Continuous Deployment implementation (fab9424)
Merge remote-tracking branch 'origin/main' into dev (c850a61)
Merge pull request #43 from NIDAP-Community/revert-42-testCD2
Revert "Test cd2" (dbd1511)
Revert "Test cd2" (82c3208)
Merge pull request #42 from ruiheesi/testCD2
Test cd2 (696718c)
Release dev (93dac20)
Dev (f094e92)
Test cd2 (89850c1)
Merge remote-tracking branch 'origin/dev' into testCD2 (429581c)
feat :test (10b3e05)
Merge pull request #14 from ruiheesi/dev
Dev (c932c71)
Test cd2 (da01ac7)
Release dev (447457a)
Dev (e4a2987)
fix: update readme (a3f0d9c)
Release dev (4026e1a)
Dev (4364548)
test: update meta.ymal (fe470f9)
Dev (4e75a9f)
test: update meta.ymal (caed439)
Dev (9f27de1)
test: mute line42 in test-Process_Raw_Data (abef880)
feat: enable CD (0194dd9)
Updating dev to avoid potential lost of progress (8936388)
8 4 tutorial (c640c8f)
Merge branch '8_4_tutorial' of https://github.com/NIDAP-Community/SCWorkflow into 8_4_tutorial (be8b11f)
Just for tutorial (b667bb0)
test (d8bc63c)
Fixing visualization for "after" plot (d7bb90f)
Merge pull request #36 from NIDAP-Community/dev
Dev (0b66085)
Fix heatmap (49f0486)
Fix heatmap (db3ee4e)
Merge pull request #34 from NIDAP-Community/release_6_15_test
Update DESCRIPTION file with author info and short package description (31a4d13)
Update DESCRIPTION file (df2abd7)
Update DESCRIPTION file (5e43253)
Adding auto-generated files (14ff346)
Merge pull request #31 from NIDAP-Community/release_6_13
Update 6 13 from Alexei (e2297c6)
Run all unit tests (407ca8f)
Update (2891614)
Modify package function load (370522e)
Including "NULL" and "seurat_cluster" tests (8cb6a23)
Introducing "cluster" variable functionality (e26f2aa)
Modify package function load (fe7ad65)
Adding auto-generated files (e65ad6b)
Merge pull request #26 from NIDAP-Community/release_test
Passed all tests (4a40802)
Run all unit test (4979266)
Update Plot_Metadata (573b57a)
Update ModuleScore (4367b28)
Update NAMESPACE (77240ed)
Merge changes (b9226e0)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main
Conflicts: NAMESPACE tests/testthat/fixtures/downsample_SO.R (d4b92fe)
update documentation (19b7179)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main (ca74b58)
delete old files (b5b2d1d)
Removed test-Pseudobulk_DEG.R and test-Sample_Names.R (877fa28)
Removed test-Meta_Data.R (975face)
Merge branch 'main' into phil_6_6_no_NG (f638db9)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main (77c1f03)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main
need to update violinPlot subset function (41f805e)
update violinPlot subset function (0609899)
Remove old tests (6ca9164)
udate PBMC sing Filtered rds (516a9df)
Fix Test Error (7641655)
fix Test error (e97494a)
Merge branch 'main' into phil_6_6_no_NG (d7fd7c8)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main (1e52f51)
Setting add.gene.or.protein to TRUE - will error out on FALSE (2e0a153)
Merge branch 'main' into phil_6_6_no_NG (d61ce1d)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main (cd90fbb)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main (b44581b)
bug fix on heatmap sort by annotation (8d09781)
Merge branch 'main' into phil_6_6_no_NG (986bcdf)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main (8fab93f)
changed select_crobject to selectCRObject (b7446a6)
Update Seurate importing method in process raw (846ac5d)
Trigger check and update latest main (2b575eb)
Merge branch 'main' into phil_6_6_no_NG (aab0562)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main (b786ed1)
Removed gene from Seurat (d5d17ac)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main (e7f08eb)
Bug fix for dual labeling (9eede5b)
Fixed bug in Dual Labeling and added one more plot output (contingency table) (0b17248)
Test direct import seurat in process raw (3bd763b)
Trigger action, updated process raw to import Seurat (2e46082)
Trigger action, updated cc.gene (84acd38)
Trigger action, updated NAMESPACE (a968d2d)
Trigger action (b38dd32)
Trigger action (05e9be4)
Update NAMESPACE (d7015e6)
Merge branch 'main' into phil_6_6_no_NG (d9ba725)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main (5559288)
Trigger unit tests (99ae357)
Add Filtered rds (666c3d8)
update Variable descriptions (43e05f5)
update Variable descriptions (3fd169b)
reverting from clusters to barcodes for merging (f561e2f)
Trigger unit test (a668ef9)
Trigger unit test (1c48c37)
Merge branch 'main' into phil_6_6_no_NG (ada4aab)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main (aa254f1)
Update NAMESPACE (dc6152b)
rn h5 test (d398586)
Fixing "All" cluster label (18bbdc8)
Removing "latent variable" from a test script (1839cdd)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main
Conflicts: NAMESPACE R/Combine_and_Renormalize.R R/Filter_and_QC.R R/PCA_and_Normalization.R R/Post_filter_QC_Plots.R tests/testthat/fixtures/NSCLC_Single/NSCLC_Single_Filtered_PCA_Norm_SO_downsample.rds tests/testthat/fixtures/NSCLC_Single/NSCLC_Single_Filtered_SO_downsample.rds tests/testthat/fixtures/NSCLC_Single/NSCLCsingle_Filtered_PCA_Norm_SO_downsample.rds tests/testthat/fixtures/NSCLC_Single/NSCLCsingle_Filtered_SO_downsample.rds tests/testthat/fixtures/PBMC_Single/PBMC_Single_Filtered_PCA_Norm_SO_downsample.rds tests/testthat/fixtures/PBMC_Single/PBMC_Single_Filtered_SO_downsample.rds tests/testthat/fixtures/downsample_SO.R tests/testthat/test_Combine_and_Renormalize.R tests/testthat/test_Filter_and_QC.R tests/testthat/test_PCA_and_Normalization.R tests/testthat/test_Post_Filter_QC.R (92eae54)
FiltQC Variable Descriptions (4aa0674)
New RAW filtQC CombNorm (7aa1a24)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main
Conflicts: NAMESPACE R/Post_filter_QC_Plots.R tests/testthat/test_Post_Filter_QC.R (4fd27d2)
Conflicts: man/Combine_and_Renormalize.Rd man/Post_filter_QC.Rd (159af06)
skip on ci on reticulate pacakge (549f205)
skip on ci on reticulate pacakge (75412d7)
Edited snapshot tests (a316ad3)
Edited snapshot tests (cf00505)
update pseudobulk helper (fd0a506)
update pseudobulk helper (7f8060e)
add pseudobulk helper and test scripts (122f072)
add pseudobulk helper and test scripts (27a49ec)
update functions and tests (c7ddbf8)
update functions and tests (c201dd7)
Removing "latent var" and replacing second.clust (67c3aea)
Removing "latent var" and replacing second.clust (9c16231)
Quick test for CI (e71339c)
Quick test for CI (73c62ca)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main (b600bf0)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main (8bb7502)
Added color selection to 3D-tsne Plotter (2882b76)
Added color selection to 3D-tsne Plotter (f7decbc)
Added a "cached" CellDex option (2cabb8d)
Added a "cached" CellDex option (c913672)
fixed NAMESPACE conflicts (f2aa02f)
fixed NAMESPACE conflicts (797ab6d)
Changed pheatmap to ComplexHeatmap::pheatmap (5c9316b)
Changed pheatmap to ComplexHeatmap::pheatmap (414723d)
Code Review (03f4392)
Code Review (b2724c8)
Removed LICENCE file in the description (e2affa9)
Removed LICENCE file in the description (8c3154e)
Minor fixes for R CMD CHECK (134523f)
Minor fixes for R CMD CHECK (c1eb410)
Fix syntax error
At line 200, fix syntax error from "=" to "==" (2916381)
At line 200, fix syntax error from "=" to "==" (d909584)
Helper for Recluster, Sprint 7 compliant. (d5181f9)
Helper for Recluster, Sprint 7 compliant. (8f28252)
New test for Recluster with correct name. (bf252e2)
New test for Recluster with correct name. (0d88348)
Old file w bad name gone. New file good. (e903ca0)
Old file w bad name gone. New file good. (0e0d81e)
Re-arranged for new Sprint 7 formatting and functions. (2c07bcb)
Re-arranged for new Sprint 7 formatting and functions. (e670fe9)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main
need to push updated code to main (20f0ab7)
need to push updated code to main (189075c)
push updated scripts to main (ed4b682)
push updated scripts to main (f70b090)
Restructured according to new requirements (94b0170)
Restructured according to new requirements (797d5be)
Restructured according to new requirements (495be93)
Restructured according to new requirements (7e53872)
Restructured according to new requirements (6043df1)
Restructured according to new requirements (5efd01d)
Restructured according to new requirements (8465a9e)
Restructured according to new requirements (75be9d0)
Restructured according to new requirements (8c4739b)
Restructured according to new requirements (8a39e82)
Restructured according to new requirements (2ccad56)
Restructured according to new requirements (4770cf7)
Restructured according to new requirements (8762e39)
Restructured according to new requirements (c21ca07)
Restructured according to new requirements (b9dfed4)
Restructured according to new requirements (9cc27d3)
Restructured according to new requirements (656b12e)
Restructured according to new requirements (2989dbe)
Restructured according to new requirements (bf8dcb1)
Restructured according to new requirements (d11a692)
Restructured according to new requirements (95693f6)
Restructured according to new requirements (da04b19)
Restructured according to new requirements (6dca0bf)
Restructured according to new requirements (de6b4da)
Restructured according to new requirements (8f4ea59)
Restructured according to new requirements (1741342)
Restructured according to new requirements (f522e45)
Restructured according to new requirements (dc8cfe2)
Restructured according to new requirements (b2235b0)
Restructured according to new requirements (6f4bd6d)
Delete test-DegGeneExpressionMarkers.R
Replaced with newer, renamed version (237eacf)
Replaced with newer, renamed version (ee510b7)
Accepted changes to Namespace (b0ef9e7)
Accepted changes to Namespace (70d880f)
Removed ticks on dotplot code (d6599be)
Removed ticks on dotplot code (3b4a6e0)
Added select to dplyr import (1311aae)
Added select to dplyr import (c860639)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main (8759676)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main (28e310b)
Added snapshot file tests to Name clusters (1a0c530)
Added snapshot file tests to Name clusters (de98847)
Added more snapshot tests to heatmap (3f138a4)
Added more snapshot tests to heatmap (1fe2d7b)
Additional snapshot file tests for dual labeling (8d92fcf)
Additional snapshot file tests for dual labeling (580ab8d)
Additional tests to dotplot by metadata (fbc3ada)
Additional tests to dotplot by metadata (b7f6c45)
Adding expect snapshot file tests to 3D-tSNE plotter (8f33e2b)
Adding expect snapshot file tests to 3D-tSNE plotter (661102c)
Formatting changes to helper-dual labeling (8f5da99)
Formatting changes to helper-dual labeling (266dec8)
Formatting changes to helper - Name clusters (5a6079f)
Formatting changes to helper - Name clusters (cfc8b69)
Formatting changes to helper-Heatmap (abd3f09)
Formatting changes to helper-Heatmap (1ca0e49)
Formatting changes to helper-dotplot by Metadata (321e619)
Formatting changes to helper-dotplot by Metadata (69653cb)
Formatting changes to helper 3D-tSNE (8be697c)
Formatting changes to helper 3D-tSNE (c1835c2)
Formatting changes to Dotplot by Metadata (7dbbc99)
Formatting changes to Dotplot by Metadata (d994b6c)
Code changes to Name clusters and formatting (70a9fc2)
Code changes to Name clusters and formatting (bca98aa)
Formatting changes to Heatmap.R (e1bd5c7)
Formatting changes to Heatmap.R (f47e847)
Add files via upload
replace image file (7bf9b80)
replace image file (542b65d)
additional text (700ad07)
additional text (2e0feec)
Added image. (7694f8d)
Added image. (f28a6a7)
Workflow image (f93175b)
Workflow image (433a89d)
Create README.md (70aa926)
Create README.md (0b318e5)
formatting for dual labeling (2e7d12c)
formatting for dual labeling (f782199)
format 3D-tSNE function (fe97cb0)
format 3D-tSNE function (4ae1381)
Update gitflow-R-action.yml (9bdcf6c)
Update gitflow-R-action.yml (7799784)
update Dotplot conflict (0ea5f42)
update Dotplot conflict (e99ac9b)
Update (aa71a29)
Update (3dfcdb5)
Adding action files and dockerfiles (d215fdb)
Adding action files and dockerfiles (1cbab8e)
Resolving git conflict in Recluster. (0c70bdb)
Resolving git conflict in Recluster. (28d7b96)
committing in-progress Sugarloaf updates to Recluster SO template. (ed03d46)
committing in-progress Sugarloaf updates to Recluster SO template. (446af26)
changed fixture filenames (71ebc2f)
changed fixture filenames (6e3284c)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main (f5590de)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main (219746d)
edit code formatting (1a7a120)
edit code formatting (2676adc)
Initial TestThat for Recluster
Includes tests on all 5 datasets testing type, as well as one test on MouseTEC that tests UMAP instead of default TSNE. (4da52a7)
Includes tests on all 5 datasets testing type, as well as one test on MouseTEC that tests UMAP instead of default TSNE. (da7c560)
Initial R4 functionalization. (7558379)
Initial R4 functionalization. (84acb8c)
Add files via upload
Initial release (3eca944)
Initial release (deafd1c)
Initial release (77b96a6)
Initial release (91b7594)
Initial commit (4a74c89)
Initial commit (9d694ae)
Initial release (fa2e7c3)
Initial release (25d5857)
Initial release (69d1dcf)
Initial release (900ab4c)
Delete DEG_Gene_Expression_Markers.R (5496f85)
Delete DEG_Gene_Expression_Markers.R (fe406ea)
Add files via upload
Initial release (ea9b264)
Initial release (45fd8d2)
Initial release (c2e8e8c)
Initial release (fee817b)
Initial release (55fd6c9)
Initial release (a59a2bc)
Initial release (ad72a95)
Initial release (aac8353)
Initial release (a0c5606)
Initial release (c31a9f2)
Delete DeletMeAgain (d2436b6)
Delete DeletMeAgain (4514dae)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main (9ce4628)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main (2a53ebc)
CommLine Test (82aa0fa)
CommLine Test (811846c)
Delete Delete.Me
Following the orders (6b41c15)
Following the orders (1f82ca7)
DELETE IMMEDIATELY!!! (986326c)
DELETE IMMEDIATELY!!! (ea68f0a)
Initial release (2c12ea5)
Initial release (a294bd3)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main (a276a80)
Recover code from past commit (184c917)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main
update function and parameter names. (83fbdd1)
update function and parameter names. (6f46e6e)
reformat function and parameter names (0dfca6c)
reformat function and parameter names (c81712f)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main (eac38ce)
Merge pull request #9 from NIDAP-Community/Rui_resolve_conflict
Resolve conflicts (7fa7db9)
Resolve conflicts (7839aba)
Resolve conflicts (d516cd2)
Resolve conflicts (8c776b1)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main (0a5942a)
Update main on local branch (b27d7af)
Merge pull request #8 from NIDAP-Community/phi_test
Phi test (2d5e7ec)
Phi test (87fdb1a)
resolve conflict (b4d8548)
resolve conflict (a3ddae1)
Merge branch 'main' into phi_test (e22b5e6)
Add ignore h5 files in gitignore (55c3167)
resolve conflicts (43976ba)
resolve error (d59173b)
Update current directory (f7e242b)
Downsampled CITEseq (bdfa1f3)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main Correct CITEseq Downsmple (4d643f4)
correct CITEseq Downsample (3f032fd)
helper script for 3D-tsne (12ee9f3)
helper script for 3D-tsne (30b7146)
helper script for 3D-tsne (a901830)
new tests (1ce5664)
new tests (29d75bc)
new tests (9cb29d2)
unit test Jing templates (bb48481)
unit test Jing templates (63a6636)
unit test Jing templates (97d74ca)
NSCLCmulti SO (3d42d4a)
NSCLCmulti SO (540bdf3)
NSCLCmulti SO (6e8e596)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main
Update Chariou Single R SO and BRCA combin and Renormalize (e851077)
Update Chariou Single R SO and BRCA combin and Renormalize (072096f)
Update Chariou Single R SO and BRCA combin and Renormalize (1a8fbf8)
BRCA comb_Renorm (5e3985b)
BRCA comb_Renorm (9fb63a3)
BRCA comb_Renorm (6d4c05a)
unit tests for Name Clusters (95cf6f5)
unit tests for Name Clusters (c7ed110)
unit tests for Name Clusters (43859bd)
unit test for dual labeling (46dd45e)
unit test for dual labeling (3f07269)
unit test for dual labeling (5c85127)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main
merging new changes (b8b1eda)
merging new changes (09c8f46)
merging new changes (729b051)
unit tests for heatmap, dotplot (7659b83)
unit tests for heatmap, dotplot (b81287c)
unit tests for heatmap, dotplot (5414455)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main
adding NSCLC_Single SOs (152cf11)
adding NSCLC_Single SOs (b0ea506)
adding NSCLC_Single SOs (d83c561)
NSCLC_single SO (df265cd)
NSCLC_single SO (ad62924)
NSCLC_single SO (7d0b242)
add dotplot tests (57166ba)
add dotplot tests (b2bd01e)
add dotplot tests (69fec28)
unit test for Dotplot (a94f7ba)
unit test for Dotplot (13fb938)
unit test for Dotplot (9c67e81)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main
new error messaging added (b09cb64)
new error messaging added (d266d5e)
new error messaging added (c0aaa1b)
new error messaging to dotplot (9742c5f)
new error messaging to dotplot (a9bf495)
new error messaging to dotplot (93a3a06)
changes to dotplot (1849346)
changes to dotplot (b52dc29)
changes to dotplot (d4c0824)
Charou SO (dccaf54)
Charou SO (95b3421)
Charou SO (1f3ca66)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main
Conflicts: .gitignore DESCRIPTION tests/testthat/test_Filter_and_QC.R (c58b92e)
Conflicts: .gitignore DESCRIPTION tests/testthat/test_Filter_and_QC.R (8a845be)
Conflicts: .gitignore DESCRIPTION tests/testthat/test_Filter_and_QC.R (bb18f4c)
The conda package build requires a NAMESPACE file to be added, which is being ignored during the dev cycle. (e7ac125)
The conda package build requires a NAMESPACE file to be added, which is being ignored during the dev cycle. (0027492)
The conda package build requires a NAMESPACE file to be added, which is being ignored during the dev cycle. (4f3bbc8)
Dev release dec 13 22 (02999db)
Dev release dec 13 22 (6ec32fa)
Dev release dec 13 22 (2e0f434)
Initial Commit for sprint 5 Functions. Including change to DESCRIPTION file (4384dd1)
Initial Commit for sprint 5 Functions. Including change to DESCRIPTION file (eeb7741)
Initial Commit for sprint 5 Functions. Including change to DESCRIPTION file (90120cb)
Minor fix for codes to pass Check (3b4f7ee)
Minor fix for codes to pass Check (29de7d6)
Minor fix for codes to pass Check (b65e314)
Updated tests (733e2ec)
Updated tests (c9ed47b)
Updated tests (97e18e5)
update NameClusters function and test (128fbb4)
update NameClusters function and test (3f90257)
update NameClusters function and test (c88161e)
update test-Metadata_Table.R (a37474b)
update test-Metadata_Table.R (4257cc6)
update test-Metadata_Table.R (7b2f599)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main (78fc249)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main (cce3673)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main (986e82b)
small changes in 3D plotter testing (74364db)
small changes in 3D plotter testing (a60aa38)
small changes in 3D plotter testing (7ac6a75)
changed heatmap test and added library to heatmap (cb33cf2)
changed heatmap test and added library to heatmap (bcab3c2)
changed heatmap test and added library to heatmap (20f7260)
revised test for dual labeling (b5caf02)
revised test for dual labeling (0f39220)
revised test for dual labeling (d1b47d6)
new doc for dotplot (b986ccc)
new doc for dotplot (800edc4)
new doc for dotplot (acd4514)
changes to test and added color option (493b745)
changes to test and added color option (b66d7fa)
changes to test and added color option (69c3c15)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main (8863d0d)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main (63fc3f6)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main (8fa25f6)
add original citation for Pseudobulk.R (4293f96)
add original citation for Pseudobulk.R (53add2e)
add original citation for Pseudobulk.R (7b99980)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main (9abcb98)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main (940e610)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main (fb13a18)
add functions for heatmap, dotplot, 3d-tsne and dual-labeling (0ed4df7)
add functions for heatmap, dotplot, 3d-tsne and dual-labeling (74fe2ad)
add functions for heatmap, dotplot, 3d-tsne and dual-labeling (44338d2)
update ModScore Pseudobulk and DESCRIPTION (aefedde)
update ModScore Pseudobulk and DESCRIPTION (abe0919)
update ModScore Pseudobulk and DESCRIPTION (ec95f0c)
fix NAMESPACE @importFrom methods empty (756de4e)
fix NAMESPACE @importFrom methods empty (2f2bd5a)
fix NAMESPACE @importFrom methods empty (5984060)
Update Description (3dcc872)
Update Description (968b204)
Update Description (1f05120)
Merge pull request #6 from NIDAP-Community/rui
Rui (c09fa3f)
Rui (5d3d3b2)
Rui (e71621d)
update man docs (bf9fb25)
update man docs (c08890f)
update man docs (98e86e3)
add NameCluster function and tests (dbe4d15)
add NameCluster function and tests (5812a98)
add NameCluster function and tests (233dd75)
update MetadataTable & SampleNames (b3f19d8)
update MetadataTable & SampleNames (175fa43)
update MetadataTable & SampleNames (1d921a2)
drop unused factor levels in SO_moduleScore.rds (3a39fcf)
drop unused factor levels in SO_moduleScore.rds (133d872)
drop unused factor levels in SO_moduleScore.rds (ea6df85)
Jing templates and fixtures (08532bf)
Jing templates and fixtures (9f84531)
Jing templates and fixtures (150df39)
add SampleNames .R and .Rd files (9f16588)
add SampleNames .R and .Rd files (780b298)
add SampleNames .R and .Rd files (446d631)
update MetadataTable (615afdc)
update MetadataTable (44abfce)
update MetadataTable (a27296a)
Unit test added to 3d tsne function (3ab8d75)
Unit test added to 3d tsne function (6dc17bd)
Unit test added to 3d tsne function (e032618)
rui update 1 (9011356)
rui update 1 (81793d8)
rui update 1 (7006ac8)
add man/MetadataTable.Rd (af8eedf)
add man/MetadataTable.Rd (7830b05)
add man/MetadataTable.Rd (61457e8)
upload fixtures/SO_moduleScore.rds (78caf56)
upload fixtures/SO_moduleScore.rds (07bc42d)
upload fixtures/SO_moduleScore.rds (b3b3dc4)
correct DESCRIPTION tibble (57847f5)
correct DESCRIPTION tibble (fe89882)
correct DESCRIPTION tibble (90dd394)
update DESCRIPTION (f55cf25)
update DESCRIPTION (fcf6d26)
update DESCRIPTION (7d3e4ef)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main (be5cff8)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main (0d74815)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main (58aa02a)
add MetadataTable function (42c3569)
add MetadataTable function (50e3af0)
add MetadataTable function (09b995d)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main (01921d5)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main (795043f)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main (70082b0)
removed NAMESPACE from repo (dc422fa)
removed NAMESPACE from repo (d528f76)
removed NAMESPACE from repo (f7f5da5)
removed Rcheck.txt (8b70481)
removed Rcheck.txt (e0a6384)
removed Rcheck.txt (e23003a)
Added Git ignore and update R check results, 11_16_2022 (ce18e14)
Added Git ignore and update R check results, 11_16_2022 (e705893)
Added Git ignore and update R check results, 11_16_2022 (1d8a95c)
Update DESCRIPTION (7fdea8e)
Update DESCRIPTION (0d266f4)
Update DESCRIPTION (5effd23)
Update cc.genes calls (797aca1)
Update cc.genes calls (3db02b2)
Update cc.genes calls (65f805b)
Update cc.genes calls (8cd8b03)
Update cc.genes calls (82a4244)
Update cc.genes calls (ea8e671)
Update library call (423fbe9)
Update library call (f52a89c)
Update library call (a3d302b)
Update namespace (a4230b7)
Update namespace (d35dc0e)
Update namespace (0a8e2a9)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main (272c0ec)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main (8558d4f)
Merge branch 'main' of https://github.com/NIDAP-Community/SCWorkflow into main (83f6f23)
Update namespace (9960214)
Update namespace (3d85b8d)
Update namespace (b8c8b0e)
Merge pull request #5 from NIDAP-Community/initial_filter_qc
Adjusted png render method for NIDAP display (33820ce)
Adjusted png render method for NIDAP display (770cb6a)
Adjusted png render method for NIDAP display (12b4ce3)
Adjusted png render method for NIDAP display (0b9e4d2)
Adjusted png render method for NIDAP display (9968f1f)
Adjusted png render method for NIDAP display (747b89a)
Merge pull request #4 from NIDAP-Community/initial_filter_qc
Update namespace (bcc1c7f)
Update namespace (61952ec)
Update namespace (ac05afc)
Update namespace (fdcfd52)
Update namespace (f070d8e)
Update namespace (fd74f19)
Merge pull request #3 from NIDAP-Community/initial_filter_qc
Added license file (a3a99b6)
Added license file (5c508c3)
Added license file (d5113f3)
Added license file (186d183)
Added license file (a8bd74c)
Added license file (1d7ed13)
Merge pull request #2 from NIDAP-Community/initial_filter_qc
remove GenomeInfoDb (fe8164b)
remove GenomeInfoDb (75ae5fd)
remove GenomeInfoDb (8908e24)
remove GenomeInfoDb (f3bb0e6)
remove GenomeInfoDb (2b32d4e)
remove GenomeInfoDb (b27279e)
Merge pull request #1 from NIDAP-Community/initial_filter_qc
Initial push with filter and qc, demo (866a648)
Initial push with filter and qc, demo (a30130b)
Initial push with filter and qc, demo (b627f06)
Initial push with filter and qc, demo (a843d4d)
Initial push with filter and qc, demo (dcd9fef)
Initial push with filter and qc, demo (462a39d)
Update README.md
Changed package name (acb154c)
Changed package name (fdffdf4)
YEAR: 2024 +COPYRIGHT HOLDER: NIDAP Community ++ +
MIT License
+Copyright (c) 2024 NIDAP Community
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ + +CONTRIBUTING.RmdIf you are a member of CCBR, +you can clone this repository to your computer or development +environment.
+SCWorkflow is a large repository so this may take a few minutes.
+ +++ +Cloning into ‘SCWorkflow’…
+
remote: Enumerating objects: 3126, +done.
remote: Counting objects: 100% (734/734), done.
remote: +Compressing objects: 100% (191/191), done.
remote: Total 3126 +(delta 630), reused 545 (delta 543), pack-reused 2392 (from 1)
+Receiving objects: 100% (3126/3126), 1.04 GiB | 4.99 MiB/s, done.
+Resolving deltas: 100% (1754/1754), done.
Updating files: 100% +(306/306), done.
If this is your first time cloning the repo you may have to install +dependencies
+ +Check R CMD: In an R console, make sure the package +passes R CMD check by running:
+
+ devtools::check()++ +⚠️ Note: If R CMD check doesn’t pass cleanly, it’s a +good idea to ask for help before continuing.
+
In an R console, load the package from the local repo using:
+
+devtools::load_all()Create a Git branch for your pull request (PR). Give the branch a +descriptive name for the changes you will make.
+Example: Use iss-10 if it’s for a
+specific issue, or feature-new-plot for a new feature.
For bug fixes or small changes, you can branch from the
+main branch.
++Success: Switched to a new branch ‘iss-10’
+
For new features or larger changes, branch from the DEV
+branch.
# Switch to DEV branch, create a new branch, and switch to new branch
+git switch DEV
+git branch feature-new-plot
+git switch feature-new-plot++Success: Switched to a new branch +‘feature-new-plot’
+
Now you’re ready to edit the code, write unit tests, and update the +documentation as needed.
+New code should follow the general guidelines outlined here. +- Important: Don’t restyle code unrelated to your +PR
+Tools to help: - Use the styler package to +apply these styles
+Key conventions from the tidyverse style +guide:
+| Element | +Style | +Example | +
|---|---|---|
| Variables | +snake_case | +my_variable |
+
| Functions | +verbs in camelCase | +processData() |
+
| Assignment | +
+<- operator |
+x <- 5 |
+
| Operations | +pipes | +data %>% filter() %>% mutate() |
+
Structure your functions like this:
+Functions should follow this template. Use roxygen2 for +documentation:
+
+#' @title Function Title
+#' @description Brief description of what the function does
+#' @param param1 Description of first parameter
+#' @param param2 Description of second parameter
+#' @details Additional details if needed
+#' @importFrom package function_name
+#' @export
+#' @return Description of what the function returns
+
+yourFunction <- function(param1, param2) {
+
+ ## --------- ##
+ ## Functions ##
+ ## --------- ##
+
+ ## --------------- ##
+ ## Main Code Block ##
+ ## --------------- ##
+
+ output_list <- list(
+ object = SeuratObject,
+ plots = list(
+ 'plotTitle1' = p1,
+ 'plotTitle2' = p2
+ ),
+ data = list(
+ 'dataframeTitle' = df1
+ )
+ )
+
+ return(output_list)
+}Best practices for commits:
+We recommend following the “atomic commits” +principle where each commit contains one new feature, fix, or task.
+Learn more: Atomic +Commits Guide
+Your commit message should follow the Conventional
+Commits specification. Briefly, each commit should start with one of
+the approved types such as feat, fix,
+docs, etc. followed by a description of the commit. Take a
+look at the Conventional
+Commits specification for more detailed information about how to
+write commit messages.
If this is the first time you are pushing this branch, you may have +to explicitly set the upstream branch:
+ +We recommend pushing your commits often so they will be backed up on
+GitHub. You can view the files in your branch on GitHub at
+https://github.com/NIDAP-Community/SCWorkflow/tree/<your-branch-name>
+(replace <your-branch-name> with the actual name of
+your branch).
Why tests matter: Most changes to the code will also +need unit tests to demonstrate that the changes work as intended.
+How to add tests:
+testthat
+to create your unit testsWhen to update documentation:
+How to update documentation:
+🔍 Final validation step:
+After making your changes, run the following command from an R +console to make sure the package still passes R CMD check:
+
+devtools::check()++Goal: All checks should pass with no errors, +warnings, or notes.
+
Once your branch is ready, create a PR on GitHub: https://github.com/NIDAP-Community/SCWorkflow/pull/new/
+Select the branch you just pushed:
+
Edit the PR title and description. The title should briefly describe
+the change. Follow the comments in the template to fill out the body of
+the PR, and you can delete the comments (everything between
+<!-- and -->) as you go. When you’re
+ready, click ‘Create pull request’ to open it.

Optionally, you can mark the PR as a draft if you’re not yet ready +for it to be reviewed, then change it later when you’re ready.
+We will do our best to follow the tidyverse code review principles: +https://code-review.tidyverse.org/. The reviewer may +suggest that you make changes before accepting your PR in order to +improve the code quality or style. If that’s the case, continue to make +changes in your branch and push them to GitHub, and they will appear in +the PR.
+Once the PR is approved, the maintainer will merge it and the +issue(s) the PR links will close automatically. Congratulations and +thank you for your contribution!
+Intro.RmdThe CCBR Single-cell RNA-seq Package (SCWorkflow) allows users to +analyze their own single-cell RNA-seq datasets starting from CellRanger +output files (H5 or mtx files, etc.).
+You can install the SCWorkflow package from GitHub +with:
+
+# install.packages("remotes")
+remotes::install_github("NIDAP-Community/SCWorkflow", dependencies = TRUE)There is also a Docker container available at
+Following this workflow you can perform these steps of a single-cell +RNA-seq analysis, and more:
+Quality Control:
+Import, Select, & Rename Samples
Filter Cells based on QC metrics
Combine Samples, Cluster, and Normalize your Data
Batch Correction using Harmony
Cell Annotation:
+SingleR Automated Annotations
Module Scores
Co-Expression
External Annotations
Visualizations:
+Dimensionality Reductions (t-SNE and UMAP Plots) colored by +Marker Expression or by Metadata
Heatmaps
Violin Plots
Trajectory
Differential Expression Analysis
+Seurat’s FindMarkers()
Pseudobulk Aggregation
Pathway Analysis
Please see the introductory +vignette for a quick start tutorial. Take a look at the reference +documentation for detailed information on each function in the +package.
+README.RmdThe CCBR Single-cell RNA-seq Package (SCWorkflow) allows users to +analyze their own single-cell RNA-seq datasets starting from CellRanger +output files (H5 or mtx files, etc.).
+You can install the SCWorkflow package from GitHub +with:
+
+# install.packages("remotes")
+remotes::install_github("NIDAP-Community/SCWorkflow", dependencies = TRUE)There is also a Docker container available at
+Following this workflow you can perform these steps of a single-cell +RNA-seq analysis, and more:
+Quality Control:
+Import, Select, & Rename Samples
Filter Cells based on QC metrics
Combine Samples, Cluster, and Normalize your Data
Batch Correction using Harmony
Cell Annotation:
+SingleR Automated Annotations
Module Scores
Co-Expression
External Annotations
Visualizations:
+Dimensionality Reductions (t-SNE and UMAP Plots) colored by +Marker Expression or by Metadata
Heatmaps
Violin Plots
Trajectory
Differential Expression Analysis
+Seurat’s FindMarkers()
Pseudobulk Aggregation
Pathway Analysis
Please see the introductory +vignette for a quick start tutorial. Take a look at the reference +documentation for detailed information on each function in the +package.
+SCWorkflow-Annotations.RmdThis function automates cell type annotation in single-cell RNA +sequencing data by employing the SingleR [1] method, which +allocates labels to cells within a dataset according to their gene +expression profile similarities with a reference dataset containing cell +type labeled samples
+SingleR is an automatic annotation method for single-cell RNA +sequencing data that uses a given reference dataset of samples +(single-cell or bulk) with known labels to label new cells from a test +dataset based on similarity to the reference. Two mouse reference +datasets (MouseRNAseqData and ImmGenData) and two human reference +datasets (HumanPrimaryCellAtlasData and BlueprintEncodeData) from +CellDex R package [2] are currently available.
+
+
+Anno_SO=annotateCellTypes(object=Comb_SO$object,
+ species = "Mouse",
+ reduction.type = "umap",
+ legend.dot.size = 2,
+ do.finetuning = FALSE,
+ local.celldex = NULL,
+ use.clusters = NULL
+ )

This function will display co-expression of two chosen markers in +your Seurat Object. It will then Create a metadata column containing +annotations for cells that correspond to the marker expression +thresholds you set.
+This function enables users to visualize the association between two +selected genes or proteins according to their expression values in +various samples. The association is plotted, and samples with values +above or below a specified limit can be excluded. Users have the ability +to customize the visualization, including the choice of visualization +type, point size and shape, and transparency level.
+Furthermore, the tool allows for the application of filters to the +data, setting thresholds, and providing annotations to notify users if +cells meet the established thresholds. The visualization can be improved +by omitting extreme values. The tool also facilitates the creation of a +heatmap to represent the density distribution of cells and exhibit the +raw gene/protein expression values.
+
+grep("Cd4",rownames(Anno_SO$object@assays$RNA),ignore.case = T,value=T)
+
+DLAnno_SO=dualLabeling(object = Anno_SO$object,
+ samples <- c("PBS","CD8dep","ENT","NHSIL12","Combo"),
+ marker.1="Nos2",
+ marker.2="Arg1",
+ marker.1.type = "SCT",
+ marker.2.type = "SCT",
+ data.reduction = "both",
+ point.size = 0.5,
+ point.shape = 16,
+ point.transparency = 0.5,
+ add.marker.thresholds = TRUE,
+ marker.1.threshold = 0.5,
+ marker.2.threshold = 0.5,
+ filter.data = TRUE,
+ marker.1.filter.direction = "greater than",
+ marker.2.filter.direction = "greater than",
+ apply.filter.1 = TRUE,
+ apply.filter.2 = TRUE,
+ filter.condition = TRUE,
+ parameter.name = "My_CoExp",
+ trim.marker.1 = FALSE,
+ trim.marker.2 = FALSE,
+ pre.scale.trim = 0.99,
+ display.unscaled.values = FALSE
+ )
+
+plot(DLAnno_SO$plots$tsne)
+plot(DLAnno_SO$plots$umap)

This function generates plots to visualize the expression of specific +markers (genes) in single-cell RNA sequencing (scRNA-seq) data. Gene +plots are generated in the same order as they appear in the input list +(provided that they are present in the data).
+This function takes in a number of inputs to create detailed plots +showing the activity of certain genes. You can customize these based on +specific samples or genes of interest or point transparency. The code +has a built-in system to alert you if there are any issues with your +chosen inputs. If a particular gene is missing, it will return an empty +plot. If the gene is present, it will perform several steps to adjust +the data for better visualization and analysis, such as normalizing the +data and creating a reduction plot (a type of plot that helps visualize +complex data). The code also makes sure to display your chosen samples, +creates a caption for the plot indicating which samples are shown, +colors the points based on gene activity levels, and adjusts the plot’s +visual elements like transparency, size, and labels. If you haven’t +selected specific samples, it will use all the available samples from +your data. It also checks for the presence of your chosen genes in the +data and processes them to ensure uniformity across different cell +types. The output of this function is a detailed figure showing the +activity of chosen genes across different cell types. This is useful for +identifying distinct groups of cells based on gene activity levels.
+
+Marker_Table <- read.csv("Marker_Table_demo.csv")
+
+ colorByMarkerTable(object=Anno_SO$object,
+ samples.subset=c("PBS","ENT","NHSIL12", "Combo","CD8dep" ),
+ samples.to.display=c("PBS","ENT","NHSIL12", "Combo","CD8dep" ),
+ marker.table=Marker_Table,
+ cells.of.interest=c("Neutrophils","Macrophages","CD8_T" ),
+ protein.presence = FALSE,
+ assay = "SCT",
+ reduction.type = "umap",
+ point.transparency = 0.5,
+ point.shape = 16,
+ cite.seq = FALSE
+ )
Screens data for cells based on user-specified cell markers. Outputs +a seurat object with a metadata with averaged marker scores and +annotated “Likely_CellType” column.
+This function can be used to quantify the expression of marker sets +in each individual cell and (optionally) in a hierarchical manner, +helping you identify different cell types and potential +subpopulations.
+This function aids in identifying cell types based on average gene +expression. It uses a feature of the Seurat software known as the +AddModuleScore function. This function calculates the gene expression of +specific sets and records them within a designated area of the Seurat +object. The program then forecasts cell identities by comparing these +recorded scores across various gene sets. You have the ability to adjust +the identification process by designating cutoff points for a bimodal +distribution in a parameter known as manual threshold. Any thresholds +below this cutoff will not be considered during the identification +process.
+Inputs: The program takes several inputs. These +include the single-cell RNA sequencing (scRNA-seq) object, a selection +of samples for analysis, a table of gene markers for different cell +types, and optionally, a hierarchical table for directing the order of +cell classification. Data Preparation: The program +prepares the scRNA-seq object, assigns names to the samples, and selects +data based on your specified samples. Module Score +Calculation: The program calculates module scores, a measure of +gene set activity or expression [3], for each cell type based on your +provided marker table. Visualization: Density +distribution plots and colored reduction plots will be generated to help +you visualize the module scores, their relationship with cell types, and +sample identities. Thresholding: Users can select +threshold values to aid in the classification of cells. Cells with +scores below your designated threshold will be labeled as “unknown”. +Subclass Identification: If desired, the program can identify subclasses +within cell types by further analyzing subpopulations. Updating +Cell Type Labels: The program appends a “Likely_CellType” +column to the metadata of the scRNA-seq object, based on the results of +the module score analysis. Output: An updated scRNA-seq +object with new cell type labels.
+
+
+MS_object=modScore(object=Anno_SO$object,
+ marker.table=Marker_Table,
+ use.columns = c("Neutrophils","Macrophages","CD8_T" ),
+ ms.threshold=c("Neutrophils .25","Macrophages .40","CD8_T .14"),
+ general.class=c("Neutrophils","Macrophages","CD8_T"),
+ multi.lvl = FALSE,
+ reduction = "umap",
+ nbins = 10,
+ gradient.ft.size = 6,
+ violin.ft.size = 6,
+ step.size = 0.1
+ )


This function creates a dot plot of Cell Types by Renamed Clusters +and outputs a Seurat Object with a new metadata column containing these +New Cluster Names. The Cell Types are often determined by looking at the +Module Score Cell Classification calls made by the upstream Module Score +Cell Classification (see MS_Celltype metadata column).
+You must provide a table with a column containing the unique Cluster +IDs from an upstream clustering analysis (e.g. one of the SCT_snn_res_* +columns in your input Seurat Object metadata) and a column containing +the corresponding New Cluster Names you have chosen. The dot plot will +display the unique Cell Types on the x-axis and the Renamed Clusters on +the y-axis. The size of the dots show the percentage of cells in each +row (each Renamed Cluster) that was classified as each Cell Type. A +comparison of dot sizes within a row may provide insights into that +cluster’s primary Cell Type. A new metadata column named “Clusternames” +is added to the output Seurat Object that contains the New Cluster +Names.
+Methodology
+This function creates a dot plot visualization of cell types by metadata
+category (usually cluster number) from a given dataset implemented in
+the SCWorkflow package. The function allows you to update and organize
+biological data about cell clusters in a Seurat object. By changing the
+input labels, you can map custom names to the existing cluster IDs which
+will add these names to a new metadata column. It also generates a dot
+plot using Seurat’s Dotplot function [4], providing a visual
+representation of the percentage of various cell types within each
+cluster. Typically, a cluster can be more distinctively named by the
+predominant cell type as seen in the dotplot. The plot’s order can be
+customized for the clusters and cell types. If no specific order is
+provided, the function uses a default order. An optional parameter
+allows the user to make the plot interactive. The function returns the
+updated Seurat object and the plot.
+
+clstrTable <- read.table(file = "./images/Cluster_Names.txt", sep = '\t',header = T)| OriginalClusterIDs | +NewClusterNames | +
|---|---|
| 0 | +Pop0 | +
| 1 | +Pop1 | +
| 2 | +Pop2 | +
| 3 | +Pop3 | +
| 4 | +Pop4 | +
| 5 | +Pop5 | +
| 6 | +Pop6 | +
| 7 | +Pop7 | +
+
+RNC_object=nameClusters(object=Anno_SO$object,
+ cluster.identities.table=clstrTable,
+ cluster.numbers= 'OriginalClusterIDs',
+ cluster.names='NewClusterNames',
+ cluster.column ="SCT_snn_res.0.2",
+ labels.column = "mouseRNAseq_main",
+ order.clusters.by = NULL,
+ order.celltypes.by = NULL,
+ interactive = FALSE
+ )
+
+# DimPlot(MS_object, group.by = "SCT_snn_res.0.2", label = T, reduction = 'umap')
+# DimPlot(MS_object, group.by = "mouseRNAseq_main", label = T, reduction = 'umap')
+
+ggsave(RNC_object$plots, filename = "./images/RNC.png", width = 9, height = 6)
This function creates a dot plot of average gene expression values +for a set of genes in cell subpopulations defined by metadata annotation +columns. The input table contains a single column for genes (the “Genes +column”) and a single column for category (the “Category labels to plot” +column). The values in the “Category labels to plot” column should match +the values provided in the metadata function (Metadata Category to +Plot). The plot will order the genes (x-axis, left to right) and +Categories (y-axis, top to bottom) in the order in which it appears in +the input table. Any category entries omitted will not be plotted.
+The Dotplot size will reflect the percentage of cells expressing the +gene while the color will reflect the average expression for the gene. A +table showing values on the plot (either percentage of cells expressing +gene, or average expression scaled) will be returned, as selected by +user.
+Methodology
+This function creates a dot plot visualization of gene expression by
+metadata from a given dataset. It uses the Seurat package to create
+these plots. The size of the dot represents the percentage of cells
+expressing a particular gene (frequency), while the color of the dot
+indicates the average gene expression level. The function ensures that
+only unique and valid genes and categories are used. If some categories
+or genes are not found in the dataset, appropriate warnings are issued.
+The plot is then drawn with the option to reverse the x and y-axes and
+to reverse the order of metadata categories. The colors can also be
+customized. In addition to the plot, the function provides the tabular
+format of the dot plot data, which can be useful for further analysis or
+reporting. A choice of returning either the tables representing the
+percent of cells expressing a gene or the average expression level of
+the genes. This function can be useful for exploratory data analysis and
+visualizing the differences in gene expression across different
+conditions or groups of cells.
+
+FigOut=dotPlotMet(object=Anno_SO$object,
+ metadata="orig.ident",
+ cells=c("PBS","ENT","NHSIL12", "Combo","CD8dep" ),
+ markers=Marker_Table$Macrophages,
+ plot.reverse = FALSE,
+ cell.reverse.sort = FALSE,
+ dot.color = "darkblue"
+ )
Aran, D., A. P. Looney, L. Liu, E. Wu, V. Fong, A. Hsu, S. Chak, +et al. 2019. “Reference-based analysis of lung single-cell sequencing +reveals a transitional profibrotic macrophage.” Nat. Immunol. 20 (2): +163–72.
http://bioconductor.org/packages/release/data/experiment/html/celldex.html
Hao Y et al. Integrated analysis of multimodal single-cell data. +Cell. 2021 Jun 24;184(13):3573-3587.e29. doi: +10.1016/j.cell.2021.04.048. Epub 2021 May 31. PMID: 34062119; PMCID: +PMC8238499.
SCWorkflow-DEG.RmdThis function performs a DE (differential expression) analysis on a +merged Seurat object to identify expression markers between different +groups of cells (contrasts). This analysis uses the FindMarkers() +function of the Seurat Workflow.
+Methodology Differential expression analysis (DEG) +is a fundamental technique in single-cell genomics research. The goal of +DEG analysis is to identify genes that exhibit significant changes in +expression levels between different groups of cells or conditions, +thereby uncovering potential markers that distinguish these groups. This +function takes a merged Seurat object [1] as input, expected to contain +single-cell data from multiple samples, along with relevant metadata and +SingleR annotations, which provide information about cell identity. To +perform the DEG analysis, the user can choose from various statistical +algorithms, such as MAST [2], wilcox [3], bimod [4], and more, which +accommodate different types of experimental designs and assumptions +about the data. The user can control the sensitivity of the analysis by +setting the minimum fold-change in gene expression between the groups to +be considered significant. Additionally, users can specify the assay to +be used for the analysis, whether it is the scaled data (SCT) or raw RNA +counts. For best results, it is recommended to use this function with +well-curated and preprocessed single-cell data, ensuring that the Seurat +object contains relevant metadata and SingleR annotations. Users should +carefully select the samples and contrasts based on their experimental +design and research questions. Additionally, exploring different +statistical algorithms and adjusting the threshold can fine-tune the DEG +analysis and reveal more accurate gene expression markers.
+
+
+DEG_table=degGeneExpressionMarkers(object = Anno_SO$object,
+ samples = c("PBS", "ENT", "NHSIL12", "Combo", "CD8dep" ),
+ contrasts = c("0-1"),
+ parameter.to.test = "SCT_snn_res_0_2",
+ test.to.use = "MAST",
+ log.fc.threshold = 0.25,
+ assay.to.use = "SCT",
+ use.spark = F
+ )| Gene | +C_0_vs_1_pval | +C_0_vs_1_logFC | +C_0_vs_1_pct1 | +C_0_vs_1_pct2 | +C_0_vs_1_adjpval | +
|---|---|---|---|---|---|
| Cd274 | +0 | +-1.1999485 | +0.369 | +0.808 | +0 | +
| Fth1 | +0 | +-1.4170103 | +1.000 | +1.000 | +0 | +
| Mmp12 | +0 | +-3.0512305 | +0.163 | +0.635 | +0 | +
| mt-Atp6 | +0 | +0.9790296 | +1.000 | +0.984 | +0 | +
| mt-Co2 | +0 | +1.0289905 | +1.000 | +0.982 | +0 | +
| mt-Co3 | +0 | +0.9775768 | +1.000 | +0.981 | +0 | +
This function is the first step in a Pseudobulk analysis of your +scRNA-seq dataset. It groups cells based on chosen categorical +variable(s) in the Seurat Object’s Metadata and aggregates the counts of +each gene in each group.
+The output is a table of aggregate expression in which the rows are +genes and the columns are values found in the chosen Pseudobulk +variable. If you select multiple categories to aggregate by +(e.g. Category1: A,B,C and Category2: D,E,F), cells will be grouped by +combinations of category variables (e.g. A_D, A_E, A_F, B_D, B_E, B_F). +By default, gene counts are averaged across cells in each group.
+
+AggOut=aggregateCounts(object=Anno_SO$object,
+ var.group=c( "orig.ident"),
+ slot="data")
SCWorkflow-QC.RmdThis package is designed to work with the general Seurat Workflow. To +begin using the SCWorkflow tools you will have to process the h5 files +generated by the Cell Ranger software from the 10x genomics platform to +create a list of Seurat Objects[1] corresponding to each h5 file. A +Seurat Object is the basic data structure for Seurat Single Cell +analysis
+This tool supports standard scRNAseq, CITE-Seq, and TCR-Seq assays. +Samples prepared with a cell hashing protocol (HTOs) can also be +processed to produce a Seurat Object split by the corresponding +experimental design strategy. h5 files containing multiple samples can +also be processed to create Seurat objects that will be split based on +the values in the orig.ident column.
+A corresponding Metadata table can be used to add sample level +information to the Seurat object. The table format should have Sample +names in the first Column and any sample metadata in additional columns. +The Metadata table can also be used to rename samples by including an +alternative sample name Column in the metadata table.
+| Sample_Name | +Rename | +Treatment | +
|---|---|---|
| SCAF1713_1_1 | +PBS | +WT | +
| SCAF1714_2_1 | +ENT | +Entinostat | +
| SCAF1715_3_1 | +NHSIL12 | +NHS-IL12 | +
| SCAF1716_4_1 | +Combo | +Entinostat + NHS-IL12 | +
| SCAF1717_5_1 | +CD8dep | +Entinostat + NHS-IL12 | +
Samples can also be excluded from the final Seurat object using a +REGEX strategy to identify the samples to be included/excluded. explain +based on newnames
+The final Seurat Object will contain an assay slot with log2 +normalized counts. QC figures for individual samples will also be +produced to help evaluate samples quality.
+
+
+SampleMetadataTable <- read.table(file = "./images/Sample_Metadata.txt", sep = '\t',header = T)
+files=list.files(path="../tests/testthat/fixtures/Chariou/h5files",full.names = T)
+
+SOlist=processRawData(input=files,
+ sample.metadata.table=SampleMetadataTable,
+ sample.name.column="Sample_Name",
+ organism="Mouse",
+ rename.col="Rename",
+ keep=T,
+ file.filter.regex=c(),
+ split.h5=F,
+ cell.hash=F,
+ tcr.summarize.topN=10,
+ do.normalize.data=T
+)

This function will filter genes and cells based on multiple metrics +available in the Seurat Object metadata slot. A detailed guide for +single cell quality filtering can be found from Xi and Li, 2021 [2]. +First, genes can be filtered by setting the minimum number of cells +needed to keep a gene or removing VDJ Add descriptiopn of VDJ genes. +Next, cells can be filtered by setting thresholds for each individual +metric. Cells that do not meet any of the designated criteria will be +removed from the final filtered Seurat Object . Filter limits can be set +by using absolute values or median absolute deviations (MADs) for each +criteria. If both absolute and MAD values are set for a single filter, +the least extreme value (i.e. the lowest value for upper limits or the +highest value for lower limits) will be selected. The filter values used +for each metric will be printed in the log output. All filters have +default values and can be turned off by setting limits to NA.
+The individual filtering criteria used in this tool are listed +below.
+The function will return a filtered Seurat Object and various figures +showing metrics before and after filtering. These figures can be used to +help evaluate the effects of filtering criteria and whether filtering +limits need to be adjusted.
+
+
+SO_filtered=filterQC(object=SOlist$object,
+ ## Filter Genes
+ min.cells = 20,
+ filter.vdj.genes=FALSE,
+
+ ## Filter Cells
+ nfeature.limits=c(NA,NA),
+ mad.nfeature.limits=c(5,5),
+ ncounts.limits=c(NA,NA),
+ mad.ncounts.limits=c(5,5),
+ mitoch.limits = c(NA,25),
+ mad.mitoch.limits = c(NA,3),
+ complexity.limits = c(NA,NA),
+ mad.complexity.limits = c(5,NA),
+ topNgenes.limits = c(NA,NA),
+ mad.topNgenes.limits = c(5,5),
+ n.topgenes=20,
+ do.doublets.filter=TRUE
+ )


This functions combines multiple sample level Seurat Objects into a +single Seurat Object and normalizes the combined dataset. The +multi-dimensionality of the data will be summarized into a set of +“principal components” and visualized in both UMAP and tSNE projections. +A graph-based clustering approach will identify cell clusters with in +the data.
+
+
+Comb_SO=combineNormalize(
+ object=SO_filtered$object,
+ # Nomralization variables
+ npcs = 21,
+ SCT.level="Merged",
+ vars.to.regress = c("percent.mt"),
+ # FindVariableFeatures
+ nfeatures = 2000,
+ low.cut = 0.1,
+ high.cut = 8,
+ low.cut.disp = 1,
+ high.cut.disp = 100000,
+ selection.method = "vst",
+ # Dim Reduction
+ only.var.genes = FALSE,
+ draw.umap = TRUE,
+ draw.tsne = TRUE,
+ seed.for.pca = 42,
+ seed.for.tsne = 1,
+ seed.for.umap = 42,
+ # Clustering Varables
+ clust.res.low = 0.2,
+ clust.res.high = 1.2,
+ clust.res.bin = 0.2,
+ # Select PCs
+ methods.pca = NULL,
+ var.threshold = 0.1,
+ pca.reg.plot = FALSE,
+ jackstraw = FALSE,
+ jackstraw.dims=5,
+ # Other
+ exclude.sample = NULL,
+ cell.count.limit= 35000,
+ reduce.so = FALSE,
+ project.name = "scRNAProject",
+ cell.hashing.data = FALSE
+)

Hao Y et al. Integrated analysis of multimodal single-cell data. +Cell. 2021 Jun 24;184(13):3573-3587.e29. doi: +10.1016/j.cell.2021.04.048. Epub 2021 May 31. PMID: 34062119; PMCID: +PMC8238499.
Heumos, L., Schaar, A.C., Lance, C. et al. Best practices for +single-cell analysis across modalities. Nat Rev Genet (2023). https://doi.org/10.1038/s41576-023-00586-w
Germain P, Lun A, Macnair W, Robinson M (2021). “Doublet +identification in single-cell sequencing data using scDblFinder.” +f1000research. doi:10.12688/f1000research.73600.1.
SCWorkflow-SubsetReclust.RmdThis function subsets your Seurat object. Select a metadata column +and values matching the cells to pass forward in your analysis.
+
+
+filter_SO=filterSeuratObjectByMetadata(
+ object = Anno_SO$object,
+ samples.to.include = c("PBS","ENT","NHSIL12","Combo","CD8dep"),
+ sample.name = "orig.ident",
+ category.to.filter = "immgen_main",
+ values.to.filter = c("Monocytes","Macrophages","DC"),
+ keep.or.remove = FALSE,
+ greater.less.than = "greater than",
+ colors = c(
+ "aquamarine3",
+ "salmon1",
+ "lightskyblue3"),
+ seed = 10,
+ cut.off = 0.5,
+ legend.position = "right",
+ reduction = "umap",
+ plot.as.interactive.plot = FALSE,
+ legend.symbol.size = 2,
+ dot.size = 0.1,
+ number.of.legend.columns = 1,
+ dot.size.highlighted.cells = 0.5,
+ use.cite.seq.data = FALSE
+ ) 
This function provides a mechanism for re-clustering a filtered +Seurat object, a common task in single-cell RNA sequencing analysis. The +function provides options to choose the number of principal components, +range of clustering resolution, type of dimensionality reduction, and +several other parameters. The function finds variable features and +performs Principal Component Analysis (PCA). Next, dimensionality +reduction is performed using UMAP and t-SNE based on PCA, followed by +identification of nearest neighbors. It then performs clustering at +different resolutions within the provided range, creating new clustering +columns in the Seurat object. It also retains the old clustering +information, plots the clusters for each resolution and returns a list +containing the re-clustered Seurat object and the grid of clustering +plots. This function can be helpful for experimenting with different +clustering parameters especially after filtering and visually inspect +the results.
+Methodology
+This function uses methods from the Seurat package [1].
+Seurat uses a graph-based clustering method inspired by previous
+strategies, particularly those of Macosko et al [3]. It uses methods
+like SNN-Cliq and PhenoGraph [4.5], which represent cells in a graph
+structure based on similarities in feature expression patterns. The aim
+is to divide this graph into highly connected communities or clusters.
+The process begins by building a K-nearest neighbor (KNN) graph using
+Euclidean distance in PCA space. The algorithm refines the edge weights
+between cells according to their local neighborhood overlap, calculated
+using the Jaccard similarity measure. This is performed using predefined
+dimensions of the dataset, such as the first 10 Principal Components
+(PCs). To cluster cells, Seurat uses modularity optimization techniques
+like the Louvain [4] algorithm or SLM [5]. The ‘resolution’ parameter
+can be adjusted to control the granularity of the downstream clustering;
+a higher resolution results in more clusters. For single-cell datasets
+of approximately 3K cells, the recommended range for this parameter is
+between 0.4 and 1.2, but larger datasets typically require a higher
+resolution.
+
+reClust_SO=reclusterSeuratObject(
+ object = filter_SO$object,
+ prepend.txt = "old",
+ old.columns.to.save=c("orig_ident","Sample_Name","nCount_RNA","nFeature_RNA","percent_mt",
+ "log10GenesPerUMI","S_Score","G2M_Score","Phase","CC_Difference","Treatment",
+ "pct_counts_in_top_N_genes","Doublet","nCount_SCT","nFeature_SCT",
+ "mouseRNAseq_main","mouseRNAseq","immgen_main","immgen" ),
+ number.of.pcs = 50,
+ cluster.resolution.low.range = 0.2,
+ cluster.resolution.high.range = 1.2,
+ cluster.resolution.range.bins = 0.2,
+ reduction.type = "umap"
+ )
Seurat Clustering method https://satijalab.org/seurat/articles/pbmc3k_tutorial.html
Macosko EZ, Basu A, Satija R, Nemesh J, Shekhar K, Goldman M, +Tirosh I, Bialas AR, Kamitaki N, Martersteck EM, Trombetta JJ, Weitz DA, +Sanes JR, Shalek AK, Regev A, McCarroll SA. Highly Parallel Genome-wide +Expression Profiling of Individual Cells Using Nanoliter Droplets. Cell. +2015 May 21;161(5):1202-1214.
Xu, Chen, and Zhengchang Su. Identification of cell types from +single-cell transcriptomes using a novel clustering method. +Bioinformatics 31.12 (2015): 1974-1980.
Levine, Jacob H., et al. Data-driven phenotypic dissection of AML +reveals progenitor-like cells that correlate with prognosis. Cell 162.1 +(2015): 184-197.
Blondel, Vincent D., et al. Fast unfolding of communities in +large networks.”Journal of statistical mechanics: theory and experiment +2008.10 (2008): P10008.
Waltman, Ludo, and Nees Jan Van Eck. A smart local moving +algorithm for large-scale modularity-based community detection. The +European physical journal B 86 (2013): 1-14
SCWorkflow-Usage.RmdThe SCWorkflow docker container is available on Biowulf which can be +used with RStudio to organize and rune the SCWorkflow package.
+You will need 2 shells (terminals) to set up RStudio on Biowulf.
+Open a terminal and login to biowulf then call an interactive +session
+ssh username@helix.nih.gov
+
+sinteractive --tunnel --time=12:00:00 --mem=50g --cpus-per-task=16 --gres=lscratch:50
+The single cell container will emulate the environments from +NIDAP
+
+source /data/CCBR/NIDAP/container_singlecell.sh
+for general use SCWorkflow can be installed into your Rlibrary
+# install.packages("remotes")
+# remotes::install_github("NIDAP-Community/SCWorkflow", dependencies = TRUE)
+
+library(SCWorkflow)
+SCWorkflow-Visualizations.RmdUse this Function to color your dimensionality reduction (TSNE & +UMAP) with different columns from your Metadata Table. You can select +one or more columns from the Metadata Table, and for each column +selected, this function will produce a plot (t-SNE & UMAP) using the +data in that column to color the cells.
+This function visualizes your plot based on selected metadata. Users +can customize how they want to visualize the data, including the type of +visualization used, the size and shape of the points, and the level of +transparency.
+
+FigOut=plotMetadata(
+ object=Anno_SO$object,
+ samples.to.include=c("PBS","ENT","NHSIL12","Combo","CD8dep" ),
+ metadata.to.plot=c("SCT_snn_res.0.4","Phase"),
+ columns.to.summarize=NULL,
+ summarization.cut.off = 5,
+ reduction.type = "umap",
+ use.cite.seq = FALSE,
+ show.labels = FALSE,
+ legend.text.size = 1,
+ legend.position = "right",
+ dot.size = 0.01
+ )
This Function creates 3D interactive UMAP or t-SNE plot. The plot is +saved in the output folder as an HTML file that can be downloaded.
+This function is designed to generate a 3D t-SNE visualization based +on a given Seurat Object. The output includes an interactive plot and a +dataframe containing the t-SNE coordinates. The function accepts several +parameters, such as the Seurat Object, a metadata column for color, a +metadata column for labeling, dot size for the plot, legend display +option, colors for the color variable, filename for saving the plot, the +number of principal components for t-SNE calculations, and an option to +save the plot as a widget in an HTML file. Initially, the function +executes t-SNE on the Seurat Object to obtain the 3D coordinates. +Subsequently, it constructs a dataframe for the Plotly visualization, +incorporating the t-SNE coordinates, color variable, and label variable. +The function generates a 3D scatter plot using the t-SNE coordinates. +Finally, the function saves the plot as an embedded Plotly image in an +HTML file.
+Methodology
+t-Distributed Stochastic Neighbor Embedding (t-SNE) is a sophisticated
+dimensionality reduction technique frequently employed for the
+visualization of high-dimensional data [1]. It effectively displays the
+relationships between individual cells based on their gene expression
+profiles. To compute t-SNE, the algorithm constructs a probability
+distribution representing similarities between data points in
+high-dimensional space. Subsequently, it generates a lower-dimensional
+representation, typically two or three dimensions, wherein the distances
+between data points reflect their similarities in the high-dimensional
+space. The algorithm employs an iterative process to adjust the
+positions of cells in a lower-dimensional space, aiming to minimize
+discrepancies between the original high-dimensional similarities and
+those in the lower-dimensional space. This approach enables the
+algorithm to capture both global and local structures within the data,
+effectively revealing clusters or groups of similar cells.
+
+FigOut=tSNE3D(
+ object=Anno_SO$object,
+ color.variable="SCT_snn_res.0.4",
+ label.variable="SCT_snn_res.0.4",
+ dot.size = 4,
+ legend = TRUE,
+ colors = c("darkblue","purple4","green","red","darkcyan",
+ "magenta2","orange","yellow","black"),
+ filename = "plot.html",
+ save.plot = FALSE,
+ npcs = 15
+ )This function visualizes gene expression intensities for provided +Genes across your cells. If a gene is not found in the dataset, the Log +will report this. Otherwise, you should see one plot (TSNE or UMAP, your +choice) per gene name provided. The intensity of the red color will be +relative to the expression of the gene in that cell. Final Potomac +Compatible Version: v98. Sugarloaf V1: v103. [View
+Methodology
+This function visualizes expression values of the chosen gene or protein
+in different samples. Users can customize how they want to visualize the
+data, including the type of visualization used, the size and shape of
+the points, and the level of transparency.
+
+FigOut=colorByGene(
+ object=Anno_SO$object,
+ samples.to.include=c("PBS","ENT","NHSIL12","Combo","CD8dep" ),
+ gene="Itgam",
+ reduction.type = "umap",
+ number.of.rows = 0,
+ return.seurat.object = FALSE,
+ color = "red",
+ point.size = 1,
+ point.shape = 16,
+ point.transparency = 0.5,
+ use.cite.seq.data = FALSE,
+ assay = "SCT")
This Function allows for the generation of customized violin plots to +visualize transcriptional changes and interactions in single-cell +RNA-seq data, providing insights into the cellular heterogeneity and +dynamics within the dataset.
+Methodology
+The Function organizes your data based on specific groups that you
+choose from a Seurat Object metadata. It then gathers information about
+the activity levels of specific genes you’re interested in. You can, if
+you wish, change the names or the order of these groups based on a
+column you specify in the data. This feature lets you tailor the
+analysis more closely to your needs. The code also has a function that
+removes any odd data points that might distort the results, and it
+adjusts the data to make it easier to visualize through jittered points
+and an overlaying boxplot displaying quantile information. Then, the
+code creates violin plots, which allows you to see how the activity
+levels of genes vary within each group [2]. The graph is customizable,
+letting you set various options such as limit values on the vertical
+axis, displaying individual data points, converting scales to
+logarithmic, and showing boxplots. You can choose how the plot looks -
+whether it’s laid out like a grid, in rows, or with customized
+labels.
+
+FigOut=violinPlot(
+ object=Anno_SO$object,
+ assay="SCT",
+ layer="scale.data",
+ genes=c("Itgam","Cd38"),
+ group="SCT_snn_res.0.4",
+ facet.by = "",
+ filter.outliers = F,
+ outlier.low = 0.05,
+ outlier.high = 0.95,
+ jitter.points = TRUE,
+ jitter.dot.size = 1
+ )
This Function provides a comprehensive method for visualizing single
+cell transcript and/or protein expression data in the form of a heatmap.
+The data is obtained from a Seurat object, and the user can specify a
+set of genes for the analysis.
+The Function allows optional ordering by metadata (categorical) or
+gene/protein expression levels. Visualization customization options
+include color choices for the heatmap, addition of gene or protein
+annotations, and optional arrangement by metadata.
Key features include: - Options for adding gene or protein +annotations, metadata arrangement, and specifying row and column names. +- Customizable visualization settings including font sizes for rows, +columns, and legend, row height, and heatmap colors. - Ability to trim +outlier data, perform z-scaling on rows, and set row order.
+The Function returns a heatmap plot along with the underlying data +used to generate it. It also allows the user to set a seed for color +generation and specify outlier data parameters. This function is +particularly useful for exploratory data analysis and preliminary data +visualization in single cell studies.
+Methodology
+In this method, two hierarchical clustering processes are performed: one
+on the rows and one on the columns of the dataset unless ordered by
+annotations. Hierarchical clustering is a method of cluster analysis
+that aims to build a hierarchy of clusters. The result is a tree-like
+diagram called a dendrogram, where similar data points (e.g., genes or
+samples) are joined together into clusters at the “branches”, based on a
+mathematical measure of similarity such as Euclidean or Manhattan
+distance. The heatmap is produced by a package called ComplexHeatmap [3]
+and presents the data matrix where rows represent individual genes (or
+proteins, metabolites, etc.) and columns represent different samples
+(e.g., tissue samples, cells, experimental conditions). The color at
+each position in the grid corresponds to the expression level of a gene
+in a particular sample, with one color representing upregulation (higher
+expression), another representing downregulation (lower expression), and
+usually a neutral color representing no change. This allows for easy
+visual interpretation of patterns or correlations in the data.
+
+FigOut=heatmapSC(
+ object=Anno_SO$object,
+ sample.names=c("PBS","ENT","NHSIL12","Combo","CD8dep" ),
+ metadata="SCT_snn_res.0.4",
+ transcripts=c("Cd163","Cd38","Itgam","Cd4","Cd8a","Pdcd1","Ctla4"),
+ use.assay = "SCT",
+ proteins = NULL,
+ heatmap.color = "Bu Yl Rd",
+ plot.title = "Heatmap",
+ add.gene.or.protein = FALSE,
+ protein.annotations = NULL,
+ rna.annotations = NULL,
+ arrange.by.metadata = TRUE,
+ add.row.names = TRUE,
+ add.column.names = FALSE,
+ row.font = 5,
+ col.font = 5,
+ legend.font = 5,
+ row.height = 15,
+ set.seed = 6,
+ scale.data = TRUE,
+ trim.outliers = TRUE,
+ trim.outliers.percentage = 0.01,
+ order.heatmap.rows = FALSE,
+ row.order = c()
+ )
This function creates a dot plot of average gene expression values +for a set of genes in cell subpopulations defined by metadata annotation +columns. The input table contains a single column for genes (the “Genes +column”) and a single column for category (the “Category labels to plot” +column). The values in the “Category labels to plot” column should match +the values provided in the metadata function (Metadata Category to +Plot). The plot will order the genes (x-axis, left to right) and +Categories (y-axis, top to bottom) in the order in which it appears in +the input table. Any category entries omitted will not be plotted.
+The Dotplot size will reflect the percentage of cells expressing the +gene while the color will reflect the average expression for the gene. A +table showing values on the plot (either percentage of cells expressing +gene, or average expression scaled) will be returned, as selected by +user.
+Methodology
+This function creates a dot plot visualization of gene expression by
+metadata from a given dataset. It uses the Seurat package to create
+these plots. The size of the dot represents the percentage of cells
+expressing a particular gene (frequency), while the color of the dot
+indicates the average gene expression level. The function ensures that
+only unique and valid genes and categories are used. If some categories
+or genes are not found in the dataset, appropriate warnings are issued.
+The plot is then drawn with the option to reverse the x and y-axes and
+to reverse the order of metadata categories. The colors can also be
+customized. In addition to the plot, the function provides the tabular
+format of the dot plot data, which can be useful for further analysis or
+reporting. A choice of returning either the tables representing the
+percent of cells expressing a gene or the average expression level of
+the genes. This function can be useful for exploratory data analysis and
+visualizing the differences in gene expression across different
+conditions or groups of cells.
+
+FigOut=dotPlotMet(
+ object=Anno_SO$object,
+ metadata="SCT_snn_res.0.4",
+ cells=unique(Anno_SO$object$SCT_snn_res.0.4),
+ markers=c("Itgam","Cd163","Cd38","Cd4","Cd8a","Pdcd1","Ctla4"),
+ plot.reverse = FALSE,
+ cell.reverse.sort = FALSE,
+ dot.color = "darkblue"
+ )
This function compares cell population composition across +experimental groups (for example sample, treatment, timepoints, or donor +cohorts) using metadata already stored in the Seurat object. It is +useful after clustering and annotation, when you want to quantify how +specific cell populations shift between conditions. + The function supports both Frequency (percent) and +Counts (absolute cell numbers) modes. In most +biological comparisons with unequal total cell recovery across samples, +frequency mode is preferred for interpretation. Counts mode can be +useful for QC and yield-focused assessments.
+ +Methodology
+The method first aggregates metadata by annotation and group to compute
+percentages and counts. It then links these summaries to sample-level
+metadata and generates a composition-focused barplot for sample-level
+variability. Together, these plots help distinguish overall
+compositional shifts from replicate-level dispersion.
+
+FigOut=compareCellPopulations(
+ object=Anno_SO$object,
+ annotation.column="immgen_main",
+ group.column="Treatment",
+ sample.column = "orig.ident",
+ counts.type = "Frequency",
+ group.order = NULL,
+ wrap.ncols = 5
+)
+ 
Seurat Documentation for t-SNE Analysis https://satijalab.org/seurat/reference/runtsne
Complex Heatmap Reference Book https://jokergoo.github.io/ComplexHeatmap-reference/book/
Developer documentation
SCWorkflow is an R package for single-cell RNA-seq analysis built on the Seurat framework. It’s designed for analyzing multimodal 10x Genomics data, with support for CITE-Seq, cell hashing, and TCR-seq data. The package is deployed as both an R package and Docker container for use in NIDAP (Palantir Foundry) and Biowulf HPC environments.
+Functions follow a numbered workflow sequence: 1. processRawData() - Process H5 files into Seurat objects 2. filterQC() - Quality control and filtering
+3. combineNormalize() - Merge samples, normalize, dimension reduction 4. Harmony integration (optional) - Batch correction 5. annotateCellTypes() - Automatic cell type annotation via SingleR 6. Analysis functions - DEG, visualization, clustering
R/ contains one function per file, named descriptively (e.g., Process_Raw_Data.R)processRawData(), annotateCellTypes()
+Process_Raw_Data.R
+object - Primary Seurat object inputsamples.to.include - Character vector for sample subsettingreduction.type - Visualization method (“umap”, “tsne”, “pca”)organism - Species specification (“Human” or “Mouse”). separator: do.normalize.data, draw.umap
+tests/testthat/ with both unit tests and integration testsfixtures/ directory contains real Seurat objects for testinghelper-*.R files for test setuptest-Function_Name.R
+is(input, "Seurat")
+When working with this codebase: 1. Always check if input is a Seurat object: class(object) 2. Verify required reductions exist: object@reductions 3. Check available assays: names(object@assays) 4. Use str(object@meta.data) to understand metadata structure 5. Test functions start with small datasets from tests/testthat/fixtures/
This document tracks major design decisions for the SCWorkflow package.
+Context: Need for visualizing cell population distributions across experimental groups (treatments, timepoints, conditions).
+Decision: Implemented dual visualization approach with alluvial flow plots and box plots.
+Rationale: - Alluvial flow plots show proportional relationships across groups while maintaining visibility of sample composition - Box plots provide statistical distribution view with individual data points - Both visualizations complement each other: flows for overall trends, boxes for statistical variance - Flexible frequency vs. counts mode supports different analytical needs
+Implementation Details: - Uses ggalluvial for flow visualizations (Sankey-style plots) - ggpubr for box plot styling with statistical comparisons - Internal helper createAnnoTable() aggregates frequencies/counts by sample - Supports custom color palettes or auto-generates from RColorBrewer - Handles group ordering for controlled presentation
Alternatives Considered: 1. Single bar plot visualization - rejected as insufficient for showing sample-level variation 2. Stacked area plots - rejected due to difficulty comparing non-adjacent categories 3. Separate samples in flow plots - rejected due to visual clutter with many samples
+Trade-offs: - Alluvial plots can be busy with many cell types (>10-15) - Box plots require sufficient samples per group for meaningful statistics - Two separate plots increase figure space requirements but provide complementary insights
+Generated From: JSON template Compare_Cell_Populations.code-template.json using json2r.prompt.md instructions