928:    path <-paste(system.file(package="seq2pathway"),

856: get_python3_command_path <- function()

859:   python3_command_path <- Sys.which2("python")

1029:     script_path <- file.path(tempdir(), name)

275: pathwaygene<-length(intersect(toupper(gene_list[[i]]),

484: pathwaygene<-length(intersect(toupper(gsmap$genesets[[i]]),

843:   cmdpath <- Sys.which(cmdname)

1051: runseq2pathway<-function(inputfile,

1161: gene2pathway_result<-list()

1310: gene2pathway_test<-function(dat,DataBase="GOterm",FisherTest=TRUE,

1344: gene2pathway_result<-list()

854: #get_python3_command_path: funtion from Herve Pages, Bioconductor Maintainance Team, Oct 9 2020

858: #  python3_command_path <- Sys.which2("python3") #3/3/2021 by Holly

860:   if (python3_command_path != "")

864:           return(python3_command_path)}

873: #  python3_command_path <- Sys.which2("python")

874:   python3_command_path <- Sys.which2("python3")  #3/3/2021 by Holly

875:   if (python3_command_path != ""){

876:     print(paste0("python3 found: ",python3_command_path))

877:     return(python3_command_path)}

880:        "  'python3' (or 'python') executable is in your PATH.")

924:     ### assign the path of main function

932:     path <-paste(system.file(package="seq2pathway"),

976: 		sink(file.path(tempdir(),name,fsep = .Platform$file.sep))} 

994:     cat("'", path, "').load_module()",sep="")

1030:     if (!file.exists(script_path))

1032:     mypython <- get_python3_command_path()

1034:     response <- system2(mypython, args=script_path,

75: data(gencode_coding,package="seq2pathway.data")

155: data(gencode_coding,package="seq2pathway.data")

214: ####load GP pathway information

216:    data(GO_BP_list,package="seq2pathway.data")

217:    data(GO_MF_list,package="seq2pathway.data")

218:    data(GO_CC_list,package="seq2pathway.data") 

219:    data(Des_BP_list,package="seq2pathway.data")

220:    data(Des_MF_list,package="seq2pathway.data")

221:    data(Des_CC_list,package="seq2pathway.data")

223:          data(GO_BP_list,package="seq2pathway.data") 

224:          data(Des_BP_list,package="seq2pathway.data")

226:               data(GO_MF_list,package="seq2pathway.data") 

227:               data(Des_MF_list,package="seq2pathway.data")

229:                   data(GO_CC_list,package="seq2pathway.data")

230:                   data(Des_CC_list,package="seq2pathway.data")

237: data(GO_GENCODE_df_hg_v36,package="seq2pathway.data")

240: data(GO_GENCODE_df_hg_v19,package="seq2pathway.data")

243: data(GO_GENCODE_df_mm_vM25,package="seq2pathway.data")

246: data(GO_GENCODE_df_mm_vM1,package="seq2pathway.data")

280: c<-pathwaygene-a

289: mdat[i,7]<-pathwaygene

321: pathwaygene<-length(intersect(toupper(GO_BP_list[[i]]),

326: c<-pathwaygene-a

335: mdat[i,7]<-pathwaygene

367: pathwaygene<-length(intersect(toupper(GO_CC_list[[i]]),

372: c<-pathwaygene-a

381: mdat[i,7]<-pathwaygene

413: pathwaygene<-length(intersect(toupper(GO_MF_list[[i]]),

418: c<-pathwaygene-a

427: mdat[i,7]<-pathwaygene

455: data(Msig_GENCODE_df_hg_v36,package="seq2pathway.data")

458: data(Msig_GENCODE_df_hg_v19,package="seq2pathway.data")

461: data(Msig_GENCODE_df_mm_vM25,package="seq2pathway.data")

464: data(Msig_GENCODE_df_mm_vM1,package="seq2pathway.data")

489: c<-pathwaygene-a

498: mdat[i,7]<-pathwaygene

549: data(gencode_coding,package="seq2pathway.data")

647: rungene2pathway <-

704: colnames(res) <- c(paste(colnames(dat),"2pathscore",sep=""))

705: print("gene2pathway calculates score....... done")

711: rungene2pathway_EmpiricalP <-

770: colnames(res) <- c(paste(colnames(dat),"2pathscore",sep=""))

829: colnames(res_p) <- c(paste(colnames(dat),"2pathscore_Pvalue",sep=""))

832: print("pathwayscore Empirical Pvalue calculation..........done")

849:   success <- grepl(pattern1, cmdpath, fixed=TRUE) ||

850:     grepl(pattern2, cmdpath, fixed=TRUE)

851:   if (success) cmdpath else ""

1007:     #cat(paste("inputpath=","'",inputpath,"/'",sep=""),sep="\n")

1009:     #cat(paste("outputpath=","'",outputpath,"/'",sep=""),sep="\n")

1018:     cat(paste("pwd=","'",system.file(package="seq2pathway.data"),"/extdata/'",sep=""),sep="\n")

1103: data(GO_BP_list,package="seq2pathway.data")

1104: data(GO_MF_list,package="seq2pathway.data")

1105: data(GO_CC_list,package="seq2pathway.data")

1106: data(Des_BP_list,package="seq2pathway.data")

1107: data(Des_CC_list,package="seq2pathway.data")

1108: data(Des_MF_list,package="seq2pathway.data")

1134: #############################rungene2pathway,normalization,empiricalP,summary table

1166: GO_BP_FAIME<-rungene2pathway(dat=dat_CP,gsmap=GO_BP_list,alpha=alpha,logCheck=logCheck,

1171: GO_BP_FAIME_Pvalue<-rungene2pathway_EmpiricalP(dat=dat_CP,gsmap=GO_BP_list,

1174: ########gene2pathway table

1190: gene2pathway_result[[n.list]]<-GO_BP_N_P

1191: names(gene2pathway_result)[n.list]<-c("GO_BP")

1195: GO_MF_FAIME<-rungene2pathway(dat=dat_CP,gsmap=GO_MF_list,alpha=alpha,logCheck=logCheck,

1198: GO_MF_FAIME_Pvalue<-rungene2pathway_EmpiricalP(dat=dat_CP,gsmap=GO_MF_list,

1215: gene2pathway_result[[n.list]]<-GO_MF_N_P

1216: names(gene2pathway_result)[n.list]<-c("GO_MF")

1220: GO_CC_FAIME<-rungene2pathway(dat=dat_CP,gsmap=GO_CC_list,alpha=alpha,logCheck=logCheck,

1223: GO_CC_FAIME_Pvalue<-rungene2pathway_EmpiricalP(dat=dat_CP,gsmap=GO_CC_list,

1241: gene2pathway_result[[n.list]]<-GO_CC_N_P

1242: names(gene2pathway_result)[n.list]<-c("GO_CC")

1245: dat_FAIME<-rungene2pathway(dat=dat_CP,gsmap=DataBase,alpha=alpha,logCheck=logCheck,

1248: dat_FAIME_Pvalue<-rungene2pathway_EmpiricalP(dat=dat_CP,gsmap=DataBase,

1255: colnames(DB_N_P)<-c("score2pathscore_Normalized","score2pathscore_Pvalue")

1274: gene2pathway_result<-DB_N_P[,c(ncol(DB_N_P),1:(ncol(DB_N_P)-1))]

1276: print("gene2pathway analysis is done")

1279: if(exists("gene2pathway_result")&exists("FS_test")){

1283: TotalResult[[2]]<-gene2pathway_result

1284: names(TotalResult)[2]<-"gene2pathway_result.FAIME"

1286: names(TotalResult)[3]<-"gene2pathway_result.FET"

1289: }else if(exists("gene2pathway_result")&exists("FS_test")==FALSE){

1293: TotalResult[[2]]<-gene2pathway_result

1294: names(TotalResult)[2]<-"gene2pathway_result.FAIME"

1298: else if(exists("gene2pathway_result")==FALSE&exists("FS_test")){

1303: names(TotalResult)[2]<-"gene2pathway_result.FET"

1326: data(GO_BP_list,package="seq2pathway.data")

1327: data(GO_MF_list,package="seq2pathway.data")

1328: data(GO_CC_list,package="seq2pathway.data")

1329: data(Des_BP_list,package="seq2pathway.data")

1330: data(Des_CC_list,package="seq2pathway.data")

1331: data(Des_MF_list,package="seq2pathway.data")

1346: #############################rungene2pathway,normalization,empiricalP,summary table

1348: gene2pathway_result<-list()

1352:   GO_BP_method<-rungene2pathway(dat=dat,gsmap=GO_BP_list,alpha=alpha,logCheck=logCheck,

1358:     GO_BP_method_Pvalue<-rungene2pathway_EmpiricalP(dat=dat,gsmap=GO_BP_list,alpha=alpha,

1364:   ########gene2pathway table

1376:   gene2pathway_result[[n.list]]<-GO_BP_N_P

1377:   names(gene2pathway_result)[n.list]<-c("GO_BP")

1380:     GO_MF_method<-rungene2pathway(dat=dat,gsmap=GO_MF_list,alpha=alpha,logCheck=logCheck,

1384:       GO_MF_method_Pvalue<-rungene2pathway_EmpiricalP(dat=dat,gsmap=GO_MF_list,alpha=alpha,

1402:   gene2pathway_result[[n.list]]<-GO_MF_N_P

1403:   names(gene2pathway_result)[n.list]<-c("GO_MF")

1406:    GO_CC_method<-rungene2pathway(dat=dat,gsmap=GO_CC_list,alpha=alpha,logCheck=logCheck,

1410:       GO_CC_method_Pvalue<-rungene2pathway_EmpiricalP(dat=dat,gsmap=GO_CC_list,alpha=alpha,

1427:   gene2pathway_result[[n.list]]<-GO_CC_N_P

1428:   names(gene2pathway_result)[n.list]<-c("GO_CC")

1431: dat_method<-rungene2pathway(dat=dat,gsmap=DataBase,alpha=alpha,logCheck=logCheck,

1435: dat_method_Pvalue<-rungene2pathway_EmpiricalP(dat=dat,gsmap=DataBase,alpha=alpha,

1443: colnames(DB_N_P)<-c("score2pathscore_Normalized","score2pathscore_Pvalue")

1464: gene2pathway_result<-DB_N_P[,c(ncol(DB_N_P),1:(ncol(DB_N_P)-1))]

1466: print("gene2pathway analysis is done")

1470: if(exists("gene2pathway_result")&exists("FS_test")){

1472: TResult[[1]]<-gene2pathway_result

1473: names(TResult)[1]<-"gene2pathway_result.2"

1475: names(TResult)[2]<-"gene2pathway_result.FET"

1476: }else if(exists("gene2pathway_result")&exists("FS_test")==FALSE){

1477: TResult<-gene2pathway_result

1479: else if(exists("gene2pathway_result")==FALSE&exists("FS_test")){

101:         path <- paste(dir, file, sep='//')

34:         paths <- list.files(xmlDir) 

83: pathwayToGraph <- function (i, ...)

3: createPathwayGraphs <- function(org, pathways, edgeTypes, doubleEdges, choice,

141: getPathwayType                    <- function(filepath, file)

159: metabolicPathwayToGraph           <- function(filepath)

347: nonMetabolicPathwayToGraph <- function(filepath, doubleEdges, groupMode)

102:         gr   <- metabolicPathwayToGraph(path)

119:         path <- paste(dir, file, sep='//')

120:         gr   <- nonMetabolicPathwayToGraph(path, doubleEdges, groupMode)

225: removeCompoundsMetabolicGraph     <- function(path)

228:     if(path$name != gsub('ec','',path$name)) { nodeType<-"enzyme" }

229:     enzymes  <- which(path$vertices$type == nodeType)

230:     vid      <- path$vertices$id

233:     if ( length(path$edges) > 0 )

243:             for (r1 in path$edges[path$edges$e1 == 

244:                                 path$vertices[,'id'][enzymes[j]],]$e2)  

247:                 for (r2 in path$edges[path$edges$e1 == 

248:                                 path$vertices[,'id'][which(vid == r1)],]$e2)

252:                     nid <- vid[which(path$vertices$id == r2)]

267:     xid    <- path$vertices$id[enzymes]

268:     names  <- path$vertices$names[enzymes]       

513: removeCompoundsNonMetabolicGraph <- function(path, unique, edgeTypes)

515:     if (is.null(path)) return(NULL)

516:     vid      <- as.numeric(path$vertices$id)

517:     etype    <- path$vertices$type

519:     if(path$name != gsub('ko','',path$name)) { nodeType <- "ortholog" }

522:     genesIndx <- which(path$vertices$type == nodeType)

528:         neighbors <- path$edges$e2[path$edges$e1 == vid[gi]]

546:                 idx1 <- which( path$edges$e1 == vid[gi] )

547:                 idx2 <- which( path$edges$e2 == vid[nbrId] )

549:                 TT   <- c( TT, paste((path$edges$type[idx]), collapse='_') )

557:                 cpdNeighbors <- path$edges$e2[ 

558:                                         which(path$edges$e1 == vid[nbrId]) ]

586:         names            <- unique(path$vertices$names[genesIndx])

598:             idx1 <- which(path$vertices$id == source[i])

599:             idx2 <- which(path$vertices$id == destin[i])

600:             source[i] <- names[ names == path$vertices$names[idx1] ]

601:             destin[i] <- names[ names == path$vertices$names[idx2] ]

623:         gids                <- path$vertices$id[genesIndx]

624:         names               <- unname(path$vertices$names[genesIndx])

31:     # Choose valid pathways

32:     if (missing(pathways))  

37:     if (!missing(pathways)) 

39:         paths <- paste(org, pathways, '.xml', sep='') 

44:     # Create compact adjacency matrices for given pathways.

45:     types  <- getPathwayType(paste(xmlDir, paths, sep='//'))

46:     N <- length(paths)

56:                     funcName=pathwayToGraph,

59:                     N=length(paths),

61:                     xmlDir, paths, types, FALSE, edgeTypes, 

64:     names(cAdjMats) <- gsub('.xml', '', paths)

67:     eAdjMats <- .doSafeParallel(funcName=pathwayToGraph,

70:                                 N=length(paths),

72:                                 xmlDir, paths, types, TRUE, edgeTypes, 

75:     names(eAdjMats) <- gsub('.xml', '', paths)

143:     types <- vector(mode='numeric', length=length(filepath))

144:     for (i in 1:length(filepath))

146:         num <- tail(unlist(strsplit(filepath[i], '//')), 1)

156: # Graph from Metabolic Pathways

161:     xmlDoc <- tryCatch(xmlTreeParse(filepath,error=NULL),

344: # Graph from Mon Metabolic Pathways

350:     xmlDoc         <- tryCatch(xmlTreeParse(filepath,error=NULL),

49:         'nonMetabolicPathwayToGraph', 'expandMetabolicGraph', 

51:         'metabolicPathwayToGraph', 'expandNonMetabolicGraph',

609:                 # Set new interaction types to apathetic

732:     # apathetic  3

61:         path <- self$getEntry(path.id)

59:     for (path.id in id) {

127:     for (path.id in id) {

304:     path_idx <- sub('^[^0-9]+', '', id)

322:     path_idx <- sub('^[^0-9]+', '', id)

29: KeggPathwayConn <- R6::R6Class("KeggPathwayConn",

40:     super$initialize(db.name='pathway', db.abbrev='path', ...)

62:         if ( ! is.null(path) && path$hasField('kegg.module.id')) {

65:             for (mod.id in path$getFieldValue('kegg.module.id')) {

144:             graph[[path.id]]=list(vertices=vert, edges=edg)

147:             graph[[path.id]]=NULL

309:         params=c(org_name='map', mapno=path_idx,

325:     img_filename <- paste0('pathwaymap-', path_idx)

331:             biodb::error0('Impossible to find pathway image path inside',

335:         tmp_file <- file.path(cache$getTmpFolderPath(),

2: #' The connector class to KEGG Pathway database.

16: #' conn=mybiodb$getFactory()$createConn('kegg.pathway')

18: #' # Retrieve all reactions related to a mouse pathway:

21: #' # Get a pathway graph

44: #' Retrieves all reactions part of a KEGG pathway. Connects to

45: #'     KEGG databases, and walk through all pathways submitted, and

58:     # Loop on all Pathway IDs

89: #' Takes a list of pathways IDs and converts them to the specified organism,

92: #' @param org The organism in which to search for pathways, as a KEGG organism

113: #' Builds a pathway graph in the form of two tables of vertices and edges,

115: #' @param id A character vector of KEGG pathway entry IDs.

120: #' @return A named list whose names are the pathway IDs, and values are lists

126:     # Loop on all pathway IDs

158: #' Builds a pathway graph, as an igraph object, using KEGG database.

159: #' @param id A character vector of KEGG pathway entry IDs.

196: #' Create a pathway graph picture, with some of its elements colorized.

197: #' @param id A KEGG pathway ID.

227: #' Extracts shapes from a pathway map image.

228: #' @param id A KEGG pathway ID.

303:     # Extract pathway number

308:         'show_pathway'),

329:             'src="([^"]+)"(\\s+.*)?\\s+(name|id)="pathwayimage"')

332:                 ' HTML page for pathway ID ', id, '.')

342:     img_file <- cache$getFilePath(cid, img_filename, 'png')

22: #' graph=conn$buildPathwayGraph('mmu00260')

98: convertToOrgPathways=function(id, org) {

122: buildPathwayGraph=function(id, directed=FALSE, drop=TRUE) {

166: getPathwayIgraph=function(id, directed=FALSE, drop=TRUE) {

173:         g <- self$buildPathwayGraph(id=id, directed=directed, drop=FALSE)

210:         pix <- private$getPathwayImage(id)

213:         shapes <- self$extractPathwayMapShapes(id=id, color2ids=color2ids)

233: ,extractPathwayMapShapes=function(id, color2ids) {

237:     html <- private$getPathwayHtml(id)

301: ,getPathwayHtml=function(id) {

319: getPathwayImage=function(id) {

321:     html <- private$getPathwayHtml(id)

353:   path <- merge(merge1, symb, by = "gene")

66:     pathTable <- unique(keggPathwayDB(org_assembly))

72:     pathfreq <- as.data.frame(table(annot$pathway))

100:     pathT <- as.character(freq$Var1[enrich])

119:     pathways <- data.frame(unique(pathT))

205:     pathTable <- unique(reactomePathwayDB(org_assembly))

211:     pathfreq <- as.data.frame(table(annot$pathway))

237:     pathT <- as.character(freq$Var1[enrich])

542:   pathTable <- unique(WikiPathwayDB(org_assembly))

547:   pathfreq <- as.data.frame(table(annot$pathID))

573:   pathT <- as.character(freq$Var1[enrich])

580:   pathTerms <- as.character(r$pathTerm[match(pathT, r$pathID)])

630: pathwayEnrichment <- function(genes,

679:   pathfreq <- as.data.frame(table(annot$pathTerm))

711:   pathT <- as.character(freq$Var1[enrich])

719:   pathTerms <- as.character(r$pathTerm[match(pathT, r$pathID)])

272: reactomePathwayDB <- function(org_assembly = c("hg19",

359: keggPathwayDB <- function(org_assembly = c("hg19",

435: WikiPathwayDB <- function(org_assembly = c("hg19",

15: #' @param gmtFile File path of the gmt file

92:         file.path(x[1], x[2]))

96:         file.path(x[1], x[2]))

156: #' @param gmtFile File path of the gmt file

230:       file.path(x[1], x[2]))

233:       file.path(x[1], x[2]))

355:   return(path)

501: #' @param gmtFile File path of the gmt file

565:       file.path(x[1], x[2]))

569:       file.path(x[1], x[2]))

610: #' @param gmtFile File path of the gmt file

704:     file.path(x[1], x[2]))

707:     file.path(x[1], x[2]))

1: #' KEGG pathway enrichment

22: #' @return KEGG pathway enrichment results

69:     annot <- pathTable[which(pathTable$symbol %in% genes$g),]

73:     pathfreq <- pathfreq[which(pathfreq$Freq > 0),]

76:     geneSize = length(unique(pathTable$symbol))

78:     bckfreq <- as.data.frame(table(pathTable$pathway))

79:     notGene <- bckfreq[bckfreq$Var1 %in% pathfreq$Var1,]

80:     freq <- merge(pathfreq, notGene, by = "Var1")

105:     r <- annot[annot$pathway %in% pathT,]

107:     for (i in seq_along(pathT))

109:       if (length(which(pathT[i] == r$pathway)) > 0)

114:               as.character(r[which(pathT[i] == r$pathway),]$symbol)),

115:                      paste(pathT[i])))

120:     tmp <- character(length(pathT))

121:     if (nrow(pathways) > 0) {

123:         unlist(lapply(seq_len(nrow(pathways)), function(x)

124:           tmp[x] <- try(KEGGREST::keggGet(pathT[x])[[1]]$NAME)

130:         ID = pathT,

142: #' Reactome pathway enrichment

164: #' @return Reactome pathway enrichment results

208:     annot <- pathTable[which(pathTable$symbol %in% genes$g),]

212:     pathfreq <- pathfreq[which(pathfreq$Freq > 0),]

214:     geneSize = length(unique(pathTable$symbol))

216:     bckfreq <- as.data.frame(table(pathTable$pathway))

217:     notGene <- bckfreq[bckfreq$Var1 %in% pathfreq$Var1,]

218:     freq <- merge(pathfreq, notGene, by = "Var1")

242:     r <- annot[annot$pathway %in% pathT,]

246:     for (i in seq_along(pathT))

248:       if (length(which(pathT[i] == r$pathway)) > 0)

253:               list(as.character(r[which(pathT[i] == r$pathway),]$symbol)),

254:                      paste(pathT[i])))

260:         ID = pathT,

261:         Term = as.character(rt[order(match(rt$pathway, pathT)), ]$name),

281:   table1 <- data.frame(pathway = rep(names(xx), lapply(xx, length)),

284:   pn <- data.frame(pathway = rep(names(pn), lapply(pn, length)),

290:     ty <- table1[grepl("^R-HSA", table1$pathway),]

291:     pn1 <- pn[grepl("^R-HSA", pn$pathway),]

298:     ty <- table1[grepl("^R-MMU", table1$pathway),]

299:     pn1 <- pn[grepl("^R-MMU", pn$pathway),]

306:     ty <- table1[grepl("^R-DRE", table1$pathway),]

307:     pn1 <- pn[grepl("^R-DRE", pn$pathway),]

314:     ty <- table1[grepl("^R-RNO", table1$pathway),]

315:     pn1 <- pn[grepl("^R-RNO", pn$pathway),]

322:     ty <- table1[grepl("^R-CEL", table1$pathway),]

323:     pn1 <- pn[grepl("^R-CEL", pn$pathway),]

330:     ty <- table1[grepl("^R-SCE", table1$pathway),]

331:     pn1 <- pn[grepl("^R-SCE", pn$pathway),]

344:     ty <- table1[grepl("^R-DME", table1$pathway),]

345:     pn1 <- pn[grepl("^R-DME", pn$pathway),]

351:                   by = "pathway",

371:     kegg <- org.Hs.eg.db::org.Hs.egPATH2EG

379:     kegg <- org.Mm.eg.db::org.Mm.egPATH2EG

387:     kegg <- org.Dr.eg.db::org.Dr.egPATH2EG

395:     kegg <- org.Rn.eg.db::org.Rn.egPATH2EG

403:     kegg <- org.Ce.eg.db::org.Ce.egPATH2EG

411:     kegg <- org.Sc.sgd.db::org.Sc.sgdPATH2ORF

419:     kegg <- org.Dm.eg.db::org.Dm.egPATH2EG

425:   pathTable <-

426:     data.frame(pathway = paste0(prefix, rep(names(kegg2),

431:   pathTable <- merge(pathTable, x, by = "gene")

432:   return(pathTable)

474:     do.call(rbind, strsplit(as.character(gmtFile$pathTerm), '%'))

480:         pathID = tmp[, 3],

481:         pathTerm = tmp[, 1]

508: #' @return Wiki Pathway Enrichment

545:   annot <- pathTable[which(pathTable$gene %in% genes$g),]

548:   pathfreq <- pathfreq[which(pathfreq$Freq > 0),]

550:   geneSize = length(unique(pathTable$gene))

551:   bckfreq <- as.data.frame(table(pathTable$pathID))

552:   notGene <- bckfreq[bckfreq$Var1 %in% pathfreq$Var1,]

553:   freq <- merge(pathfreq, notGene, by = "Var1")

578:   r <- annot[annot$pathID %in% pathT,]

581:   for (i in seq_along(pathT))

583:     if (length(which(pathT[i] == r$pathID)) > 0)

587:           list(as.character(r[which(pathT[i] == r$pathID),]$gene)),

588:                           paste(pathT[i])))

595:       ID = pathT,

596:       Term = pathTerms,

606: #' For a given gmt file of a specific pathway database, pathway enrichment

628: #' @return Pathway Enrichment

671:     pathTable <-

676:     pathTable <- geneListEnrich(f = gmtFile, isSymbol = isSymbol)

678:   annot <- pathTable[which(pathTable$symbol %in% genes$g),]

680:   pathfreq <- pathfreq[which(pathfreq$Freq > 0),]

684:     geneSize = length(unique(pathTable$symbol))

689:   bckfreq <- as.data.frame(table(pathTable$pathTerm))

691:   notGene <- bckfreq[bckfreq$Var1 %in% pathfreq$Var1,]

692:   freq <- merge(pathfreq, notGene, by = "Var1")

717:   r <- annot[annot$pathTerm %in% pathT,]

721:   for (i in seq_along(pathT))

723:     if (length(which(pathT[i] == r$pathTerm)) > 0)

726:           list(as.character(r[which(pathT[i] == r$pathTerm),]$symbol)),

727:                           paste(pathT[i])))

732:       ID = pathT,

733:       Term = pathTerms,

743: #' Convert gmt formatted pathway file to the Pathway ID, Entrez, symbol

746: #' @param gmtName Custom pathway gmt file

815:     colnames(f) <- c('pathTerm', 'Entrez', 'symbol')

830:     colnames(f) <- c('pathTerm', 'symbol', 'Entrez')

852:     colnames(f) <- c('pathTerm', 'Entrez', 'symbol')

863:     colnames(f) <- c('pathTerm', 'symbol', 'Entrez')

280:   xx <- as.list(reactome.db::reactomePATHID2EXTID)

283:   pn <- as.list(reactome.db::reactomePATHID2NAME)

445:       rWikiPathways::downloadPathwayArchive(organism = "Homo sapiens",

449:       rWikiPathways::downloadPathwayArchive(organism = "Mus musculus",

453:       rWikiPathways::downloadPathwayArchive(organism = "Danio rerio",

457:       rWikiPathways::downloadPathwayArchive(organism = "Rattus norvegicus",

461:       rWikiPathways::downloadPathwayArchive(

465:       rWikiPathways::downloadPathwayArchive(

469:       rWikiPathways::downloadPathwayArchive(

487: #' WikiPathways Enrichment

190:         Path <- list(Type1=new("graphNEL", vertices, edgeL=arestas1),

326:         Path <- new("graphNEL", vertices, edgeL=arestas)

167:     graphPath <- function(data=NULL, cuttoffPvalue) {

309:     graphPath <- function(data=NULL, cuttoffCor=NULL, cuttoffP=NULL) {

194:         return(Path)

327:         return(Path)

287:     graph <- graphPath(x, cutPval)

426:         graph <- graphPath(x, cutCor, NULL)

431:         graph <- graphPath(x, NULL, cutPval)

928:         path <- system.file("doc", "pcaExplorer.html", package = "pcaExplorer")

929:         if (path == "") {

932:           browseURL(path)

936:         path <- system.file("doc", "upandrunning.html", package = "pcaExplorer")

937:         if (path == "") {

940:           browseURL(path)

261:                                  # Use web vignette, with varying paths depending on whether we're release or devel.

271:                                  # Use web vignette, with varying paths depending on whether we're release or devel.

1047:       cm <- utils::read.delim(input$uploadcmfile$datapath, header = TRUE,

1081:       coldata <- utils::read.delim(input$uploadmetadatafile$datapath, header = TRUE,

1114:       annodata <- utils::read.delim(input$uploadannotationfile$datapath, header = TRUE,

13:   path <- "data/discover"

92:   path <- "data/eventsHierarchy"

115:   path <- "data/orthology"

151:   path <- "data/participants"

254:   path <- "data/pathways/low/entity"

324:   path <- "data/person"

364:   path <- "search/facet"

410:   path <- "data/query/enhanced"

452:   path <- "data/schema"

542:   path <- "search/query"

586:   path <- "data/species"

261:   pathways <- .retrieveData(url, as="text")

272:     top.pathways <- foreach(id=pathways$dbId, .export=c(".retrieveData", ".checkStatus"), .combine=dfcomb) %dopar% {

253: getPathways <- function(id, species=NULL, allForms=FALSE, top.level=FALSE) {

332:     authoredPathways <- .retrieveData(ap.url, as="text")

14:   url <- file.path(getOption("base.address"), path, event.id)

61:     url <- file.path(getOption("base.address"), "data/complex", id, 

64:     url <- file.path(getOption("base.address"), "data/complexes", resource, id)

66:     url <- file.path(getOption("base.address"), "data/entity", id, retrieval)

94:   url <- file.path(getOption("base.address"), path, taxon.id)

118:   url <- file.path(getOption("base.address"), path, id, "species", species.id)

154:   url <- file.path(getOption("base.address"), path, event.id) #all participants

162:     url <- file.path(url, "participatingPhysicalEntities")

164:     url <- file.path(url, "referenceEntities")

166:     # in a different path/method - /data/pathway/{id}/containedEvents

167:     url <- file.path(getOption("base.address"), "data/pathway", event.id, "containedEvents")

256:   url <- file.path(getOption("base.address"), path, id)

257:   if (allForms) url <- file.path(url, "allForms")

274:       ancestors.url <- file.path(getOption("base.address"), "data/event", id, "ancestors")

327:     url <- file.path(getOption("base.address"), path, id)

331:     ap.url <- file.path(url, "authoredPathways")

338:       tmp.url <- file.path(getOption("base.address"), path, id, attribute)

371:   url <- file.path(getOption("base.address"), path)

411:   url <- file.path(getOption("base.address"), path, id)

453:   url <- file.path(getOption("base.address"), path, class)

457:   cnt.url <- file.path(url, "count")

484:   if (minimised) url <- file.path(url, "min")

485:   if (reference) url <-file.path(url, "reference")

543:   url <- file.path(getOption("base.address"), paste0(path, "?query=", gsub("\\s", "%20", query)))

589:                 file.path(getOption("base.address"), path, "main"),

590:                 file.path(getOption("base.address"), path, "all"))

75: #' Events (Pathways and Reactions) in Reactome are organized in a hierarchical 

129: #' Data in Reactome are organized in a hierarchical manner - Pathways contain Reactions, 

136: ...(11 bytes skipped)...g{ReferenceEntities}: retrieves the ReferenceEntities for all PhysicalEntities in every constituent Pathway/Reaction

139: #' @param event.id a stable or db id of an Event (pathways and reactions)

168:     msg <- "'Events' are found in the 'hasEvent' attribute of Pathways"

234: #' Pathway related queries

238: #' @param id a stable or db id of a PhysicalEntity or Event present in the pathways

240: #' @param allForms if set to \code{TRUE}, all low level pathways that contain the given PhysicalEntity (not Event) in all forms returned

241: #' @param top.level if set to \code{TRUE}, only top-level pathways returned

242: #' @return a dataframe containing requested pathways

263:   # map to top level pathways

281:     rownames(top.pathways) <- seq(1, nrow(top.pathways))

282:     return(top.pathways)

284:     return(pathways)

330:     # add authored pathways if any

532: #' searchQuery(query="Biological oxidation", species="Mus musculus", types=c("Pathway", "Reaction"))

576: #' either manually curated or computationally inferred pathways

137: #' - \strong{EventsInPathways}: recursively retrieves all the Events contained in any given Event

140: ...(26 bytes skipped)...ipants to be retrieved, including "AllInstances", "PhysicalEntities", "ReferenceEntities", "EventsInPathways"

144: #' getParticipants("R-HSA-69306", "EventsInPathways")

150:                                                   "ReferenceEntities", "EventsInPathways")) {

165:   } else if (retrieval == "EventsInPathways") {

236: #' To get the Events that contain the given PhysicalEntity or Event (i.e. subpathway).

244: #' getPathways("R-HSA-199420", "Homo sapiens")

245: #' @rdname getPathways

277:       ancestors[ancestors$schemaClass == "TopLevelPathway",]

333:     if (length(authoredPathways) != 0) all.info[["authoredPathways"]] <- authoredPathways

185:     path = all_paths[maxBW, ]

140:     path_individual = as.character(row)

278: path_as_network = function(path) {

123:   shortpath = rownames(as.matrix(unlist(ASP)))

347:     pathM = convertTable(response)

122: ASP_paths = function (ASP) {

360:     all_pathsGM_names = all_pathsGM

341: MS_FindPathway = function(match = NULL, organism_code = NULL) {

141:     BW = sapply(path_individual, get_bw_score, BW_matrix)

180:     ## Get global BW score for each path

186:     path = as.character(path)

187:     all_paths = matrix(path, ncol = length(path))

277: ##################### path_as_network ######################

280:     for (i in 1:(length(path) - 1)) {

281:         edge = c(path[i], path[i + 1])

348:     colnames(pathM) = c("path_ID", "path_Description")

17: #metabolite is a substrate. It is used to calculate shortest paths with SP mode.

121: ####################### ASP_paths #######################

124:   return(shortpath)

150: BW_ranked_SP = function (all_paths, BW_matrix, networkBW_i, mode) {

152:     all_nodes = unique(as.vector(all_paths))

181:     Global_BW_score = sapply (split(all_paths, row(all_paths)), get_global_BW_score,

189:     return(all_paths)

342:     file = paste("https://rest.kegg.jp/list/pathway/", organism_code, sep = "")

345:         stop("A valid organism_code is required for KEGG_entry = pathway")

349:     rownames(pathM) = NULL

351:         target_matrix = pathM

352:         target_column = pathM[, 2]

355:     } else (return(pathM))

359: network_names = function(all_pathsGM, organism_code) {

361:     all_nodes = unique(as.vector(all_pathsGM[, 1:2]))

365:         all_pathsGM_names[all_pathsGM_names == all_nodes[i]] = all_names[i]

367:     return(all_pathsGM_names)

340: #################### MS_FindPathway ####################

11:   sparklyr::spark_read_csv(connection, "mstinput", path = input_file,

95:                               path=paste0("/", index_file), 

217:   path <- NULL

92:   server <- epivizrServer::createServer(static_site_path = webpath, non_interactive=non_interactive, ...)

219:   server <- epivizrServer::createServer(static_site_path = webpath, non_interactive=non_interactive, ...)

84:   webpath <- system.file("www", package = "epivizrStandalone")

215:   webpath <- ""

222:                               path=path, 

104:     path<-getwd()

105:     cat("Plot was saved in ",paste(path,"/",fileName,sep=""),"\n")

106: path <- system.file("files", package="PloGO2")

107: allDat = read.csv(file.path(path,"rice.csv") )

108: Group = read.csv(file.path(path, "group_rice.csv") ) [,2]

5439:             path <- env[['PATH_INFO']]

6044:             path <- env[['PATH_INFO']]

2147:                 pathsizes <- unlist(tapply(vi, gcll, length))

5059: pathway.pc.correlation.distance <- function(pcc, xv, n.cores = 10, target.ndf = NULL) {

6173:                        pathcl <- ifelse(is.null(req$params()$pathcl), 1, as.integer(req$params()$pathcl))

1877: pagoda.pathway.wPCA <- function(varinfo, setenv, n.components = 2, n.cores = detectCores(), min.pathway.size = 10, max.pathway.size = 1e3, n.randomizations = 10, n.internal.shuffles = 0, n.starts = 10, center = TRUE, batch....(55 bytes skipped)...

5558: t.view.pathways <- function(pathways, mat, matw, env, proper.names = rownames(mat), colcols = NULL, zlim = NULL, labRow = NA, vhc = ...(145 bytes skipped)...

5684: pagoda.show.pathways <- function(pathways, varinfo, goenv = NULL, n.genes = 20, two.sided = FALSE, n.pc = rep(1, length(pathways)), colcols = NULL, zlim = NULL, showRowLabels = FALSE, cexCol = 1, cexRow = 1, nstarts = 10, ce...(117 bytes skipped)...

5698: c.view.pathways <- function(pathways, mat, matw, goenv = NULL, batch = NULL, n.genes = 20, two.sided = TRUE, n.pc = rep(1, length(pathways)), colcols = NULL, zlim = NULL, labRow = NA, vhc = NULL, cexCol = 1, cexRow = 1, nstarts = 50, ...(93 bytes skipped)...

461: ##' @param name URL path name for this app

5443:             switch(path,

6047:             switch(path,

1: ##' Single-cell Differential Expression (with Pathway And Gene set Overdispersion Analysis)

6: ##' The scde package also contains the pagoda framework which applies pathway and gene set overdispersion analysis

9: ##' See vignette("pagoda") for a brief tutorial on pathway and gene set overdispersion analysis to identify and characterize cell subpopulations.

1292: ...(39 bytes skipped)...lowed for the estimated adjusted variance (capping of adjusted variance is recommended when scoring pathway overdispersion relative to randomly sampled gene sets)

1789: ##' such as ribosomal pathway variation) and subtracts it from the data so that it is controlled

1815: ##' cc.pattern <- pagoda.show.pathways(ls(go.env)[1:2], varinfo, go.env, show.cell.dendrogram = TRUE, showRowLabels = TRUE)  # Look at...(30 bytes skipped)...

1845: ##' @param min.pathway.size minimum number of observed genes that should be contained in a valid gene set

1846: ##' @param max.pathway.size maximum number of observed genes in a valid gene set

1847: ...(103 bytes skipped)...ith each gene set (can be kept at 5 or 10, but should be increased to 50-100 if the significance of pathway overdispersion will be determined relative to random gene set models)

1873: ##' pwpca <- pagoda.pathway.wPCA(varinfo, go.env, n.components=1, n.cores=10, n.internal.shuffles=50)

1901:         gsl <- gsl[gsl.ng >= min.pathway.size & gsl.ng<= max.pathway.size]

1905:         message("processing ", length(gsl), " valid pathways")

1954: ##' @param pwpca result of the pagoda.pathway.wPCA() call with n.randomizations > 1

1965: ##' pwpca <- pagoda.pathway.wPCA(varinfo, go.env, n.components=1, n.cores=10, n.internal.shuffles=50)

2148:                 names(pathsizes) <- pathsizes

2151:                     rsdv <- unlist(lapply(names(pathsizes), function(s) {

2156:                     return(data.frame(n = as.integer(pathsizes), var = unlist(sdv), round = i, rvar = rsdv))

2160:                 data.frame(n = as.integer(pathsizes), var = unlist(sdv), round = i)

2216: ##' @param pwpca output of pagoda.pathway.wPCA()

2242: ##' pwpca <- pagoda.pathway.wPCA(varinfo, go.env, n.components=1, n.cores=10, n.internal.shuffles=50)

2393:     # determine genes driving significant pathways

2435: ##' @param pwpca output of pagoda.pathway.wPCA()

2453: ##' pwpca <- pagoda.pathway.wPCA(varinfo, go.env, n.components=1, n.cores=10, n.internal.shuffles=50)

2460:     pclc <- pathway.pc.correlation.distance(c(pwpca, clpca$cl.goc), tam$xv, target.ndf = 100, n.cores = n.cores)

2521: ##' pwpca <- pagoda.pathway.wPCA(varinfo, go.env, n.components=1, n.cores=10, n.internal.shuffles=50)

2603: ##' pwpca <- pagoda.pathway.wPCA(varinfo, go.env, n.components=1, n.cores=10, n.internal.shuffles=50)

2654: ##' @param tamr Combined pathways that show similar expression patterns. Output of \code{\link{pagoda.reduce.redundancy}}

2655: ##' @param row.clustering Dendrogram of combined pathways clustering

2667: ##' pwpca <- pagoda.pathway.wPCA(varinfo, go.env, n.components=1, n.cores=10, n.internal.shuffles=50)

2724: ##' @param tamr Combined pathways that show similar expression patterns. Output of \code{\link{pagoda.reduce.redundancy}}

2725: ##' @param tam Combined pathways that are driven by the same gene sets. Output of \code{\link{pagoda.reduce.loading.redundancy}}...(0 bytes skipped)...

2728: ...(15 bytes skipped)...a Weighted PC magnitudes for each gene set provided in the \code{env}. Output of \code{\link{pagoda.pathway.wPCA}}

2732: ##' @param row.clustering Dendrogram of combined pathways clustering. Default NULL.

2733: ##' @param title Title text to be used in the browser label for the app. Default, set as 'pathway clustering'

2739: ...(47 bytes skipped)... env, pwpca, clpca = NULL, col.cols = NULL, cell.clustering = NULL, row.clustering = NULL, title = "pathway clustering", zlim = c(-1, 1)*quantile(tamr$xv, p = 0.95)) {

2764:     # prepare pathway df

3559: .onUnload <- function(libpath) {

3560:     library.dynam.unload("scde", libpath, verbose = TRUE)

5108:         #set scale at top pathway?

5560:     lab <- which(proper.names %in% na.omit(unlist(mget(pathways, envir = env, ifnotfound = NA))))

5564:         lab <- which(proper.names %in% pathways)

5569:     #table(rownames(mat) %in% mget(pathways, envir = env))

5660: ##' View pathway or gene weighted PCA

5662: ##' Takes in a list of pathways (or a list of genes), runs weighted PCA, optionally showing the result.

5663: ##' @param pathways character vector of pathway or gene names

5665: ##' @param goenv environment mapping pathways to genes

5668: ...(5 bytes skipped)...param n.pc optional integer vector giving the number of principal component to show for each listed pathway

5681: ##' @param ... additional arguments are passed to the \code{c.view.pathways}

5687:     x <- c.view.pathways(pathways, varinfo$mat, varinfo$matw, goenv, batch = varinfo$batch, n.genes = n.genes, two.sided = two.si...(213 bytes skipped)...

5695: # takes in a list of pathways with a list of corresponding PC numbers

5696: # recalculates PCs for each individual pathway, weighting gene loading in each pathway and then by total

5697: # pathway variance over the number of genes (rough approximation)

5699:     # are these genes or pathways being passed?

5701:         x <- pathways %in% ls(goenv)

5703:         x <- rep(FALSE, length(pathways))

5705:     if(sum(x) > 0) { # some pathways matched

5707:         message("WARNING: partial match to pathway names. The following entries did not match: ", paste(pathways[!x], collapse = " "))

5709:         # look up genes for each pathway

5710:         pathways <- pathways[x]

5711:         p.genes <- mget(pathways, goenv, ifnotfound = NA)

5713:         x <- pathways %in% rownames(mat)

5716: ...(9 bytes skipped)...       message("WARNING: partial match to gene names. The following entries did not match: ", paste(pathways[!x], collapse = " "))

5718:             p.genes <- list("genes" = pathways[x])

5719:             pathways <- c("genes");

5720:         } else { # neither genes nor pathways are passed

5721:             stop("ERROR: provided names do not match either gene nor pathway names (if the pathway environment was provided)")

5728:     # recalculate wPCA for each pathway

5729:     ppca <- pagoda.path...(130 bytes skipped)...s), n.cores = 1, n.randomizations = 0, n.starts = 2, n.components = max(n.pc), verbose = FALSE, min.pathway.size = 0, max.pathway.size = Inf, n.internal.shuffles = 0)

5731:     if(length(ppca) > 1) { # if more than one pathway was supplied, combine genes using appropriate loadings and use consensus PCA (1st PC) as a patte...(2 bytes skipped)...

5733:         scaled.gene.loadings <- unlist(lapply(seq_along(pathways), function(i) {

5734:             gl <- ppca[[pathways[i]]]$xp$rotation[, n.pc[i], drop = TRUE]*as.numeric(ppca[[pathways[i]]]$xp$sd)[n.pc[i]]/sqrt(ppca[[pathways[i]]]$n)

5735:             names(gl) <- rownames(ppca[[pathways[i]]]$xp$rotation)

5777:     } else { # only one pathway was provided

5970: ##' @field results Output of the pathway clustering and redundancy reduction

5972: ##' @field pathways

5983:     fields = c('results', 'genes', 'pathways', 'mat', 'matw', 'goenv', 'renv', 'name', 'trim', 'batch'),

5986:         initialize = function(results, pathways, genes, mat, matw, goenv, batch = NULL, name = "pathway overdispersion", trim = 1.1/ncol(mat)) {

5995:             pathways <<- pathways

6012:                 gcl <- t.view.pathways(genes, mat = mat, matw = matw, env = goenv, vhc = results$hvc, plot = FALSE, trim = ltrim)

6058: ...(21 bytes skipped)...                <link rel = "stylesheet" type = "text/css" href = "http://pklab.med.harvard.edu/sde/pathcl.css" / >

6064: ...(10 bytes skipped)...                           <script type = "text/javascript" src = "http://pklab.med.harvard.edu/sde/pathcl.js" > </script >

6072:                    '/pathcl.json' = { # report pathway clustering heatmap data

6126:                    '/pathwaygenes.json' = { # report heatmap data for a selected set of genes

6133:                        x <- c.view.pathways(gsub("^#PC\\d+# ", "", pws), mat, matw, goenv = goenv, n.pc = n.pcs, n.genes = ngenes, two.side...(75 bytes skipped)...

6134:                        #x <- t.view.pathways(gsub("^#PC\\d+# ", "", pws), mat, matw, env = goenv, vhc = results$hvc, plot = FALSE, trim = lt...(14 bytes skipped)...

6174:                        ii <- which(results$ct == pathcl)

6251:                    '/pathways.json' = {

6252:                        lgt <- pathways

475:                 if (is.function(path)) path <- path()

418:                                         path=".", globalUI=FALSE) {

476:                 ENCODEsamples <- loadENCODEsamples(ENCODEmetadata, path=path)

1194:     inputFile  <- file.path(token, sprintf("input_%s.Rda",  rand))

1195:     outputFile <- file.path(token, sprintf("output_%s.rds", rand))

1380: .predictTargetingDrugsServer <- function(id, x, path=".", globalUI=FALSE,

1405:                 corMatrix, path=path)

1469: .drugSetEnrichmentAnalyserServer <- function(id, x, path=NULL) {

1492:                                            path=path)

1665:                                  file="ENCODEmetadata.rds", path=".") {

1670:         .diffExprENCODEloaderServer(id, metadata, cellLine, gene, path=path)

308:     path <- f

305: extractPath <- function(s, f, pens) {

307: # linear path from node s to node f

311:     while (path[1] != s) {

312:         if (i > maxl)        # no path available

314:             path <- "NA" 

317:         path <- c(pens[f], path)

321:     as.numeric(path)

373:          # obtain weights in g for path of nodes in char vec nl

394:                           path_detail=as.vector(ans[[i]]), 

182:     ans <- .Call("BGL_dijkstra_shortest_paths_D", 

365:                    nG[extractPath(nodeind(thiss), nodeind(thisf[j]), curdi)]

410:     ans <- .Call("BGL_johnson_all_pairs_shortest_paths_D", 

428:     ans <- .Call("BGL_floyd_warshall_all_pairs_shortest_paths_D", 

450:     ans <- .Call("BGL_bellman_ford_shortest_paths", 

478:     ans <- .Call("BGL_dag_shortest_paths", 

223:       path <- paste0(files_location,"/",all_files[[i]])

28:     filename <- file.path(output_folder,

31:     filename <- file.path(output_folder,

58:     all_files <- list.files(path = files_location, pattern = ".sam")

63:     output.files[[read.context]] <- file.path(output_folder,

66:     read.files <- file.path(files_location, all_files)

97:         asBam(file.path(files_location, all_files[i]), destination=file.path(temp_folder, sample_name[i]), overwrite=TRUE)

101:     bam.files <- file.path(path = temp_folder, paste(sample_name, ".bam", sep=""))

112:             filename <- file.path(output_folder, paste0(sample_name[[i]],"_uncov", ".Rdata"))

220:     all_files <- list.files(path = files_location, pattern = ".txt")

224:       temp_data <- fread(path,nrows=10)

227:         cmd <- paste("sed -i 's/\"//g'",path)

229:         cmd <- paste("sed -i 's/^/chr/'",path) 

268:     Tabix_files <- list.files(path = files_location, pattern = "_tabix.txt")

11:     output_folder <- normalizePath(output_folder)  

50:     files_location <- normalizePath(files_location)

51:     output_folder <- normalizePath(output_folder)

132:   files_location <- normalizePath(files_location)

186: BSprepare <-  function(files_location, output_folder, tabixPath, bc=1.5/100) {

191:     if(!is.character(tabixPath))

192:         stop('tabixPath has to be of class character ..')

193:     if(!file.exists(paste(tabixPath, '/tabix', sep='')))

194:         stop('tabix not found at tabixPath ..')

195:     if(!file.exists(paste(tabixPath, '/bgzip', sep='')))

196:         stop('bgzip not found at tabixPath ..')

198:     files_location <- normalizePath(files_location)

199:     output_folder <- normalizePath(output_folder)

200:     tabixPath <- normalizePath(tabixPath)

276:         str <- paste0(tabixPath, '/bgzip ', output_folder, "/", filetb_name,"_out.txt")

280:         str <- paste(tabixPath, '/tabix -s 1 -b 2 -e 2 -f ', fileoutgz, sep='')

1277:                             path <- goseq::goseq(pwf, "hg19", "knownGene",

1196:             PATHID2NAME <- AnnotationDbi::as.list(reactome.db::reactomePATHID2NAME)

1210:             pathways <- KEGGREST::keggList("pathway", "hsa") ## returns the list of human pathways

1279:                             path <- cbind(path,(as.character(sapply(

1280:                                 path$category, function(i){PATHID2NAME[[i]]}))))

1281:                             colnames(path)[6] <- "cat_name"

1282:                             subset(path, path$over_represented_pvalue < p_thresh)

1189:                 AnnotationDbi::as.list(reactome.db::reactomeEXTID2PATHID)

1201:             link_kegg<- KEGGREST::keggLink("pathway", "hsa") ## returns pathways for each kegg gene

1202:             list_link <- split(unname(link_kegg), names(link_kegg)) ## combines each pathway into list object for each gene

1211:             PATHID2NAME <- as.list(pathways)

634:     path <- pvalue_results@pwayCounts[[pathway]]

780:     path1 <- pvalue_results@pwayCounts1[[pathway]]

781:     path2 <- pvalue_results@pwayCounts2[[pathway]]

99: pathVarOneSample <- function(dat.mat, pways, test = c("chisq", "exact"), varStat = c("sd", 

131:     pathwayCounts <- lapply(lapply(olap.pways, function(x) table(x, deparse.level = 0)), function(x) if (len...(10 bytes skipped)...

206: pathVarTwoSamplesCont <- function(dat.mat, pways, groups, boot = 1000, varStat = c("sd", "mean", 

290: pathVarTwoSamplesDisc <- function(dat.mat, pways, groups, perc = c(1/3, 2/3), test = c("chisq", 

344:     pathwayCounts1 <- lapply(lapply(olap.pways1, function(x) table(x, deparse.level = 0)), 

354:     pathwayCounts2 <- lapply(lapply(olap.pways2, function(x) table(x, deparse.level = 0)), 

853:     pathDat1 <- as.data.frame(table(mixDat1))

855:     pathDat2 <- as.data.frame(table(mixDat2))

943:     pathname <- sapply(listPath, function(x) if (length(unlist(strsplit(x, "/"))) > 1) {

796:     plotPath1 <- ggplot(path1, aes(x = Cluster, y = Number_of_genes, fill = Cluster)) + geom_bar(stat = "identity", 

800:     plotPath2 <- ggplot(path2, aes(x = Cluster, y = Number_of_genes, fill = Cluster)) + geom_bar(stat = "identity", 

659:         plotPathway <- d + theme(panel.grid.major = element_blank(), panel.grid.minor = element_blank(), 

738:             plotPathway <- d + theme(panel.grid.major = element_blank(), panel.grid.minor = element_blank(), 

806:         plotPathway1 <- plotPath1 + theme(panel.grid.major = element_blank(), panel.grid.minor = element_blank(), 

809:         plotPathway2 <- plotPath2 + theme(panel.grid.major = element_blank(), panel.grid.minor = element_blank(), 

871:     plotPathDat1 <- ggplot(path...(136 bytes skipped)...("Number of genes") + theme(legend.position = "none") + ggtitle("Group 1") + xlab("") + ylim(0, max(pathDat1[,2], pathDat2[,2]))

872:     plotPathDat2 <- ggplot(path...(136 bytes skipped)...("Number of genes") + theme(legend.position = "none") + ggtitle("Group 2") + xlab("") + ylim(0, max(pathDat1[,2], pathDat2[,2]))

26: ...(25 bytes skipped)...ptions are TRUE or FALSE. If TRUE then the first column of the tab delimited file is expected to be path IDs. If FALSE, then the first column is expected to be pathway names.

645:     path <- as.data.frame(path)

646:     colnames(path) <- c("Cluster", "Number_of_genes")

653:     d <- ggplot(path, aes(x = Cluster, y = Number_of_genes, fill = Cluster)) + geom_bar(stat = "identity", 

663:             plotPathway <- plotPathway + annotate("text", x = sigCat, y = path[sigCat + 0.1, 

789:     path1 <- as.data.frame(path1)

790:     colnames(path1) <- c("Cluster", "Number_of_genes")

792:     path2 <- as.data.frame(path2)

793:     colnames(path2) <- c("Cluster", "Number_of_genes")

794:     yLimMax <- max(path1[, 2], path2[, 2])

813:             plotPathway1 <- plotPathway1 + annotate("text", x = sigCat, y = path1[sigCat + 

815:             plotPathway2 <- plotPathway2 + annotate("text", x = sigCat, y = path2[sigCat + 

20: #makeDBList put your pathways text file into a list

21: #pway$PATHNAME is the pathway names from the file

22: #pway$PATHID is a vector of pathway ID numbers is there are any. Otherwise it will be a vector filled with NA

23: #pway$GENES is a list of vectors, where each vector are the genes for a single pathway

25: #file is a tab delimited text file, where first and second columns are pathwayID and pathway name. The third (or last column is the genes associated with each pathway, seperated by commas.

33:         pways$PATHNAME <- as.vector(pwayTable[, 2])

34:         pways$PATHID <- as.vector(pwayTable[, 1])

35:         pways$GENES <- list(length(pways$PATHID))

37:         for (i in 1:length(pways$PATHID)) {

43:                 pways$PATHID <- pways$PATHID[-i]

44:                 pways$PATHNAME <- pways$PATHNAME[-i]

49:         pways$PATHNAME <- as.vector(pwayTable[, 1])

50:         pways$PATHID <- rep("NA", length(pways$PATHNAME))

51:         pways$GENES <- list(length(pways$PATHID))

53:         for (i in 1:length(pways$PATHID)) {

59:                 pways$PATHID <- pways$PATHID[-i]

60:                 pways$PATHNAME <- pways$PATHNAME[-i]

64:     names(pways$GENES) <- pways$PATHNAME

69: #pathVarOneSample

73: # 3. For each pathway, we extract the gene in our dataset and in which cluster they belong.

74: # 4. For each pathway, we look how the gene counts in each category and compare it to the reference counts with all th...(59 bytes skipped)...

78: # Output 1: tablePway columns are :pathway name, path...(46 bytes skipped)...or exact test,the percentage of genes from our dataset related to the total number of genes in each pathway, the number of genes from our dataset inside the pathway and the total number of genes inside the pathway

79: #Output 2: NAPways corresponds to the pathway names of the pathway having less than 10 genes for the Chi-Squared or also more than 500 genes for the exact tes.

80: # Output 3: genesInPway correspond to each pathway with the genes from the datasets belonging to it and in which cluster they were classsify.

83: # Output 6: pwayCounts is the genes counts of the each pathway in each cluster.

91: #Input 2: pways contains the pathways of interest (KEGG, REACTOME, etc...) in the same format that makeDBList

103:     # check if any GENES are in the pathway.

106:         stop("None of the genes in the data set are found in the given gene set or pathway")

125:     # olap.pways contains the genes are in each pathway with their cluster number

127:     names(olap.pways) <- pways$PATHNAME

130:     # list of tables of the number of genes in each cluster per pathway

140:     # Chi-Square or Exact test to compare the reference and the pathway distribution

142:         # chisq test and ajustment of the pvalue for each pathway

143:         pvals.pways <- sapply(pathwayCounts, function(x) if (sum(x) >= 10) {

154:         # Exact test and ajustment of the pvalue for each pathway

157:         # We perform the multinomial test on the pathway containing between 10 and 500 genes because a bigger number will involve too many possibilities ...(11 bytes skipped)...

158:         pvals.pways <- sapply(pathwayCounts, function(x) if (sum(x) >= 10 & sum(x) < 500) {

170:     xtab <- data.table(PwayName = pways$PATHNAME[not_na], PwayID = pways$PATHID[not_na], APval = apvals.pways, 

172:         NumOfGenesFromDataSetInPathway = lengths(olap.pways[not_na]), PathwaySize = pways$SIZE[not_na])

176: ...(50 bytes skipped)...ab, NAPways=pval.NA, genesInPway=olap.pways, refProb=pexp, refCounts=pexp * length(mix), pwayCounts=pathwayCounts, numOfClus=nmix, varStat=varStat, genesInClus=mix, var=vs)

181: #pathVarTwoSamplesCont

184: # 2. For each pathway, we extract the gene in our dataset.

185: # 3. For each pathway, we look how its genes are distributed and compare the 2 groups using the bootstrap Kolmogorov-S...(12 bytes skipped)...

189: # Output 1: tablePway columns are :pathway name, pathway IDs, adjusted p-value ffrom the boot KS test, the number of genes from our dataset inside the pathway and the total number of genes inside the pathway.

190: #Output 2: NAPways corresponds to the pathway names of the pathway having no genes inside the dataset.

191: # Output 3: genesInPway correspond to the genes from the dataset belonging to each pathway

200: #Input 2: pways contains the pathways of interest (KEGG, REACTOME, etc...) in the same format that makeDBList

209:     # check if any GENES are in the pathway

212:         stop("None of the genes in the data set are found in the given gene set or pathway")

236:     # olap.pways contains the genes from the dataset in each pathway

238:     names(olap.pways) <- pways$PATHNAME

239:     # We compare the two densities (one for each group) of the genes of each pathway with the Kolmogorov-Smirnow test.       

251:     xtab <- data.table(PwayName = pways$PATHNAME[not_na], PwayID = pways$PATHID[not_na], APval = apvals, 

253:         NumOfGenesFromDataSetInPathway = lengths(olap.pways[not_na]), PathwaySize = pways$SIZE[not_na])

261: #pathVarTwoSamplesDisc

265: # 3. For each pathway, we extract the gene in our dataset and in which cluster they belong.

266: # 4. For each pathway, we look at the gene counts in each category and compare the 2 samples to each other with all th...(60 bytes skipped)...

269: # Output 1: tablePway columns are :pathway name, path...(11 bytes skipped)...justed p-value, the percentage of genes in our dataset related to the total number of genes in each pathway, the number of genes from our dataset inside the pathway and the total number of genes inside the pathway.

270: #Output 2: NAPways corresponds to the pathway names of the pathway having no genes inside the dataset.

271: # Output 3: genesInPway1 corresponds to the genes from the dataset belonging to each pathway in the first sample

272: # Output 4: genesInPway2 corresponds to the genes from the dataset belonging to each pathway in the second sample

273: # Output 5: pwayCounts1 corresponds to a list of tables of the number of genes in each cluster per pathway for group 1

274: # Output 6: pwayCounts2 corresponds to a list of tables of the number of genes in each cluster per pathway for group 2

283: #Input 2: pways contains the pathways of interest (KEGG, REACTOME, etc...) in the same format that makeDBList

294:     # check if any GENES are in the pathway

297:         stop("None of the genes in the data set are found in the given gene set or pathway")

338:     # olap.pways contains the genes from the dataset in each pathway

340:     names(olap.pways1) <- pways$PATHNAME

342:     names(olap.pways2) <- pways$PATHNAME

343:     # list of tables of the number of genes in each cluster per pathway

353:     # list of tables of the number of genes in each cluster per pathway

364:         # chisq test and ajustment of the pvalue for each pathway

365:         pvals.pways <- sapply(pways$PATHNAME, function(x) if (sum(pathwayCounts1[x][[1]]) >= 

367:             exp.val <- pathwayCounts1[x][[1]]  #forgot the.val

368:             chi <- sum((pathwayCounts2[x][[1]] - exp.val)^2/exp.val)

374:         pval.NA <- pways$PATHNAME[-not_na]

377:         # Exact test and ajustment of the pvalue for each pathway

380:         # We perform the multinomial test on the pathway containing between 10 and 500 genes because a bigger number will involve too many possibilities ...(11 bytes skipped)...

381:         pvals.pways <- sapply(pways$PATHNAME, function(x) if (sum(pathwayCounts1[x][[1]]) >= 

382:             10 & sum(pathwayCounts1[x][[1]]) < 500) {

383:             pexp <- pathwayCounts1[x][[1]]/sum(pathwayCounts1[x][[1]])

384:             multinomial.test(as.vector(pathwayCounts2[x][[1]]), as.vector(pexp), useChisq = FALSE)$p.value

391:         pval.NA <- pways$PATHNAME[-not_na]

395:     xtab <- data.table(PwayName = pways$PATHNAME[not_na], PwayID = pways$PATHID[not_na], APval = apvals.pways, 

397:         NumOfGenesFromDataSetInPway = lengths(olap.pways1[not_na]), PathwaySize = pways$SIZE[not_na])

402: ...(36 bytes skipped)...", tablePway=xtab, NAPways=pval.NA, genesInPway1=olap.pways1, genesInPway2=olap.pways2, pwayCounts1=pathwayCounts1, pwayCounts2=pathwayCounts2, groups=groups, groupNames=groupNames, var1=var_1, var2=var_2, varStat=varStat)

409: #It is a function that returns the significant pathway(s),which category(ies) from this pathway are significant and which gene(s) belongs to this(ese) category(ies).

413: # Output 1: genesInSigPways1 contains the genes per significant pathway belonging to the significant category.

414: #Output 2: sigCatPerPway contains the category(ies) per pathway that are significant.

418: #Input 1: pvalue_results is result from the pathVarOneSample function

430:         warning("There are no significant pathways. Quitting significant_category function and returning empty object")

434:     # PathName that were significant in xtab.

436:     # The list of table with the number of genes in each cluster from the significant pathways

442:     # results contain the p-value for each category in each pathway computed with the binomial test.

450:     # For each significant pathway we look which category(ies) is are significant and the genes

477: #It is a function that returns the significant pathways and which genes belongs to these #pathways.

481: # Output 1: genesInSigPways1 contains the genes belonging to each significant pathway

485: #Input 1: pvalue_results is result from the pathVarTwoSamplesCont function

493:         warning("There are no significant pathways. Quitting significant_category function and returning empty object")

497:     # Pathways that were significant in xtab.

499:     # Genes from the dataset inside each significant pathway

507: #It is a function that returns the significant pathways and which genes belong to these pathways

511: # Output 1: genesInSigPways1 contains the genes belonging to each significant pathway in significant categories in the first sample

512: # Output 2: genesInSigPways2 contains the genes belonging to each significant pathway in significant categories in the second sample

513: # Output 3: sigCatPerPway contains the significant categories in each pathway

517: #Input 1: pvalue_results is result from the pathVarTwoSamplesDisc function

527:         warning("There are no significant pathways. Quitting significant_category function and returning empty object")

531:     # PathName that were significant in xtab.

533:     # The list of table with the number of genes in each cluster from the significant pathways

540:     # results contain the p-value for each category in each pathway computed with the binomial

550:     # For each significant pathway we look which category(ies) are significant and the genes belonging to this(ese) category(ies). ...(81 bytes skipped)...

576: ...(77 bytes skipped)...es cases and then use sigOneSample, sigTwoSamplesCont, or sigTwoSamplesDisc to find the significant pathways.

582: #Input 1: pvalue_results is result from the pathVarOneSample, pathVarTwoSamplesCont, or pathVarTwoSamplesDisc function.

602: #It is a function that returns the plot of the reference counts along with the plot of a chosen #pathway. This function is made for output from pathVarOneSample.

605: # plot of the reference and a pathway counts

608: #Input 1: pvalue_results is result from the pathVarOneSample function

609: #Input 2: pathway is the chosen pathway you want to plot.

613: #If sig is not NULL, the function will check if the pathway is a significant one and if yes the

619: plotOneSample <- function(pvalue_results, pathway, sig) {

620:     mp <- pathway

621:     # If the name of the pathway is two long it will cut it into two lines in the plot.

644:     # data frame for the pathway distribution

656:     # If the pathway is one of the significant ones, the title will be in red. and the categories, if any, we be high...(24 bytes skipped)...

657:     if (pathway %in% names(category)) {

658:         sigCat <- category[[pathway]]

670:     # plot the reference and pathway counts side by side

676: ...(34 bytes skipped)... plot of the two densities (one for each group) of the statistics (sd, mad, cv or mean) of a chosen pathway. This function is made for output from pathVarTwoSamplesCont.

682: #Input 1: pvalue_results is result from the pathVarTwoSamplesCont function

683: #Input 2: pathway is the chosen pathway you want to plot.

687: #If sig is not NULL, the function will check if the pathway is a significant one and if yes the title will be printed in red.

690: plotTwoSamplesCont <- function(pvalue_results, pathway, sig) {

691:     mp <- pathway

692:     # If the name of the pathway is two long it will cut it into two lines in the plot.

705:     # If the number of genes of the pathway is less than 3, it is not possible to draw a density and it will return an empty plot with this ...(8 bytes skipped)...

706:     if (xtab[PwayName == pathway, NumOfGenesFromDataSetInPathway] < 3) {

717:         genes <- pvalue_results@genesInPway[[pathway]]

726: ...(0 bytes skipped)...        # Plot of the two densities (one for each group) of the variability of the genes inside the pathway.

736:         # If we included the results of sigTwoSamplesCont, it will verify if the pathway is one of them and if yes the title will be printed in red.

737:         if (pathway %in% significant) {

752: ##It is a function that returns 2 plots of the 2 samples for a chosen pathway. This function is made for output from pathVarTwoSamplesDisc.

755: # plot of the 2 samples for a significant pathway

758: #Input 1: pvalue_results is result from the pathVarTwoSamplesDisc function

759: #Input 2: pathway is the chosen pathway you want to plot.

763: #If sig is not NULL, the function will check if the pathway is a significant one and if yes the title will be printed in red.

766: plotTwoSamplesDisc <- function(pvalue_results, pathway, sig) {

767:     mp <- pathway

768:     # If the name of the pathway is two long it will cut it into two lines in the plot.

791:     # data frame for the pathway distribution

803:     # If the pathway is one of the significant ones, the title will be in red. and the categories, if any, we be high...(24 bytes skipped)...

804:     if (pathway %in% names(category)) {

805:         sigCat <- category[[pathway]]

819:         plotPathway1 <- plotPath1 + theme(panel.grid.major = element_blank(), panel.grid.minor = element_blank(), 

821:         plotPathway2 <- plotPath2 + theme(panel.grid.major = element_blank(), panel.grid.minor = element_blank(), 

824:     # plot the reference and pathway counts side by side

854:     colnames(pathDat1) <- c("Cluster", "Number_of_genes")

856:     colnames(pathDat2) <- c("Cluster", "Number_of_genes")

862:     results <- apply(rbind(pathDat2[,2],pathDat1[,2]/pathDat1[,2]/sum(pathDat1[,2])), 2, function(y) multinomial.test(c(y[1], sum(pathDat2[,2]) - y[1]), prob = c(y[2],1 - y[2]))$p.value)

874:         plotPathDat1 <- plotPathDat1 + annotate("text", x = category, y = pathDat1[category +

876:         plotPathDat2 <- plotPathDat2 + annotate("text", x = category, y = pathDat2[category +

895: ...(46 bytes skipped)...rom the one sample or two samples cases and then use plotOneSample or plotTwoSamples for the chosen pathway.

898: # plot of the results of the one or two samples case for a chosen pathway.

901: #Input 1: pvalue_results is the result from the pathVarOneSample, pathVarTwoSamplesCont, or pathVarTwoSamplesDisc function

902: #Input 2: pathway is the chosen pathway you want to plot.

906: #If sig is not NULL, the function will check if the pathway is a significant one. And they will be highlighted in the resulting plot (see plotOneSample or p...(14 bytes skipped)...

909: plotPway <- function(pvalue_results, pathway, sig = NULL) {

912:         plotOneSample(pvalue_results, pathway, sig)

914:         plotTwoSamplesCont(pvalue_results, pathway, sig)

916:         plotTwoSamplesDisc(pvalue_results, pathway, sig)

923: #Save as a pdf the plots for the one or two samples case of the significant pathway or a chosen list of pathway..

926: # Save as a pdf the plots of the significant pathway or a chosen list of pathway.

929: #Input 1: pvalue_results is the result from the pathVarOneSample, pathVarTwoSamplesCont, or pathVarTwoSamplesDisc function

931: #Input 3: listPath is "significant" if you want to save the plots of the significant pathways or can be a list of names of pathway of interest.

934: #If sig is not NULL, the function will check if the pathway is a significant one. And they will be highlighted in the resulting plot (see plotOneSample or p...(14 bytes skipped)...

937: saveAsPDF <- function(pvalue_results, sig, listPath = "significant") {

938:     # If listPath='significant' we will save as pdf all the plots corresponding to the significant pathway from sig. Other wise it will save the pathways given to listPath.

939:     if (listPath[1] == "significant") {

940:         listPath <- names(sig@genesInSigPways1)

942:     # The name of the file will be the pathname where we replace '/' by '_'

948:     # save as PDF all the pathways significant or given in listPath

949:     for (i in 1:length(pathname)) {

950:         pdf(file = paste(pathname[i], ".pdf", sep = ""), width = 10, height = 7)

951:         plotPway(pvalue_results, listPath[i], sig)

959: #It is a function that returns one list of genes for group 1 and one for group 2 of a chosen pathway having their statistics (sd, mad, cv or mean) inside a chosen interval.

962: # Output 1: genes1 contains the genes belonging to the pathway in the given window for group 1.

963: # Output 2: genes2 contains the genes belonging to the pathway in the given window for group 2.

964: # Output 3: genesAll contains the genes from the dataset belonging to the pathway

967: #Input 1: pvalue_results is result from the pathVarTwoSamplesCont function

968: #Input 2: pathway is the chosen pathway.

973: getGenes <- function(pvalue_results, pathway, window) {

978:     genes <- olap.pways[[pathway]]

981:     # Take the genes from group 1 from the pathway belonging to the window

983:     # Take the genes from group 3 from the pathway belonging to the window

985:     # Take all the genes from the pathway

431:         sig <- new("significantPathway", genesInSigPways1=list(), sigCatPerPway=list(), thresPValue=numeric())

471:     sig <- new("significantPathway", genesInSigPways1=genes, sigCatPerPway=category, thresPValue=pvalue)

494:         sig <- new("significantPathway2", genesInSigPways1=list(), thresPValue=numeric())

501:     sig <- new("significantPathway2", genesInSigPways1=genes, thresPValue=pvalue)

528:         sig <- new("significantPathway3", genesInSigPways1=list(), genesInSigPways2=list(), sigCatPerPway=list(), thresPValue=numeric()...(1 bytes skipped)...

570:     sig <- new("significantPathway3", genesInSigPways1=genes1, genesInSigPways2=genes2, sigCatPerPway=category, thresPValue=pvalue)...(0 bytes skipped)...

667:         plotPathway <- d + theme(panel.grid.major = element_blank(), panel.grid.minor = element_blank(), 

671:     grid.arrange(arrangeGrob(plotRef, plotPathway, nrow = 1))

742:             plotPathway <- d + theme(panel.grid.major = element_blank(), panel.grid.minor = element_blank(), 

746:     plot(plotPathway)

825:     grid.arrange(arrangeGrob(plotPathway1, plotPathway2, nrow = 1))

879:         plotPathDat1 <- plotPathDat1 + theme(panel.grid.major = element_blank(), panel.grid.minor = element_blank(),panel.background...(63 bytes skipped)...

880:         plotPathDat2 <- plotPathDat2 + theme(panel.grid.major = element_blank(), panel.grid.minor = element_blank(),panel.background...(63 bytes skipped)...

884:         grid.arrange(arrangeGrob(plotPathDat1, plotPathDat2, nrow = 1))

887:         grid.arrange(arrangeGrob(plotPathDat1, plotPathDat2, nrow = 1))

726:     path <- c(anc_from[1:i], rev(anc_to[1:(j-1)]))

732:     path <- get.path(phylo, from, to)

700:     path_length <- sapply(1:(root-1), function(x) get.path_length(tr, root, x))

716: get.path <- function(phylo, from, to) {

980:     pathLength <- sapply(1:length(tr$tip.label), function(i) {

731: get.path_length <- function(phylo, from, to, weight=NULL) {

701:     i <- which.max(path_length)

702:     return(get.path(tr, root, i))

705: ##' path from start node to end node

708: ##' @title get.path

727:     return(path)

734:         return(length(path)-1)

749:     for(i in 1:(length(path)-1)) {

750:         ee <- get_edge_index(df, path[i], path[i+1])

981:         get.path_length(tr, i, root, yscale)

984:     ordered_tip <- order(pathLength, decreasing = TRUE)

134: 		  readCounts <- QDNAseq::binReadCounts(bins, path = inputdir)

960:         if (dirname(filename)==".") {newpath <- file.path(outputdir,filename)}

131: 		  currentdir <- file.path(outputdir,paste0(b,"kbp"))

136: 		    saveRDS(readCounts, file = file.path(outputdir, paste0(b, "kbp-raw.rds")))

146: 		  saveRDS(copyNumbersSegmented, file = file.path(outputdir,paste0(b,"kbp.rds")))

157: 			currentdir <- file.path(outputdir,paste0(substr(files[f],0,nchar(files[f])-4)))

159: 			copyNumbersSegmented <- readRDS(file.path(inputdir,files[f]))

166: 	write.table(parameters, file=file.path(outputdir,"parameters.tsv"), quote = FALSE, sep = "\t", na = "", row.names = FALSE)

182: 	  qdir <- file.path(currentdir,paste0(q,"N"))

189:   	dir.create(file.path(qdir,"likelyfits"))  

258:   		fp <- file.path(qdir,pd$name[a])

263:   		dir.create(file.path(fp,"graphs"))

284:   		imagefunction(file.path(fp,paste0(pd$name[a],"_errorlist.",imagetype)))

320:   		  fn <- file.path(fp,"graphs",paste0(pd$name[a], " - ",q,"N fit ", m, ".",imagetype))

348:   		      imagefunction(file.path(qdir,"likelyfits",paste0(pd$name[a],"_bestfit_",q,"N.",imagetype)),width=10.5)

350:   		      imagefunction(file.path(qdir,"likelyfits",paste0(pd$name[a],"_bestfit_",q,"N.",imagetype)),width=720)

358:   		      imagefunction(file.path(qdir,"likelyfits",paste0(pd$name[a],"_lastminimum_",q,"N.",imagetype)),width=10.5)

360:   		      imagefunction(file.path(qdir,"likelyfits",paste0(pd$name[a],"_lastminimum_",q,"N.",imagetype)),width=720)

377:   		  pdf(file.path(fp,paste0("summary_",pd$name[a],".pdf")),width=10.5)

382:   		    imagefunction(file.path(fp,paste0("summary_",pd$name[a],".",imagetype)), width = 720)

386:     		  imagefunction(file.path(fp,paste0("summary_",pd$name[a],".",imagetype)), width = 2160, height = 480*ceiling(length(plots)/3...(3 bytes skipped)...

399:     	  pdf(file.path(qdir,"summary_likelyfits.pdf"),width=10.5)

402:       	pdf(file.path(qdir,"summary_errors.pdf"))

406:     	  imagefunction(file.path(qdir,paste0("summary_likelyfits.",imagetype)), width = 2160, height = 480*length(pd$name))

409:       	imagefunction(file.path(qdir,paste0("summary_errors.",imagetype)), width = 1920, height = 480*ceiling(length(pd$name)/4))

415:   	    pdf(file.path(qdir,"summary_errors.pdf"))

419:   	    imagefunction(file.path(qdir,paste0("summary_errors.",imagetype)), width = 1920, height = 480*ceiling(length(pd$name)/4))

425:   	write.table(fitpicker, file=file.path(qdir,paste0("fitpicker_",q,"N.tsv")), quote = FALSE, sep = "\t", na = "", row.names = FALSE)

830: # frequency in percentage). It can also be a file path to a tab-delimited

832: # by getadjustedsegments. Again, this can be either a data frame or a file path

1003:       copyNumbersSegmented <- readRDS(file.path(inputdir,files[1]))

1005:     if(missing(modelsfile)){models <- try(read.table(file.path(inputdir,"models.tsv"), header = TRUE, comment.char = "", sep = "\t"))

1009:       if (dir.exists(file.path(inputdir,"variantdata"))) {

1010:         variantdata <- file.path(inputdir,"variantdata")

1072:           if (!dir.exists(file.path(outputdir,"newplots"))) {dir.create(file.path(outputdir,"newplots"))}

1074:             imagefunction(file.path(outputdir,"newplots",paste0(pd$name[a],".",imagetype)),width=10.5)

1078:             imagefunction(file.path(outputdir,"newplots",paste0(pd$name[a],".",imagetype)), width=720)

1091:           variantfile <- file.path(variantdata,paste0(prefix,pd$name[a],postfix,varext))

1092:           folder <- file.path(outputdir,"variantdata")

1104:           if (!dir.exists(file.path(outputdir,"segmentfiles"))) {dir.create(file.path(outputdir,"segmentfiles"))}

1105:           fn <- file.path(outputdir,"segmentfiles",paste0(pd$name[a],"_segments.",segext))

961:         else {newpath <- sub(dirname(filename),outputdir,filename)}

962:         fn <- gsub(".csv","_ACE.csv",newpath)

1724:             device = "png", path = saveFolder, dpi = 100, width = 21,

1853:     path_cpdMeta <- paste(saveFolder, "/", annotationName,

1871:     path_specMeta <- paste(saveFolder, "/", annotationName,

1883:         path_var <- paste(saveFolder, "/", annotationName, "_", i, ".csv",

1918:     path_summary <- paste(saveFolder, "/", annotationName, "_summary.csv",

1116:     .filepath <- x@filepath[i]

1863:     tmp_filepath <- filepath(object)

2045:     .spectraPaths <- resSpectra$spectraPaths

2182: resetAnnot_spectraPathMetadata <- function(previousAnnotation, spectraPaths,

2186:         .spectraPaths <- filepath(previousAnnotation)

1076:     return(tools::file_path_sans_ext(basename(object@filepath)))

1386: #' @param saveFolder (str) Path of folder where annotationParameters_summary.csv

1399: #' spectraPaths <- c('./path/file1', './path/file2', './path/file3')

1610: #' @param saveFolder (str) Path of folder where annotationParameters_summary.csv

1703:     # @param saveFolder (str) Path where plots will be saved

1727:         # output path

1758: #' @param saveFolder (str) Path of folder where the annotation result csv will

1855:     utils::write.csv(tmp_outCpdMeta, file = path_cpdMeta, row.names = FALSE,

1858:     if (verbose) { message("Compound metadata saved at ", path_cpdMeta) }

1873:     utils::write.csv(tmp_outSpecMeta, file = path_specMeta, row.names = FALSE,

1876:     if (verbose) { message("Spectra metadata saved at ", path_specMeta) }

1885:         utils::write.csv(tmp_var, file = path_var, row.names = TRUE,

1889:             message("Peak measurement \"", i, "\" saved at ", path_var)

1920:     utils::write.csv(tmp_summary, file = path_summary, row.names = TRUE,

1923:     if (verbose) { message("Summary saved at ", path_summary) }

24:             length(object@filepath), " samples. \n", sep = "")

53: # @filepath length. Slot type is not checked as \code{setClass} enforces it.

78: #' # Paths to spectra files

119: #' # Paths to spectra files

160: #' # Paths to spectra files

206: #' # Paths to spectra files

253: #' # Paths to spectra files

286: # filepath

287: setGeneric("filepath", function(object, ...) standardGeneric("filepath"))

288: #' filepath accessor

290: #' @return (str) A character vector of file paths, of length number of spectra

293: #' @aliases filepath

300: #' # Paths to spectra files

319: #' filepath(annotation)

324: setMethod("filepath", "peakPantheRAnnotation", function(object) {

325:     object@filepath

343: #' # Paths to spectra files

386: #' # Paths to spectra files

430: #' # Paths to spectra files

472: #' # Paths to spectra files

512: #' # Paths to spectra files

552: #' # Paths to spectra files

593: #' # Paths to spectra files

636: #' # Paths to spectra files

695: #' # Paths to spectra files

742: #' # Paths to spectra files

788: #' # Paths to spectra files

817: #' nbSamples accessor established on filepath

828: #' # Paths to spectra files

852:     return(length(object@filepath))

868: #' # Paths to spectra files

913: #' # Paths to spectra files

946:     nbSample <- length(object@filepath)

953:         rownames(tmpAnnotation) <- object@filepath

961:         rownames(tmpAnnotation) <- object@filepath

977:     rownames(tmpAnnotation) <- object@filepath

1000: #' # Paths to spectra files