5.1 RNASeqRParam Slots Explanation

There are 11 slots in RNASeqRParam:

1. os.type : The operating system type. Value is linux or osx. This package only supports ‘Linux’ and ‘macOS’ (not ‘Windows’). If another operating system is detected, ERROR will be reported.

2. python.variable : A Python-related variable. The value is a list of whether Python is available and the Python version (TRUE or FALSE, 2 or 3).

3. python.2to3 : Availability of the 2to3 command. THe value is TRUE or FALSE.

4. path.prefix : Path prefix of the ‘gene_data/’, ‘RNASeq_bin/’, ‘RNASeq_results/’, ‘Rscript/’ and ‘Rscript_out/’ directories. It is recommended that you create a new, empty directory in which all the subsequent RNA-Seq results can be saved.

5. input.path.prefix : Path prefix of the ‘input_files/’ directory. Users should prepare an ‘input_file/’ directory with the following rules:

   • genome.name.fa: Reference genome in FASTA file formation.

   • genome.name.gtf: Gene annotation in GTF file formation.

   • raw_fastq.gz/: Directory storing FASTQ files.

     • Supports paired-end read files only.

     • Names of paired-end FASTQ files : ’sample.pattern_1.fastq.gz’ and ’sample.pattern_2.fastq.gz’. sample.pattern must be distinct for each sample.

   • phenodata.csv: Information about the RNA-Seq experiment design.

     • First column : Distinct ids for each sample. The value of each sample of this column must match sample.pattern in FASTQ files in ‘raw_fastq.gz/’. Column names must be ids.

     • Second column : An independent variable for the RNA-Seq experiment. Values of each sample of this column can only be parameter case.group or control.group. The column name is the parameter independent.variable.

   • indices/ : The directory storing HT2 index files for the HISAT2 alignment tool.

     • This directory is optional. HT2 index files corresponding to the reference genome can be installed at HISAT2 official website. Providing HT2 files can accelerate the subsequent analysis steps. It is highly advised that you install HT2 files.

     • If HT2 index files are not provided, the ‘input_files/indices/’ directory should be deleted.

6. genome.name : The genome name defined in this RNA-Seq workflow (ex. ‘genome.name.fa’, ‘genome.name.gtf’)

7. sample.pattern : A regular expression of paired-end fastq.gz files under ‘input_files/raw_fastq.gz/’. IMPORTANT!! The expression shouldn’t have _[1,2].fastq.gz at the end.

8. independent.variable: Independent variable for the biological experiment design of a two-group RNA-Seq analysis workflow.

9. case.group : Name of the case group.

10. control.group : Name of the control group.

11. indices.optional : A logical value indicating whether ‘input_files/indices/’ exists. Value is TRUE or FALSE

5.2 RNASeqRParam Constructor Checking

1. Create a new directory for the RNA-Seq analysis. It is highly recommended to create a new, completely empty directory. The parameter path.prefix of RNASeqRParam() constructor should be the absolute path of this new directory. All the RNA-SeqR-related files are generated in the subsequent steps will be stored inside of this directory.

2. Create a valid ‘input_files/’ directory. You should create a file directory named ‘input_files/’ with the neccessary files inside. It should follow the rules mentioned above.

3. Run the constructor of the RNASeqRParam S4 object. This constructor will check the validity of the input parameters before creating the S4 objects.

   • Operating system

   • Python version

   • 2to3 command

   • Structure, content, and rules of ‘inputfiles/’

   • Validity of input parameters

5.3 Example

library(RNASeqR)
library(RNASeqRData)

input_files.path <- system.file("extdata/", package = "RNASeqRData")
rnaseq_result.path <- tempdir(check = TRUE)
list.files(input_files.path, recursive = TRUE)

