-
Notifications
You must be signed in to change notification settings - Fork 13
/
Copy path#RaMP_Vignette.Rmd#
272 lines (215 loc) · 13.2 KB
/
#RaMP_Vignette.Rmd#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
---
title: "RaMP-DB 2.0 Vignette"
author: "Kyle Spencer, Ewy Mathé, Andrew Patt, and Cole Tindall"
date: "`r Sys.Date()`"
output:
html_document:
self_contained: yes
highlight: kate
theme: yeti
toc: yes
fig_width: 9
fig_height: 7
code_folding: show
vignette: >
%\VignetteIndexEntry{Running RaMP locally}
%\VignetteEngine{knitr::rmarkdown}
%\VignetteEncoding{UTF-8}
---
## Introduction
This vignette will provide basic steps for interacting with [RaMP-DB](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC5876005/) (Relational database of Metabolomic Pathways).
The codebase for RaMP-DB is available on [our GitHub site](https://github.com/ncats/RaMP-DB). Details on RaMP-DB installation are also avaialble through GitHub, and questions can be asked through the Issues tab or by sending an email to [NCATSRaMP@nih.gov](mailto:NCATSRaMP@nih.gov).
RaMP-DB supports queries and enrichment analyses. Supported queries are:
- Retrieve Analytes From Input Pathway(s)
- Retrieve Pathways From Input Analyte(s)
- Retrieve Metabolites from Metabolite Ontologies
- Retrieve Ontologies from Input Metabolites
- Retrieve Analytes Involved in the Same Reaction
- Retrieve Chemical Classes from Input Metabolites
- Retrieve Chemical Properties from Input Metabolites
Supported enrichment analyses are:
- Perform Pathway Enrichment
- Perform Chemical Enrichment
Once installed, first load the package:
```{r message=F}
library(RaMP)
library(DT) # for prettier tables in vignette
library(dplyr)
library(magrittr)
pkg.globals <- setConnectionToRaMP(dbname="ramp2",username="ramp",conpass="r@mpt3stR!88",host = "ramp-db.ncats.io")
```
The latter line cannot be modified, other than changes to the parameters inside the function (e.g., values for dbname, username, conpass, and host). For example, if your password is different than "", you would set conpass="mypassword". This line needs be run only once, every time the package is loaded.
## Supported RaMP Queries
### Retrieve Analytes From Input Pathway(s)
Analytes (genes, proteins, metabolites) can be retrieve by pathway. Users have to input the exact pathway name. Here is an example:
```{r}
myanalytes <- getAnalyteFromPathway(pathway="sphingolipid metabolism")
```
```{r echo = FALSE}
cutoff <- 100
for(i in 1:nrow(myanalytes)) {
char.length <- nchar(myanalytes$sourceAnalyteIDs[i])
if(char.length >= cutoff) {
new.string <- substr(myanalytes$sourceAnalyteIDs[i], 1, cutoff)
new.string <- paste0(new.string, "...")
myanalytes$sourceAnalyteIDs[i] <- new.string
}
}
```
```{r}
datatable(myanalytes)
```
To retrieve information from multiple pathways, input a vector of pathway names:
```{r}
myanalytes <- getAnalyteFromPathway(pathway=c("De Novo Triacylglycerol Biosynthesis",
"sphingolipid metabolism"))
```
### Retrieve Pathways From Input Analyte(s)
It is oftentimes useful to get a sense of what pathways are represented in a dataset (this is particularly true for metabolomics, where coverage of metabolites varies depending on what platform is used). In other cases, one may be interested in exploring one or several metabolites to see what pathways they are arepresented in.
Note that it is always preferable to utilize IDs rather then common names.
When entering IDs, prepend each ID with the database of origin followed by a colon, for example kegg:C02712, hmdb:HMDB04824, etc.. It is possible to input IDs using multiple different sources. RaMP currently supports the following ID types (that should be prepended):
```{r}
metabprefixes <- getPrefixesFromAnalytes("metabolite")
geneprefixes <- getPrefixesFromAnalytes("gene")
datatable(rbind(metabprefixes, geneprefixes))
```
In this example, we will search for pathways that involve the two genes MDM2 and TP53, and the two metabolites glutamate and creatinine.
```{r}
pathwaydfids <- getPathwayFromAnalyte(c("ensembl:ENSG00000135679", "hmdb:HMDB0000064",
"hmdb:HMDB0000148", "ensembl:ENSG00000141510"))
datatable(pathwaydfids)
```
Note that each row returns a pathway attributed to one of the input analytes.
To retrieve the number of unique pathways returned for all analytes or each analyte, try the following:
```{r}
print(paste("Number of Unique Pathways Returned for All Analytes:",
length(unique(pathwaydfids$pathwayId))))
lapply(unique(pathwaydfids$commonName), function(x) {
(paste("Number of Unique Pathways Returned for",x,":",
length(unique(pathwaydfids[which(pathwaydfids$commonName==x),]$pathwayId))))})
```
### Retrieve Metabolites from Metabolite Ontologies
Conversely, the user can retrieve the metabolites that are associated with a specific ontology or vector of ontologies. We can accomplish this using the function getMetaFromOnto(). It should be noted that it does not matter which ontology the metabolites are from. The function will return all metabolites associated with all the ontologies specified by the user.
```{r}
ontologies.of.interest <- c("Colon", "Liver", "Lung")
new.metabolites <- RaMP::getMetaFromOnto(ontology = ontologies.of.interest)
datatable(new.metabolites)
```
### Retrieve Ontologies from Input Metabolites
RaMP contains information on where the metabolites originate from the biospecimen. This information is called ontology. Here are all the ontologies found in RaMP.
To retrieve ontologies that are associated with our metabolites we can use getOntoFromMeta(). This function takes in a vector of metabolites as an input and returns a vector comprised of the ontologies from the user's defined metabolites.
```{r}
analytes.of.interest <- c("ensembl:ENSG00000135679", "hmdb:HMDB0000064",
"hmdb:HMDB0000148", "ensembl:ENSG00000141510")
new.ontologies <- RaMP::getOntoFromMeta(analytes = analytes.of.interest)
datatable(new.ontologies)
```
### Retrieve Analytes Involved in the Same Reaction
The user may want to know what gene transcripts encode enzymes which can catalyze reactions involving metabolites in their experiment. RaMP can return this data to its user.
We can return the gene transcripts using the rampFastCata() function. To use it the user needs to provide a vector of metabolites they are interested in and the connection information for MySQL. The user can also input a vector of protein IDs or gene transcripts to return the metabolites involved in chemical reactions with the input proteins or gene transcript encoded proteins.
```{r message=F}
#Input Metabolites
analytes.of.interest <- c("ensembl:ENSG00000135679", "hmdb:HMDB0000064",
"hmdb:HMDB0000148", "ensembl:ENSG00000141510")
new.transcripts <- rampFastCata(analytes = analytes.of.interest)
datatable(new.transcripts)
#Input Proteins
proteins.of.interest <- c("uniprot:094808", "uniprot:Q99259")
new.metabolites <- rampFastCata(analytes = proteins.of.interest)
datatable(new.metabolites)
```
RaMP has a built in function which is able to generate networks from the transcript data. This function is named plotCataNetwork(). This function uses the dataframe created by rampFastCata() as an input. These plots are completely interactive.
```{r}
plotCataNetwork(new.transcripts)
```
### Retrieve Chemical Classes from Input Metabolites
RaMP incorporates Classfire and lipidMAPS classes. The function chemicalClassSurvey() function takes as input a vector of metabolites and outputs the classes associated with each metabolite input.
```{r}
metabolites.of.interest = c('hmdb:HMDB0000056','hmdb:HMDB0000439','hmdb:HMDB0000479','hmdb:HMDB0000532',
'hmdb:HMDB0001015','hmdb:HMDB0001138','hmdb:HMDB0029159','hmdb:HMDB0029412',
'hmdb:HMDB0034365','hmdb:HMDB0035227','hmdb:HMDB0007973','hmdb:HMDB0008057',
'hmdb:HMDB0011211')
chemical.classes <- chemicalClassSurvey(mets = metabolites.of.interest)
metabolite.classes <- as.data.frame(chemical.classes$met_classes)
datatable(metabolite.classes)
```
### Retrieve Chemical Property Information from Input Metabolites
Chemical properties captured by RaMP include SMILES, InChI, InChI-keys, monoisotopic masses, molecular formula, and common name. The getChemicalProperties() function takes as input a vector of metabolites and outputs a list of chemical property information that can easily be converted into a dataframe.
```{r}
chemical.properties <- getChemicalProperties(metabolites.of.interest)
chemical.data <- chemical.properties$chem_props
datatable(chemical.data)
```
## Enrichment Analyses
RaMP performs pathway and chemical class overrespresentation analysis using Fisher's tests.
### Perform Pathway Enrichment
Using the pathways that our analytes map to, captured in the pathwaydfids data frame in the previous step, we can now run Fisher's Exact test to identify pathways that are enriched for our analytes of interest:
```{r, results='hide'}
fisher.results <- runCombinedFisherTest(analytes = c(
"hmdb:HMDB0000033",
"hmdb:HMDB0000052",
"hmdb:HMDB0000094",
"hmdb:HMDB0000161",
"hmdb:HMDB0000168",
"hmdb:HMDB0000191",
"hmdb:HMDB0000201",
"chemspider:10026",
"hmdb:HMDB0006059",
"Chemspider:6405",
"CAS:5657-19-2",
"hmdb:HMDB0002511",
"chemspider:20171375",
"CAS:133-32-4",
"CAS:5746-90-7",
"CAS:477251-67-5",
"hmdb:HMDB0000695",
"chebi:15934",
"CAS:838-07-3",
"hmdb:HMDBP00789",
"hmdb:HMDBP00283",
"hmdb:HMDBP00284",
"hmdb:HMDBP00850"
))
```
*Note*: To explicitly view the results of mapping input IDs to RaMP, users can run the getPathwayFromAnalyte() function as noted in above in the section "Retrieve Pathways From Input Analyte(s)".
Once we have our fisher results we can format them into a new dataframe and filter the pathways for significance.
For this example we will be using an FDR p-value cutoff of 0.05.
```{r}
#Returning Fisher Pathways and P-Values
filtered.fisher.results <- FilterFishersResults(fisher.results, pval_type = 'holm', pval_cutoff=0.05)
```
Because RaMP combines pathways from multiple sources, pathways may be represented more than once. Further, due to the hierarchical nature of pathways and because Fisher's testing assumes pathways are independent, subpathways and their parent pathways may appear in a list.
To help group together pathways that represent similar biological processes, we have implemented a clustering algorithm that groups pathways together if they share analytes in common.
```{r}
clusters <- RaMP::findCluster(filtered.fisher.results,
perc_analyte_overlap = 0.2,
min_pathway_tocluster = 2, perc_pathway_overlap = 0.2
)
## print("Pathways with Holm-adjusted Pval < 0.05")
datatable(clusters$fishresults %>% mutate_if(is.numeric, ~ round(., 8)),
rownames = FALSE
)
```
To view clustered pathway results:
```{r, fig.height = 8}
pathwayResultsPlot(filtered.fisher.results, text_size = 8, perc_analyte_overlap = 0.2,
min_pathway_tocluster = 2, perc_pathway_overlap = 0.2, interactive = FALSE)
```
### Perform Chemical Enrichment
After retrieving chemical classes of metabolites, the function chemicalClassEnrichment() function will perform overrepresentation analysis using a Fisher's test and output classes that show enrichment in the user input list of metabolites relative to the backgroud metabolite population (all meteabolites in RaMP). The function performs enrichment analysis for Classyfire classes, sub-classess, and super-classes, and for LipidMaps categories, main classess, and sub classes.
```{r message=F}
metabolites.of.interest = c('hmdb:HMDB0000056','hmdb:HMDB0000439','hmdb:HMDB0000479','hmdb:HMDB0000532',
'hmdb:HMDB0001015','hmdb:HMDB0001138','hmdb:HMDB0029159','hmdb:HMDB0029412',
'hmdb:HMDB0034365','hmdb:HMDB0035227','hmdb:HMDB0007973','hmdb:HMDB0008057',
'hmdb:HMDB0011211')
chemical.enrichment <- chemicalClassEnrichment(mets = metabolites.of.interest)
# Enrichment was performed on the following chemical classes:
names(chemical.enrichment)
# To retrieve results for the ClassyFire Class:
classy_fire_classes <- chemical.enrichment$ClassyFire_class
datatable(classy_fire_classes)
```
*Note*: To explicitly view the results of mapping input IDs to RaMP, users can run the chemicalClassSurvey() function as noted in above in the section "Retrieve Chemical Class from Input Metabolites".
```{r}
sessionInfo()
```