##  [1] "input_files/Saccharomyces_cerevisiae_XV_Ensembl.fa" 
##  [2] "input_files/Saccharomyces_cerevisiae_XV_Ensembl.gtf"
##  [3] "input_files/phenodata.csv"                          
##  [4] "input_files/raw_fastq.gz/SRR3396381_XV_1.fastq.gz"  
##  [5] "input_files/raw_fastq.gz/SRR3396381_XV_2.fastq.gz"  
##  [6] "input_files/raw_fastq.gz/SRR3396382_XV_1.fastq.gz"  
##  [7] "input_files/raw_fastq.gz/SRR3396382_XV_2.fastq.gz"  
##  [8] "input_files/raw_fastq.gz/SRR3396384_XV_1.fastq.gz"  
##  [9] "input_files/raw_fastq.gz/SRR3396384_XV_2.fastq.gz"  
## [10] "input_files/raw_fastq.gz/SRR3396385_XV_1.fastq.gz"  
## [11] "input_files/raw_fastq.gz/SRR3396385_XV_2.fastq.gz"  
## [12] "input_files/raw_fastq.gz/SRR3396386_XV_1.fastq.gz"  
## [13] "input_files/raw_fastq.gz/SRR3396386_XV_2.fastq.gz"  
## [14] "input_files/raw_fastq.gz/SRR3396387_XV_1.fastq.gz"  
## [15] "input_files/raw_fastq.gz/SRR3396387_XV_2.fastq.gz"

Check the files in ‘inputfiles/’ directory.

exp <- RNASeqRParam(path.prefix = rnaseq_result.path, 
                    input.path.prefix = input_files.path, 
                    genome.name = "Saccharomyces_cerevisiae_XV_Ensembl", 
                    sample.pattern = "SRR[0-9]*_XV",
                    independent.variable = "state", 
                    case.group = "60mins_ID20_amphotericin_B", 
                    control.group = "60mins_ID20_control")

show(exp)

## RNASeqRParam S4 object
##               os.type : linux 
##       python.variable : (Availability: TRUE , Version: 2 )
##           python.2to3 : FALSE 
##           path.prefix : /tmp/Rtmp8a2w6N/ 
##     input.path.prefix : /home/biocbuild/bbs-3.9-bioc/R/library/RNASeqRData/extdata/ 
##           genome.name : Saccharomyces_cerevisiae_XV_Ensembl 
##        sample.pattern : SRR[0-9]*_XV 
##  independent.variable : state 
##            case.group : 60mins_ID20_amphotericin_B 
##         control.group : 60mins_ID20_control 
##      indices.optional : FALSE 
##  independent.variable : state

In this example, the RNASeqRParam S4 object is stored in exp for subsequent RNA-Seq analysis steps. Any ERROR occurring in the checking steps will terminate the program.

6.1 File Setup

1. Create Base Directories ‘gene_data/’, ‘RNASeq_bin/’, ‘RNASeq_results’, ‘Rscript’, and ‘Rscript_out’ will be created in the path.prefix directory. Here is the usage of these five main directories:

   • ‘gene_data/’: Symbolic links of ‘input_files/’ and files that are created in each step of RNA-Seq analysis will be stored in this directory.

   • ‘RNASeq_bin/’: The binaries of necessary tools, HISAT2, SAMtools, StringTie and Gffcompare, are installed in this directory.

   • ‘RNASeq_results’: The RNA-Seq results, for example, alignment results, quality assessment results, differential analysis results etc., will be stored in this directory.

   • ‘Rscript’: If your run the XXX_CMD() function, the corresponding R script(XXX.R) for certain steps will be created in this directory.

   • ‘Rscript_out’: The corresponding output report for R scripts (XXX.Rout) will be stored in this directory.

2. Symbolic links will be created from files in ‘input_files/’ to the path.prefix directory.

6.2 Installation of Necessary Tools

The operating system of your workstation will be detected. If the operating system is not Linux or macOS, ERROR will be reported. Users can decide whether the installation of essential programs(HISAT2, StringTie and Gffcompare) is going be automatically processed.

Third-party softwares used in this package includes HISAT2, StringTie and Gffcompare. Binaries are available for these three programs, and by default, they will be installed automatically based on the operating system of the workstation. Zipped binaries will be unpacked and exported to the R environment PATH. No compilation is needed.

To specify, there are three parameters(install.hisat2, install.stringtie and install.gffcompare) in both the RNASeqEnvironmentSet_CMD() and RNASeqEnvironmentSet() functions for users to determine which software is going to be installed automatically or skipped. The default settings of these parameters are TRUE so that these three programs will be installed directly. Otherwise, users can skip certain software installation processes by turning the values to FALSE. Please make sure to check that the skipped programs are available using system2() through the R shell. Unavailability of any of the programs will cause failure in the ‘Environment Setup’ step.

Here is the version information of each software binary.

• HISAT2
  • Based on your operating system, hisat2-2.1.0-Linux_x86_64.zip or hisat2-2.1.0-OSX_x86_64.zip zipped file will be installed.
  • The downloaded file will be unzipped and all binary files will be copied to and run from ‘RNASeq_bin/’
• StringTie
  • Based on your operating system, stringtie-1.3.4d.Linux_x86_64.tar.gz or stringtie-1.3.4d.Linux_x86_64 will be installed.
  • The downloaded file will be unzipped and all binary files will be copied to and run from ‘RNASeq_bin/’.
• Gffcompare
  • Based on your operating system, gffcompare-0.10.4.Linux_x86_64.tar.gz or gffcompare-0.10.4.Linux_x86_64.tar.gz will be installed.
  • The downloaded file will be unzipped and all binary files will be copied to and run from ‘RNASeq_bin/’.

6.3 Export Path

‘RNASeq_bin/’ will be added to the R environment PATH so that these binaries can be found in the R environment in the R shell through system2(). In the last step of environment setup, the hisat2 --version,stringtie --version,gffcompare --version, and samtools --version commands will be checked in order to make sure the environment is correctly constructed. The environment must be set up successfully before the subsequent analyses.

6.4 Example

Run RNASeqEnvironmentSet_CMD() or RNASeqEnvironmentSet().

1. For runs in the background, the results will be reported in ‘Rscript_out/Environment_Set.Rout’. Make sure the environment is successfully set up before running the subsequent steps.

RNASeqEnvironmentSet_CMD(exp)

2. For runs in the R shell, the results will be reported in the R shell. Make sure the environment is successfully setup before running the subsequent steps.

RNASeqEnvironmentSet(exp)

7.1 “systemPipeR” Quality Assessment

In this step, the systemPipeR package is used for evaluating sequencing reads and the details are as follows:

1. Check the number of times that the user has run the quality assessment process and create the corresponding files ‘RNASeq_results/QA_results/QA_{times}’.

2. RNA-Seq environment set up. The ‘rnaseq/’ directory will be created by systemPipeR package.

3. Create the ‘data.list.txt’ file.

4. Reading FASTQ files and create ‘fastqReport.pdf’ containing the results of the quality assessment.

5. Remove the ‘rnaseq/’ directory.

This quality assessment result (example below) is generated by systemPipeR package. It will be stored as a PDF.

7.2 Example

Run RNASeqQualityAssessment_CMD() or RNASeqQualityAssessment().

1. For runs in the background, the results will be reported in ‘Rscriptout/Quality_Assessment.Rout’. Make sure the quality assessment is successfully done before running the subsequent steps.

RNASeqQualityAssessment_CMD(exp)

2. Results fo runs in R shell will be reported in the R shell. Make sure the quality assessment is successfully done before running the subsequent steps.

RNASeqQualityAssessment(exp)

## [1] "Generated rnaseq directory. Next run in rnaseq directory, the R code from *.Rmd (*.Rnw) template interactively. Alternatively, workflows can be exectued with a single command as instructed in the vignette."

8.1 The HISAT2 Indexer

In a preparation step (the RNASeqRParam creation step), the ‘indices/’ directory is checked for whether HT2 index files already exist. If not, the following commands will be executed:

• Input: ‘genome.name.gtf’, ‘genome.name.fa’

• Output: ‘genome.name.ss’, ‘genome.name.exon’, ’genome.name_tran.{number}.ht2’

1. extract_splice_sites.py, extract_exons.py execution
   • These two commands are executed to extract splice-site and exon information from the gene annotation file.
2. hisat2-build index creation
   • This command builds the HISAT2 index files genome.name.ss and genome.name.exon created in the previous step. Be aware that the index building step requires a larger amount of memory and longer time than other steps, and it might not be possible to run on some personal workstations. It is highly recommended that you check the availability of HT2 index files at the HISAT2 official website for your target reference genome beforehands. Pre-installing HT2 index files will greatly shorten the analysis time.
3. Write ‘RNASeq_results/COMMAND.txt’
   • Shell commands that run in this step will be documented in ‘RNASeq_results/COMMAND.txt’.

8.2 The HISAT2 Aligner

• Input: ’genome.name_tran.{number}.ht2’, ‘sample.pattern.fastq.gz’

• Output: ‘sample.pattern.sam’

1. hisat2 command is executed on paired end FASTQ files. SAM files will be created.
   • SAM files are stored in ‘gene_data/raw_bam/’.
2. Write ‘RNASeq_results/COMMAND.txt’
   • The shell command that run in this step will be documented into ‘RNASeq_results/COMMAND.txt’.
3. The summary dataframe for alignment reads and mapping rates in terms of tabular(CSV) and picture (PNG) format is created and kept in the directory ‘RNASeq_results/Alignment_Report’.

8.3 The Rsamtools SAM to BAM Converter

In this step, users can choose whether they want to use ‘Rsamtools’(an R package) or ‘SAMtools’ ( a command-line-based tool) to do files conversion by setting the SAMtools.or.Rsamtools parameter to Rsamtools or SAMtools. By default, Rsamtools will be used. However, if the amount of RNA-Seq data is too large, ‘Rsamtools’ might not be able to finish this process due to the Rtmp file issue, and therefore ‘SAMtools’ is recommended. Users have to make sure the ‘samtools’ command is available on the workstation beforehands or ERROR will be reported.

• Input: ‘sample.pattern.sam’

• Output: ‘sample.pattern.bam’

1. The Rsamtools package provides an interface to samtools in the R environment. In this step, SAM files from HISAT2 will be converted to BAM files by running the asBam() function.
   • Output BAM files are stored in ‘gene_data/raw_sam/’.
2. Write ‘RNASeq_results/COMMAND.txt’

8.4 The StringTie Assembler

• Input: ‘genome.name.gtf’, ‘sample.pattern.bam’

• Output: ‘sample.pattern.gtf’

1. stringtie command is executed.
   • The tool assembles RNA-Seq alignments into potential transcripts.
   • The assembled GTF files which are from each FASTQ files are stored in ‘gene_data/raw_gtf/’
2. Write ‘RNASeq_results/COMMAND.txt’
   • Shell commands that run in this step will be documented in ‘RNASeq_results/COMMAND.txt’.

8.5 The StringTie GTF Merger

• Input: ‘sample.pattern.gtf’

• Output: ‘stringtiemerged.gtf’, ‘mergelist.txt’

1. Create the file ‘mergelist.txt’.
   • gene_data/merged/mergelist.txt is created for the merging step.
2. stringtie command is executed.
   • The transcript merger merges each sample.pattern.gtf into stringtiemerged.gtf
   • Output files are all stored in ‘gene_data/merged/’
3. Write ‘RNASeq_results/COMMAND.txt’
   • Shell commands that run in this step will be documented in ‘RNASeq_results/COMMAND.txt’.

8.6 The Gffcompare Comparer

• Input: ‘genome.name.gtf’, ‘stringtie_merged.gtf’

• Output: ‘merged.annotated.gtf’, ‘merged.loci’, ‘merged.stats’, ‘merged.stringtie_merged.gtf.refmap’, ‘merged.stringtie_merged.gtf.tmap’, ‘merged.tracking’

1. gffcompare command is executed.
   • The comparison result of the merged GTF file and reference annotation files is reported in the ‘merged/’ directory.
2. Write ‘RNASeq_results/COMMAND.txt’
   • Shell commands that run in this step will be documented in ‘RNASeq_results/COMMAND.txt’.

8.7 The Ballgown input Creator

• Input: ‘stringtie_merged.gtf’

• Output: ‘ballgown/’, ‘gene_abundance/’

1. stringtie command is executed.
   • StringTie will create the input directory for the ballgown package for subsequent differential expression analysis. Ballgown-related files will be stored under each sample name in ‘gene_data/ballgown/’.
   • StringTie will store gene-related information in an TSV file under each sample name in ‘gene_data/gene_abundance/’.
2. Write ‘RNASeq_results/COMMAND.txt’
   • Shell commands that run in this step will be documented in ‘RNASeq_results/COMMAND.txt’.

8.8 The Reads Count Table Creator

Whether this step is executed depends on the availability of Python on your workstation.

• Input: ‘samplelst.txt’

• Output: ‘gene_count_matrix.csv’, ‘transcript_count_matrix.csv’

1. The reads count table converter Python script is downloaded as prepDE.py

2. Python checking

   • When Python is not available, this step is skipped.

   • When Python2 is available, prepDE.py is executed.

   • When Python3 is available, the 2to3 command will be checked.(Usually, if Python3 is installed, 2to3 command will be installed too.)

   • When Python3 is available but the 2to3 command is unavailable, the raw read count step will be skipped.

   • When Python3 and the 2to3 command are available, prepDE.py is converted to a file that can be executed by Python2 and is automatically executed.

3. Raw reads count creation
   • The raw reads count is created and the results are stored in ‘gene_data/reads_count_matrix/’
4. Write ‘RNASeq_results/COMMAND.txt’
   • Shell commands that run in this step will be documented in ‘RNASeq_results/COMMAND.txt’.

8.9 Example

Run RNASeqReadProcess_CMD() or RNASeqReadProcess().

1. For runs in the background, the results will be reported in ‘Rscriptout/Raw_Read_Process.Rout’. Make sure the raw read process is successfully done before running the subsequent steps.

RNASeqReadProcess_CMD(exp)

2. For runs in the R shell, the results will be reported in R shell. Make sure the raw read process is successfully done before running the subsequent steps.

RNASeqReadProcess(exp)

9.1 General Data Visualization

Here we illustrate general data visualization before and after differential expression analysis. The results based on each differential analysis tool(ballgown, DESeq2, edgeR) are kept in the directory ‘RNASeq_results/’. The plots shown below are the statistical results visualization of example data in the RNASeqRData package based on MRN-normalized expression values from DESeq2. For real data analysis results, please go to this website: https://howardchao.github.io/RNASeqR_analysis_result/.

9.2 “ballgown” Analysis Based on FPKM Value

Ballgown is an R package designed for differential expression analysis of RNA-Seq data. This package extracts FPKM values, i.e., read counts normalized by both library size and gene length, from StringTie software followed by applying a parametric F-test comparing the nested linear model as its default statistic model to identify DEGs. The basic steps are as follows:

• Input: ‘gene_data/ballgown/’
• Output: ‘RNASeq_results/ballgown_analysis/’

1. Create a ballgown object that will be stored in ‘RNASeq_results/ballgown_analysis/ballgown.rda’.

2. Filter out the genes for which the sum of FPKM values of all samples per gene equals 0.

3. Calculate log2-based fold change value in column log2FC.

4. Split a matrix of normalized counts into case and control groups based on phenotype data (‘gene_data/phenodata.csv’) and assign relative information in column sample.pattern.FPKM.

5. Generate a csv file, ‘RNASeq_results/ballgown_analysis/ballgown_normalized_result.csv’, in which to store normalized FPKM values, mean expression values per group, and statistical results.

6. Select DEGs based on default criteria: pval < 0.05 and log2FC > 1 | log2FC < 1. Store the result in ‘RNASeq_results/ballgown_analysis/ballgown_normalized_DE_result.csv’

7. Additional data visualization: aside from the general data visualization mentioned above, transcript-related plots and an MA plot are also provided.

• ‘Distribution_Transcript_Count_per_Gene_Plot.png’: This plots the distribution of transcript counts per gene.

• ‘Distribution_Transcript_Length_Plot.png’: This plots the distribution of transcript length.

• ‘MA_Plot_ggplot2.png’: This displays the difference of expression value between two groups by transforming the data onto log2-based ratio (x-axis) and log2-based mean (y-axis) scales by using ggplot2.

9.3 “DESeq2” Analysis Based on Read Count

DESeq2 is an R package for count-based differential expression analysis using read counts to estimate variance-mean dependence. It takes sequence depth and gene composition into consideration and uses the MRN method to normalize read counts. The statistical model for differential expression is based on a negative binomial distribution. The basic steps are as follows:

• Input: ‘gene_data/reads_count_matrix/gene_count_matrix.csv’
• Output: ‘RNASeq_results/ballgown_analysis/’

1. Create the DESeqDataSet object based on count data from the matrix of read counts and phenotype data using the DESeqDataSetFromMatrix() function.

2. Filter out the genes for which the sum of read counts of all samples equals 0.

3. Run DESeq2() function to process the differential expression analysis.

4. Generate a csv file, ‘RNASeq_results/DESeq2_analysis/DESeq2_normalized_result.csv’, in which to store normalized MRN counts, mean expression values per group, and statistical results.

5. Select DEGs based on default criteria: pval < 0.05 and log2FC > 1 | log2FC < 1. Store the result in ‘RNASeq_results/DESeq2_analysis/DESeq2_normalized_DE_result.csv’..

6. Additional data visualization: aside from the general data visualization mentioned above, a dispersion plot and an MA plot are also provided.

• Dispersion_Plot_DESeq2.png: This displays the dispersion estimates before and after normalization using plotDispEsts(). The x-axis denotes the mean of the normalized counts while the y-axis represents the dispersion estimates values using plotDispEsts() in DESeq2.

• MA_Plot_DESeq2.png: This displays the difference in expression values between two groups by transforming the data onto log2-based ratio (x-axis) and log2-based mean (y-axis) scales using plotMA() in DESeq2.

9.4 “edgeR” Analysis Based on Read Count

edgeR is another R package for count-based differential expression analysis. It implements the TMM method to normalize count data between samples, and several statistical strategies based on the negative binomial distribution, such as exact tests, are used to detect differential expression. The basic steps are as follows:

• Input: ‘gene_data/reads_count_matrix/gene_count_matrix.csv’
• Output: ‘RNASeq_results/edgeR_analysis/’

1. Create DEGList based on the count data from the matrix of read counts and phenotype data using the DGEList() function.

2. Normalize the DEGList object by running three functions in the following order: calcNormFactors(), estimateCommonDisp() and estimateTagwiseDisp().

3. Conduct genewise exact tests using the exactTest() function.

4. Obtain a normalized count matrix using cpm() after TMM normalization. (cpm = counts per million)

5. Generate a csv file, ‘RNASeq_results/edgeR_analysis/edgeR_normalized_DE_result.csv’, in which to store normalized TMM-normalized counts, mean expression values per group, and statistical results.

6. Select DEGs based on default criteria: pval < 0.05 and log2FC > 1 | log2FC < 1. Store the result in ‘RNASeq_results/edgeR_analysis/edgeR_normalized_DE_result.csv’.

7. Additional data visualization: aside from the general data visualization mentioned above, a MeanVar plot, a biological coefficient of variance (BCV) plot, an MDS plot, and a Smear plot are also provided.

• MeanVar_Plot_edgeR.png: This visualizes the mean-variance relationship before and after TMM normalization using the plotMeanVar() function in edgeR.

• BCV_Plot_edgeR.png: This displays the genewise biological coefficient of variance (BCV) against gene abundance using the plotBCV() function in edgeR.

• MDS_Plot_edgeR.png: This presents the expression differences between the samples using the plotMDS.DGEList() function in edgeR.

• Smear_Plot_edgeR.png: This plots the log2-based fold change against the log10-based concentration using plotSmear() in edgeR.

9.5 Example

Run RNASeqDifferentialAnalysis_CMD() or RNASeqDifferentialAnalysis().

1. For runs in the background, the results will be reported in ‘Rscriptout/Differential_Analysis.Rout’. Make sure the differential expression analysis is successfully finished before running subsequent steps.

RNASeqDifferentialAnalysis_CMD(exp)

2. For runs in the R shell, the results will be reported in the R shell. Make sure the differential expression analysis is successfully finished before running subsequent steps.

RNASeqDifferentialAnalysis(exp)

10.1 GO Enrichment Analysis

GO is defined by three concepts relating to gene functions(GO terms) - molecular function(MF), cellular component(CC), and biological process(BP) - and by how these functions are related to each other. In this step, GO classification and GO over-representation tests are conducted. To classify significant GO terms, DEGs are analyzed by the groupGO() function. Similarly, the GO over-representation test of DEGs is conducted using enrichGO(). Both results are stored in a csv file and the top 15 GO terms are visualized by both a bar chart and a bubble plot.

In this example, the DESeq2 CC GO Classification bar chart is shown.

In this example, the DESeq2 MF GO Over-representation bar chart and the DESeq2 MF GO Over-representation dot plot are shown.

10.2 KEGG Pathway Analysis

KEGG is a database resource for understanding functions and utilities of a biological system from molecular-level information(KEGG website). In this step, KEGG over-representation tests can be conducted using the clusterProfiler package. A KEGG over-representation test of DEGs is conducted using enrichKEGG(). The result will be stored in a csv file. The pathway IDs that are found in the KEGG over-representation test will be visualized with the pathview package. KEGG pathway URL will also be stored.

In this example, due to the limited number of DEGs, no over-represented pathways are found.

10.3 Example

Run RNASeqGoKegg_CMD() or RNASeqGoKegg().

1. For runs in the background, the results will be reported in ‘Rscriptout/GO_KEGG_Analysis.Rout’.

RNASeqGoKegg_CMD(exp, 
                 OrgDb.species = "org.Sc.sgd.db",
                 go.level = 3, 
                 input.TYPE.ID = "GENENAME",
                 KEGG.organism = "sce")

2. Results from runs in the R shell will be reported in R shell.

RNASeqGoKegg(exp, 
             OrgDb.species = "org.Sc.sgd.db", 
             go.level = 3, 
             input.TYPE.ID = "GENENAME",
             KEGG.organism = "sce")