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)

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

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

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

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

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

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

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

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

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

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

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

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

628: pathwayEnrichment <- function(genes,

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

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

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

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

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

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

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

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

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

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

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

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

353:   return(path)

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

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

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

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

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

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

1: #' KEGG pathway enrichment

22: #' @return KEGG pathway enrichment results

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

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

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

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

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

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

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

106:     for (i in seq_along(pathT))

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

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

114:                      paste(pathT[i])))

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

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

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

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

129:         ID = pathT,

141: #' Reactome pathway enrichment

163: #' @return Reactome pathway enrichment results

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

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

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

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

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

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

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

244:     for (i in seq_along(pathT))

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

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

252:                      paste(pathT[i])))

258:         ID = pathT,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

349:                   by = "pathway",

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

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

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

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

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

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

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

423:   pathTable <-

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

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

430:   return(pathTable)

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

478:         pathID = tmp[, 3],

479:         pathTerm = tmp[, 1]

506: #' @return Wiki Pathway Enrichment

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

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

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

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

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

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

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

579:   for (i in seq_along(pathT))

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

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

586:                           paste(pathT[i])))

593:       ID = pathT,

594:       Term = pathTerms,

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

626: #' @return Pathway Enrichment

670:     pathTable <-

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

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

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

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

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

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

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

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

720:   for (i in seq_along(pathT))

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

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

726:                           paste(pathT[i])))

731:       ID = pathT,

732:       Term = pathTerms,

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

745: #' @param gmtName Custom pathway gmt file

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

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

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

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

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

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

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

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

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

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

459:       rWikiPathways::downloadPathwayArchive(

463:       rWikiPathways::downloadPathwayArchive(

467:       rWikiPathways::downloadPathwayArchive(

485: #' WikiPathways Enrichment

1734: 	path <- conMA(x, exclude="H")

1979:             path <- .linearCon(x=con)

1800: 	conpath <- t(sapply(path, function(x) x[c(1, length(x))]))

1812: 	pathlist <- cyclist$path

1813: 	conpath <- cyclist$conpath

1814: 	pathlistnew <- list() 

1735: 	noconnect <- rowSums(path) != 0 # Removes atoms with no connections

1736: 	path <- path[noconnect, noconnect]

1737: 	if(all(dim(path) == 0)) { return(path) } 

1738: 	term <- which(rowSums(path > 0)==1)

1740: 		path <- path[-term,-term]

1741: 		if(any(dim(path) == 0) | is.vector(path)) { break() }

1742: 		term <- which(rowSums(path > 0)==1)

1744: 	return(path)

1779: .update <- function(con, path) {

1780: 	## Remove non-terminal atoms in each path

1781: 	center_atoms <- unique(unlist(lapply(path, function(x) x[-c(1, length(x))])))

1791: 		path <- c(path, remainbonds)

1792: 		names(path) <- seq(along=path)

1794: 	## Collect complete rings and remove them from path object

1795: 	index <- unlist(lapply(path, function(y) any(duplicated(y))))

1796: 	rings <- path[index]

1797: 	path <- path[!index]

1798: 	names(path) <- seq(along=path)

1799: 	## Connection list for path component

1806: 	return(list(con=con, conpath=conpath, path=path, rings=rings))

1850: 		## Collect complete rings and remove them from path object

1980:             cyclist <- .update(con=con, path=path)

13: .sdfDownload <- function(mypath="ftp://ftp.ncbi.nih.gov/pubchem/Compound/CURRENT-Full/SDF/", myfile="Compound_00650001_00675000.sdf...(7 bytes skipped)...

14: 	system(paste("wget ", mypath, myfile, sep=""))

17: # .sdfDownload(mypath="ftp://ftp.ncbi.nih.gov/pubchem/Compound/CURRENT-Full/SDF/", myfile="Compound_00650001_00675000.sdf...(6 bytes skipped)...

1747: ## (b) Function to return the longest possible linear bond paths where:

1801: 	ends <- unique(as.vector(conpath))

1802: 	conpath <- lapply(ends, function(x) as.numeric(names(which(rowSums(conpath==x) > 0))))

1803: 	names(conpath) <- ends

1804: 	conpath <- conpath[sapply(conpath, length) > 1] # removes ends that occur only once 

1816: 	## Loop to join linear paths/fragments stored in pathlist

1817: 	for(i in names(conpath)) {

1818: 		if(length(conpath) == 0 | !any(names(conpath) == i)) { next() }

1819: 		pos <- t(combn(conpath[[i]], m=2))

1821: 			p1 <- pathlist[[pos[j,1]]]

1822: 			p2 <- pathlist[[pos[j,2]]]

1827: 				pathlistnew[[length(pathlistnew)+1]] <- c(rev(p2[-1]), p1)

1830: 				pathlistnew[[length(pathlistnew)+1]] <- c(p1, rev(p2[-length(p2)]))

1833: 				pathlistnew[[length(pathlistnew)+1]] <- c(p2, p1[-1])

1836: 				pathlistnew[[length(pathlistnew)+1]] <- c(p1, p2[-1])

1840: 		if(length(pathlistnew) == 0) { next() }

1842: 		dups <- duplicated(sapply(pathlistnew, function(x) paste(sort(unique(x)), collapse="_")))

1843: 		pathlistnew <- pathlistnew[!dups]

1846: 			l <- sapply(pathlistnew, length)

1847: 			pathlistnew <- pathlistnew[l <= upper]

1848: 			if(length(pathlistnew) == 0) { next() }

1851: 		index <- unlist(lapply(pathlistnew, function(y) any(duplicated(y[c(1, length(y))]))))

1852: 		rings[[length(rings)+1]] <- pathlistnew[index]

1853: 		pathlistnew <- pathlistnew[!index]

1854: 		## Remove paths with internal duplicates 

1855: 		if(length(pathlistnew) > 0) {

1856: 			index <- unlist(lapply(pathlistnew, function(y) any(duplicated(y))))

1857: 			pathlistnew <- pathlistnew[!index]

1859: 		## Update pathlist and conpath

1860: 		pathlist <- c(pathlist[-conpath[[i]]], pathlistnew)

1861: 		dups <- duplicated(sapply(pathlist, function(x) paste(sort(unique(x)), collapse="_")))

1862: 		pathlist <- pathlist[!dups]

1863: 		names(pathlist) <- seq(along=pathlist)

1864: 		conpath <- t(sapply(pathlist, function(x) x[c(1, length(x))]))

1865: 		ends <- unique(as.vector(conpath))

1866: 		conpath <- lapply(ends, function(x) as.numeric(names(which(rowSums(conpath==x) > 0))))

1867: 		names(conpath) <- ends

1868: 		conpath <- conpath[sapply(conpath, length) > 1] # removes ends that occur only once

1869: 		pathlistnew <- list()

199:   path <- viterbiPath(nm.fit$par,fx.par,data,nstates,stFn,trFn,emFn)

105:   V.path <- matrix(0,nrow=nstates,ncol=T)

90: viterbiPath <- function(par,fx.par,data,nstates,stFn,trFn,emFn) {

106: ...(78 bytes skipped)...start.probs=as.double(start.probs),A=as.double(A),emit.probs=as.double(emit.probs),V=as.double(V),V.path=as.integer(V.path),path=as.integer(numeric(T)),trans.prob=as.double(numeric(nstates^2)),trans.prob.max=as.double(numeric(ns...(57 bytes skipped)...

107:   return(viterbi.call$path + 1)

201:   log.odds <- log(emit.probs[cbind(path,seq(path))]+1e-6) - log(emit.probs[normal.state,]+1e-6)

203:   fit <- new("ExomeCopy",sample.name=sample.name,type=type,path=Rle(path),ranges=granges(gr),O.norm=as.numeric(O/mu.hat),log.odds=log.odds,fx.par=fx.par,init.par=init.par,f...(89 bytes skipped)...

424:               path <- paste0("annotation/info/", var)

449:                   path <- paste0("annotation/format/AD/", "norm")

525:               path <- ifelse(.existGdsNode(object, node),

1308:                   path <- .getNodeIndex(object, node)

1420:               path <- paste0("annotation/format/AD/", node)

1521:               path <- .getNodeIndex(object, "annotation/format/AD/norm")

18: ## Get the index of the specified path in the GDS file.

20: .getNodeIndex <- function(object, path){

21:     return(index.gdsn(.getGdsfmtObj(object), path))

83: .existGdsNode <- function(object, path){

84:     return(exist.gdsn(.getGdsfmtObj(object), path))

426:               if(!.existGdsNode(object, path)){

427:                   warning("No data at ", path)

430:               info_node <- .getNodeIndex(object, path)

451:                   path <- paste0("annotation/format/AD/", "filt.data")

453:                   path <- paste0("annotation/format/AD/", "data")

455:               if(!.existGdsNode(object, path)){

458:               ad_node <- .getNodeIndex(object, path)

529:               genotype_node <- .getNodeIndex(object, path)

1327:                                                path,

1336:                                               path,

1346: .countGenotypeScan <- function(object, path, sel, has_flipped, valid_flipped){

1347:     df <- apply.gdsn(path, 1, selection=sel, as.is="list",

1380: .countGenotypeSnp <- function(object, path, sel, has_flipped, valid_flipped){

1381:     df <- apply.gdsn(path, 2, selection=sel, as.is="list",

1421:               if(.existGdsNode(object, path)){

1422:                   path <- .getNodeIndex(object, path)

1437:                                            path,

1446:                                           path,

1454: .countReadScan <- function(object, path, sel, has_flipped, valid_flipped){

1455:     df <- apply.gdsn(path, 1, selection=sel, as.is="list",

1478: .countReadSnp <- function(object, path, sel, has_flipped, valid_flipped){

1479:     df <- apply.gdsn(path, 2, sum, sel, "list")

1526:                                                path,

1536:                                               path,

1570:                                path,

1575:     df <- apply.gdsn(path, 1, selection=sel, as.is="list",

1615:                               path,

1620:     df <- apply.gdsn(path, 2, selection=sel, as.is="list",

2509:                   stop("Failed to create a new file to the following path \n",

235:   path <- reactiveValues(

240:   path2 <- reactiveValues(

244:   path3 <- reactiveValues(

24:   uploadReferenceDNA <- eventReactive(path$pth,{

26:     testFASTA <- strsplit(path$pth,"\\.")[[1]]

28:       referenceDnaStringSet2 <- readDNAStringSet(path$pth, format="fasta",use.names=TRUE)

34:       load(path$pth)

42:   uploadTranscriptTable <- eventReactive(path3$pth3,{

45:     testCSV <- strsplit(path3$pth3,"\\.")[[1]]

47:       transCoord <- read.csv(path3$pth3, sep=";")

48:     }else{ transCoord <- readRDS(path3$pth3)}

78:     gene2transcript <- read.csv(path2$pth2, sep=";", stringsAsFactors=FALSE)

99:     gene2transcript <- read.csv(path2$pth2, sep=";", stringsAsFactors=FALSE)

126:     gene2transcript <- read.csv(path2$pth2, sep=";", stringsAsFactors=FALSE)

145:     gene2transcript <- read.csv(path2$pth2, sep=";", stringsAsFactors=FALSE)

176:     gene2transcript <- read.csv(path2$pth2, sep=";", stringsAsFactors=FALSE)

205:     gene2transcript <- read.csv(path2$pth2, sep=";", stringsAsFactors=FALSE)

251:     path$pth <- file.choose()

255:     path2$pth2 <- file.choose()

259:     path3$pth3 <- file.choose()

234:   ## Define reactive paths

207:     Path = inner_results[[2]]

1162:   Path = path_matrix

2176:     Path <- pathmod[[2]]

48:   my.path <- rbind(Gene1,Gene2)

209:     Path_effects = get_effects(Path)

363: check_path <- function(path_matrix)

1173:     path_lm = summary(lm(Y_lvs[,k1] ~ Y_lvs[,k2]))

1202:   path_effects = as.list(seq_len(lvs-1))

2177:     path.orig <- as.vector(Path[path_matrix==1])

2179:     Path.efs <- get_effects(Path)

2186:     path.labs <- NULL

2175:     pathmod <- get_paths(path_matrix, Y.lvs)

2194:     PATHS <- matrix(NA, bootnum, sum(path_matrix))

1805: get_path_scheme <- function(path_matrix, LV)

1156: get_paths <-  function(path_matrix, Y_lvs, full=TRUE)

1207:     indirect_paths = matrix(c(0,0,0,0), 2, 2)

1208:     total_paths = Path

55:   try(mod1 <- plspm(XCases,my.path,my.blocks, modes = my.modes), silent=TRUE)

59:   	res <- list(statistic=NA,p.value=NA,method="Partial Least Squares Path Modeling",parameter=list.param)

64:   try(mod0 <- plspm(XControls,my.path,my.blocks, modes = my.modes),silent=TRUE)

68:   	res <- list(statistic=NA,p.value=NA,method="Partial Least Squares Path Modeling",parameter=list.param)

91: 		try(mod1 <- plspm(XCases,my.path,my.blocks, modes = my.modes), silent=TRUE)

93: 		try(mod0 <- plspm(XControls,my.path,my.blocks, modes = my.modes),silent=TRUE)

110: #	res <- list(statistic=stat,p.value=pval,method="Partial Least Squares Path Modeling",parameter=list.param)

123: 		method="Gene-based interaction based on Partial Least Squares Path Modeling",

138:   function(Data, path_matrix, blocks, modes = NULL, scaling = NULL,  

146:     valid = check_args(Data=Data, path_matrix=path_matrix, blocks=blocks, 

153:     path_matrix = valid$path_matrix

167:     gens = get_generals(MV, path_matrix)

188:       weights = get_weights(X, path_matrix, blocks, specs)

194:       weights = get_weights_nonmetric(X, path_matrix, blocks, specs)

203:     # Path coefficients and total effects

205:     inner_results = get_paths(path_matrix, LV)

241:     inner_summary = get_inner_summary(path_matrix, blocks, specs$modes,

245:     gof = get_gof(communality, R2, blocks, path_matrix)

259:         bootstrap = get_boots(MV, path_matrix, blocks, specs, br)

264:     model = list(IDM=path_matrix, blocks=blocks, specs=specs,

270:                path_coefs = Path, 

274:                effects = Path_effects,

289:   cat("Partial Least Squares Path Modeling (PLS-PM)", "\n")

294:   cat("\n3  $path_coefs     ", "path coefficients matrix")

314:   function(Data, path_matrix, blocks, scaling, modes, scheme,

319:     path_matrix = check_path(path_matrix)

327:     good_model = check_model(path_matrix, blocks)

331:          path_matrix = path_matrix,

365:   if (is_not_matrix(path_matrix))

366:     stop("\n'path_matrix' must be a matrix.")

368:   if (!is_square_matrix(path_matrix))

369:     stop("\n'path_matrix' must be a square matrix.")

371:   if (nrow(path_matrix) == 1)

372:     stop("\n'path_matrix' must have more than one row")

374:   if (!is_lower_triangular(path_matrix))

375:     stop("\n'path_matrix' must be a lower triangular matrix")

378:   for (j in seq_len(ncol(path_matrix))) 

380:     for (i in seq_len(nrow(path_matrix)))

382:       if (length(intersect(path_matrix[i,j], c(1,0))) == 0)

383:         stop("\nElements in 'path_matrix' must be '1' or '0'")

387:   if (lacks_dimnames(path_matrix)) {

388:     LV_names = paste("LV", seq_len(ncol(path_matrix)), sep = "")

389:     dimnames(path_matrix) = list(LV_names, LV_names)

391:   if (has_rownames(path_matrix) && lacks_colnames(path_matrix)) {

392:     colnames(path_matrix) = rownames(path_matrix)

394:   if (has_colnames(path_matrix) && lacks_rownames(path_matrix)) {

395:     rownames(path_matrix) = colnames(path_matrix)

399:   path_matrix

458: check_model <- function(path_matrix, blocks)

460:   # compatibility between path_matrix and blocks

461:   if (length(blocks) != nrow(path_matrix))

462:     stop("\nNumber of rows in 'path_matrix' different from length of 'blocks'.")

687:   SCHEMES = c("centroid", "factorial", "path")

884: get_generals <- function(MV, path_matrix)

890:        lvs = nrow(path_matrix),

891:        lvs_names = rownames(path_matrix))

1035: get_weights <- function(X, path_matrix, blocks, specs)

1037:   lvs = nrow(path_matrix)

1055:                 "centroid" = sign(cor(Y) * (path_matrix + t(path_matrix))),

1056:                 "factorial" = cor(Y) * (path_matrix + t(path_matrix)),

1057:                 "path" = get_path_scheme(path_matrix, Y))

1083:     dimnames(W) = list(colnames(X), rownames(path_matrix))    

1158:   lvs_names = colnames(path_matrix)

1159:   endogenous = as.logical(rowSums(path_matrix))

1164:   R2 = rep(0, nrow(path_matrix))

1171:     k2 = which(path_matrix[k1,] == 1)

1174:     Path[k1,k2] = path_lm$coef[-1,1]

1175:     residuals[[aux]] = path_lm$residuals  

1176:     R2[k1] = path_lm$r.squared

1177:     inn_val = c(path_lm$r.squared, path_lm$coef[,1])

1180:     rownames(path_lm$coefficients) = inn_labels

1181:     results[[aux]] <- path_lm$coefficients

1184:     # paste(rep("path_",length(k2)),names(k2),sep=""))

1192:   list(results, Path, R2, residuals)

1195: get_effects <- function(Path)

1198:   lvs = nrow(Path)

1199:   lvs_names = rownames(Path)

1203:   path_effects[[1]] = Path

1212:       path_effects[[k]] = path_effects[[k-1]] %*% Path        

1215:     for (k in 2:length(path_effects)) {

1216:       indirect_paths = indirect_paths + path_effects[[k]]        

1218:     total_paths = Path + indirect_paths

1227:         direct = c(direct, Path[i,j])

1325:   function(path_matrix, blocks, modes, communality, redundancy, R2)

1328:     exo_endo = rep("Exogenous", nrow(path_matrix))

1329:     exo_endo[rowSums(path_matrix) != 0] = "Endogenous"

1330:     avg_comu = rep(0, nrow(path_matrix))

1331:     avg_redu = rep(0, nrow(path_matrix))

1332:     AVE = rep(0, nrow(path_matrix))

1334:     for (k in seq_len(nrow(path_matrix)))

1352:                row.names = rownames(path_matrix))

1355: get_gof <- function(comu, R2, blocks, path_matrix)

1357:   lvs = nrow(path_matrix)

1359:   endo = rowSums(path_matrix)

1392: get_weights <- function(X, path_matrix, blocks, specs)

1394:   lvs = nrow(path_matrix)

1412:                 "centroid" = sign(cor(Y) * (path_matrix + t(path_matrix))),

1413:                 "factorial" = cor(Y) * (path_matrix + t(path_matrix)),

1414:                 "path" = get_path_scheme(path_matrix, Y))

1440:     dimnames(W) = list(colnames(X), rownames(path_matrix))    

1478:   function(X, path_matrix, blocks, specs)

1480:     lvs = nrow(path_matrix)

1541:     link = t(path_matrix) + path_matrix

1556:                   "path" = get_path_scheme(path_matrix, Y))

1751:       dimnames(W) = list(colnames(X), rownames(path_matrix))

1752:       dimnames(Y) = list(rownames(X), rownames(path_matrix))

1808:   E = path_matrix

1810:   for (k in seq_len(ncol(path_matrix))) 

1813:     follow <- path_matrix[k,] == 1

1817:     predec <- path_matrix[,k] == 1

2141:   function(DM, path_matrix, blocks, specs, br)

2146:     lvs = nrow(path_matrix)

2147:     lvs.names = rownames(path_matrix)

2151:     endo = sign(rowSums(path_matrix))

2162:       out.ws = get_weights(X, path_matrix, blocks, specs)

2168:       out.ws = get_weights_nonmetric(X, path_matrix, blocks, specs)

2190:         if (path_matrix[i,j]==1) 

2191:           path.labs <- c(path.labs, paste(lvs.names[j],"->",lvs.names[i]))

2195:     TOEFS <- matrix(NA, bootnum, nrow(Path.efs))

2207:         w.boot = get_weights(X.boot, path_matrix, blocks, specs)

2215:         w.boot = get_weights_nonmetric(X.boot, path_matrix, blocks, specs)

2225:       pathmod <- get_paths(path_matrix, Y.boot)

2228:       PATHS[i,] <- as.vector(P.boot[path_matrix==1])

2249:     # Path coefficients

2250:     colnames(PATHS) = path.labs

2251:     PB = get_boot_stats(PATHS, path.orig)

2256:     colnames(TOEFS) = Path.efs[, 1]

2257:     TE = get_boot_stats(TOEFS, Path.efs[,4]) 

1214:     indirect_paths = matrix(0, lvs, lvs)

1228:         indirect = c(indirect, indirect_paths[i,j])

1229:         total = c(total, total_paths[i,j])

2178:     r2.orig <- pathmod[[3]][endo==1]

2226:       P.boot <- pathmod[[2]]

2230:       RSQRS[i,] <- pathmod[[3]][endo==1]

2262:          paths = PB, 

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='')

296:   for (path in filepaths) {

42:       cbu.path <- "/export/valenfs/data/processed_data/experiment_tables_for_R/"

240:     cbu.path <- "/export/valenfs/data/processed_data/experiment_tables_for_R/"

925:     cbu.path <- "/export/valenfs/data/processed_data/experiment_tables_for_R/"

287: findFromPath <- function(filepaths, candidates, slot = "auto") {

511: filepath <- function(df, type, basename = FALSE) {

515:   paths <- lapply(df$filepath, function(x, df, type) {

652:       paths <- filepath(df, type)

368:     reversePaths <- df$reverse[!(df$reverse %in% c("", "paired-end"))]

7: #' @param file relative path to a ORFik experiment. That is a .csv file following

10: #' also be full path to file, then in.dir argument is ignored.

13: #' it to disc. Does not apply if file is not a path, but a data.frame. Also

14: #' does not apply if file was given as full path.

30: #' # save.experiment(df, file = "path/to/save/experiment")

32: #' # read.experiment("path/to/save/experiment")

34: #' # read.experiment("experiment", in.dir = "path/to/save/")

43:       if (file.exists(pasteDir(cbu.path, basename(file))))

44:         file <- pasteDir(cbu.path, basename(file))

109: #' @param txdb A path to TxDb (prefered) or gff/gtf (not adviced, slower)

111: #' @param fa A path to fasta genome/sequences used for libraries, remember the

178: #' # Save with: save.experiment(df, file = "path/to/save/experiment.csv")

241:     if (dir.exists(cbu.path)) { # This will only trigger on CBU server @ UIB

243:       message(cbu.path)

244:       saveDir <- cbu.path

263: #' #save.experiment(df, file = "path/to/save/experiment.csv")

265: #' #save.experiment(df, file = "path/to/save/experiment")

280: #' @param filepaths path to all files

297:     hit <- names(unlist(sapply(candidates, grep, x = path)))

300:     hitRel <- names(unlist(sapply(candidates, grep, x = gsub(".*/", "", path))))

841:       fext[compressed] <-file_ext(file_path_sans_ext(files[compressed],

914: #' ## Path above is default path, so no dir argument needed

918: #' #list.experiments(dir = "MY/CUSTOM/PATH)

923:   experiments <- list.files(path = dir, pattern = "\\.csv")

926:     if (dir.exists(cbu.path)) { # If on UIB SERVER

927:       dir <- cbu.path

928:       experiments <- list.files(path = dir, pattern = "\\.csv")

24: #' df <- read.experiment(filepath) # <- valid ORFik .csv file

207:     df[4,] <- c("libtype", "stage", "rep", "condition", "fraction","filepath",

214:     df[4,] <- c("libtype", "stage", "rep", "condition", "fraction","filepath")

217:   # set file paths

220:   df[5:(5+length(files)-1), 1] <- findFromPath(files, libNames(), libtype)

223:   df[5:(5+length(files)-1), 2] <- findFromPath(files, stages, stage)

225:   df[5:(5+length(files)-1), 3] <- findFromPath(files, repNames(), rep)

227:   df[5:(5+length(files)-1), 4] <- findFromPath(files, conditionNames(), condition)

229:   df[5:(5+length(files)-1), 5] <- findFromPath(files, fractionNames(), fraction)

365:   files <- df$filepath

366:   if (length(df$filepath) == 0) stop("df have no filepaths!")

436: #' Get variable name per filepath in experiment

498: #' Get relative paths instead of full. Only use for inspection!

499: #' @return a character vector of paths, or a list of character with 2 paths per,

506: #' filepath(df, "default")

508: #' # filepath(df, "bedo")

510: #' # filepath(df, "pshifted")

516:     i <- which(df$filepath == x)

519:       out.dir <- paste0(dirname(df$filepath[1]), "/pshifted/")

549:       out.dir <- paste0(dirname(df$filepath[1]), "/",type,"/")

565:     if (is.null(input)) stop("filepath type not valid!")

569:   if (all(lengths(paths) == 1)) {

570:     paths <- unlist(paths)

572:   return(paths)

653:       libs <- bplapply(seq_along(paths),

654:                        function(i, paths, df, chrStyle, param, strandMode, varNames) {

656:         fimport(paths[i], chrStyle, param, strandMode)

657:       }, BPPARAM = BPPARAM, paths = paths, chrStyle = chrStyle, df = df,

698: #' dirname(df$filepath[1]),

726:                        out.dir = dirname(df$filepath[1]),

768:                        remove.file_ext(df$filepath[i], basename = TRUE),

284: #' else must be a character vector of length 1 or equal length as filepaths.

289:     if(length(slot) != 1 & length(slot) != length(filepaths)) {

369:     files <- c(files, reversePaths)

388:     stop("Duplicated filepaths in experiment!")

488: #' Get filepaths to ORFik experiment

492: #' default filepaths without warning. \cr

424:                       host="www.ebi.ac.uk",path="/uniprot/biomart/martservice")

270:                 path = file.path(dirname, s, r)

370:                 path = file.path(dirname, s, r)

774: 	    path = unique(c(subset(RData, sample==s)$currentPath, subset(RData, sample==s)$currentPath))

23: 	dir_root = file.path(dirname, "Amplicons")

24: 	dir_results = file.path(dir_root,"Results")

25: 	dir_projectDef = file.path(dir_root,"ProjectDef")

26: 	dir_variants = file.path(dir_results, "Variants")

27: 	dir_align = file.path(dir_results, "Align")

37:             | !file.exists(file.path(dir_variants, "currentVariantDefs.txt"))

38:             | !file.exists(file.path(dir_projectDef, "ampliconsProject.txt"))

95:       doAmplicon = file.path(avaBin, "doAmplicon")

217:               file_sample = file.path(dirname, file_sample)

218:               file_amp = file.path(dirname, file_amp)              

219:               file_reference = file.path(dirname, file_reference)

220:               file_variant = file.path(dirname, file_variant)

221:               file_variantHits = file.path(dirname, file_variantHits)

271:                 files = list.files(path)

281:                   amps_align[[i]]= readLines(file.path(path, file))

325:               file_sample = file.path(dirname, file_sample)

326:               file_amp = file.path(dirname, file_amp)              

327:               file_reference = file.path(dirname, file_reference)

371:                 files = list.files(path)

381:                   amps_align[[i]]= readLines(file.path(path, file))

675:     text = readLines(file.path(dir_projectDef, "ampliconsProject.txt"))

689:     	warning(paste("sample information missing in", file.path(dir_projectDef, "ampliconsProject.txt")))

757: 	    	warning(paste("Read data or MID entries missing in", file.path(dir_projectDef, "ampliconsProject.txt")))

775: 	    if(!any(is.na(path))){

776: 	        path = sapply(strsplit(path, split="\\."), function(x)x[1])

777: 	        ptp = paste(substr(path, 1, nchar(path)-2), collapse=",")

778: 	        lane = paste(substr(path, nchar(path)-1, nchar(path)), collapse=",")

822:         variantDefs=read.table(file=file.path(dir_variants, "currentVariantDefs.txt"), sep="\t",

902:             if(file.exists(file.path(dir_variants, s_id))){

903:                 detections = dir(file.path(dir_variants, s_id), pattern=".txt$", ignore.case=FALSE)

905:                     det = read.table(file.path(dir_variants, s_id, d), sep="\t",

949:         pfLines=readLines(file.path(dir_projectDef, "ampliconsProject.txt"))

997:         pfLines=readLines(file.path(dir_projectDef, "ampliconsProject.txt"))

1052:             thisSampleDir=file.path(dir_align, samples$SampleID[s])

1055:                 thisRefDir=file.path(thisSampleDir, r)

1056:                 alignFile=file.path(thisRefDir, paste(samples$SampleID[s],

700:             	"annotation", "currentPath", "name", "originalPath", "readDataGroup", "sequenceBlueprint"),

760: 	    	RData = data.frame(sample=samples, currentPath=rep(NA, numSamples), 

42:   Path <- getwd()

44:   print(paste("results and report are saved in folder", Path))

47:   imgDir <- file.path(destDir, "image")

82:   write.table(speci, file=file.path(destDir, "fractionReadsOnTarget.txt"), sep="\t", quote=FALSE)

86:   write.table(targcov, file=file.path(destDir, "targetCoverageStats.txt"), sep="\t", quote=FALSE)

100:   write.table(sensi, file=file.path(destDir, "sensitivity.txt"), sep="\t", row.names=FALSE, quote=FALSE)

103:   write.table(perTargCov, file=file.path(destDir, "targetCoverage.txt"), sep="\t", quote=FALSE)

136:   htmlFile <- file.path(destDir, "index.html")

150:   file.copy(cssFile, file.path(destDir, names(cssFile)))

151:   file.copy(system.file("template", "image", biocFile, package="TEQC"), file.path(destDir, "image", biocFile))

167:     imgDir <- file.path(dir, "image")

170:     jpeg(file.path(imgDir, figFile), ...)

172:     png(file.path(imgDir, figFile), ...)

174:     tiff(file.path(imgDir, figFile), ...)

178:     pdf(file.path(imgDir, pdfFile), ...)

183:     hwriteImage(file.path(".", "image", figFile), link=file.path(".", "image", pdfFile))

207:     imgDir <- file.path(dir, "image")

210:     jpeg(file.path(imgDir, figFile), ...)

212:     png(file.path(imgDir, figFile), ...)

214:     tiff(file.path(imgDir, figFile), ...)

218:     pdf(file.path(imgDir, pdfFile), ...)

223:     hwriteImage(file.path(".", "image", figFile), link=file.path(".", "image", pdfFile))

246:     imgDir <- file.path(dir, "image")

249:     jpeg(file.path(imgDir, figFile), ...)

251:     png(file.path(imgDir, figFile), ...)

253:     tiff(file.path(imgDir, figFile), ...)

257:     pdf(file.path(imgDir, pdfFile), ...)

262:     hwriteImage(file.path(".", "image", figFile), link=file.path(".", "image", pdfFile))

289:     imgDir <- file.path(dir, "image")

292:     jpeg(file.path(imgDir, figFile), width=1000, ...)

294:     png(file.path(imgDir, figFile), width=1000, ...)

296:     tiff(file.path(imgDir, figFile),width=1000, ...)

300:     pdf(file.path(imgDir, pdfFile), width=14, ...)

305:     hwriteImage(file.path(".", "image", figFile), link=file.path(".", "image", pdfFile))

335:     imgDir <- file.path(dir, "image")

338:     jpeg(file.path(imgDir, figFile), width=800, height=800, ...)

340:     png(file.path(imgDir, figFile), width=800, height=800, ...)

342:     tiff(file.path(imgDir, figFile), width=800, height=800, ...)

346:     pdf(file.path(imgDir, pdfFile), width=12, height=12, ...)

351:     hwriteImage(file.path(".", "image", figFile), link=file.path(".", "image", pdfFile))

76:             path<-data.frame(matrix(0,length.intersect,(Num.sample.normal+Num.sample.case)))

56:         graph.path<-igraph.from.graphNEL(g)    

42:     pathwaynames <- c()

40:     length.pathway<-c()

58:         #plot(graph.path, edge.arrow.size=.5, vertex.color="gold", vertex.size=5, 

66:         graph.path<-induced_subgraph(graph.path, as.character(intersect(unlist(nodelist),unlist(genelist_reformatted))))

67:         #plot(graph.path)   

82:                 path[j,]<-mydata[which(genelist_reformatted==a[j]),]  #collect expression data of genes for a specific pathway across normal and tumor samples.

87:             cor.normal <- apply(path[,1:Num.sample.normal], 1, function(x) { apply(path[,1:Num.sample.normal], 1, function(y) { cor.test(x,y)[[3]] })})

103:             cor.case <- apply(path[,(Num.sample.normal+1):(Num.sample.normal+Num.sample.case)], 1, function(x) { apply(path[,(Num.sample.normal+1):(Num.sample.normal+Num.sample.case)], 1, function(y) { cor.test(x,y)[[3]] })...(2 bytes skipped)...

1: #' The PoTRA analysis is based on topological ranks of genes in biological pathways. PoTRA can be used to detect pathways involved in disease. The PoTRA package contains one function for creating the PoTRA results obj...(4 bytes skipped)...

7: #' @param Pathway.database The pathway database, such as KEGG, Reactome, Biocarta and PharmGKB. 

14: ...(29 bytes skipped)...ta=mydata, genelist=genelist, Num.sample.normal=Num.sample.normal, Num.sample.case=Num.sample.case, Pathway.database=Pathway.database, PR.quantile=PR.quantile)

16: #' Pathway.database (options): 

17: #' humanKEGG=pathways('hsapiens','kegg')

18: #' humanReactome=pathways('hsapiens','reactome')

19: #' humanBiocarta=pathways('hsapiens','biocarta')

20: #' humanPharmGKB=pathways('hsapiens','pharmgkb')

22: #' Pathway.database=humanKEGG

23: #' Pathway.database=humanReactome

24: #' Pathway.database=humanBiocarta

25: #' Pathway.database=humanPharmGKB

28: PoTRA.corN <- function(mydata,genelist,Num.sample.normal,Num.sample.case,Pathway.database,PR.quantile) {

44:     #humanPharmGKB <- pathways("hsapiens", "pharmgkb")

45:     #humanBiocarta <- pathways("hsapiens", "biocarta")

46:     #humanKEGG <- pathways("hsapiens", "kegg")

48:     for (x in 1:length(Pathway.database[1:length(Pathway.database)])){

51:         p0 <-Pathway.database[[x]]

52:         pathwaynames[x] <- p0@title

54:         g<-pathwayGraph(p) 

65:         length.pathway[x]<-length.intersect

74:             #collect expression data of genes for a specific pathway across normal and tumor samples.

162:     return(list(Fishertest.p.value=Fishertest,KStest.p.value=kstest,LengthOfPathway=length.path...(62 bytes skipped)...rOfHubGenes.case=TheNumOfHubGene.case,TheNumberOfEdges.normal=E.normal,TheNumberOfEdges.case=E.case,PathwayName=pathwaynames))

734:     path <- cch$getFilePath(self$getCacheId(), name='download', ext=ext)

147: #' Get the path to the persistent cache file.

727: #' Gets the path where the downloaded content is written.

728: #' @return The path where the downloaded database is written.

736:     logDebug0('Download path of ', self$getId(), ' is "', path, '".')

738:     return(path)

743: #' @param src Path to the downloaded file.

151: #' containing the paths to the cache files corresponding to the requested

156:     fp <- c$getFilePath(self$getCacheId(), entry.id, self$getEntryFileExt())

729: getDownloadPath=function() {

793:         if ( ! file.exists(self$getDownloadPath()))

795:                 self$getDownloadPath())

26: path <- system.file("extdata", "metadata", package = "recountmethylation")

20: savepath <- paste(dfp, env.name, sep = "/")

27: mdpath <- paste(path, list.files(path)[1], sep = "/")

327:   save(ds, file = file.path("data_analyses", "df-l2med-signals.rda"))

28: md <- get(load(mdpath))

18:         path <- system("pwd",TRUE);

20:                 {postscript(paste(path,paste("/",probe_set[1],sep=""),sep=""));}

21:         else    {postscript(paste(path,paste("/",filename,sep=""),sep=""));}

125:                                  host = "grch37.ensembl.org", path = "/biomart/martservice",

130:                                  host = "grch38.ensembl.org", path = "/biomart/martservice",

138:                                  host = "grch37.ensembl.org", path = "/biomart/martservice",

924:   readr::write_delim(pairs, path = filename, append = TRUE)

614:         write_tsv(cbind(as.data.frame(pairs)[,c(1:3,6)],corretlation.tab),path = file.name.table)

628:         write_tsv(cbind(as.data.frame(pairs)[,c(1:3,6)],corretlation.tab),path = file.name.table)

974:       filename <- file.path(dir,track.names[idx])

976:       filename <- file.path(dir,paste0(sample,".bw"))

994: #' dir(path = "analysis",

1068:                   ret <- summarizeTF(path = x,

1103:                         function(path){

1104:                           TF <- readr::read_csv(dir(path = path, pattern = ".significant.TFs.with.motif.summary.csv",

1106:                           motif <- readr::read_csv(dir(path = path, pattern = ".motif.enrichment.csv",

1129:                           function(path){

1130:                             TF <- readr::read_csv(dir(path = path, 

1133:                             motif <- readr::read_csv(dir(path = path, 

1141:                             TF.meth.cor <- get(load(dir(path = path, pattern = ".TFs.with.motif.pvalue.rda", recursive = T, full.names = T)))

1184:                              function(path){

1185:                                TF <- readr::read_csv(dir(path = path, 

1189:                                motif <- readr::read_csv(dir(path = path, 

1199:                                TF.meth.cor <- get(load(dir(path = path, 

1213:                                TF.meth.cor$analysis <- path

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)

796:         path = samplePath(attributes, pseudotime, nWindows = nWindows)

302: pathToSphericalData = function(path,from,to,d,statistic)

431:             randomPath = path

492:         randomPath = matrix(0,nrow=n,ncol=d)

628: pathProgression = function(path,from=1,to=nrow(path),d=ncol(path),

670: samplePath = function(attributes, pseudotime, nWindows = 10){

678:     pathLength = end - start

681:     sampledPath = matrix(, nrow = 0, ncol = ncol(attributes))

1135:     pathLineWidth = 3

45: testPathForDirectionality = function(path,from=1,to=nrow(path),d=ncol(path),

61:     randomPaths = generateRandomPaths(path,

106: projectPathToSphere = function(path,from=1,to=nrow(path),d=ncol(path))

374: generateRandomPaths = function(path,from=1,to=nrow(path),d=ncol(path),

421:     randomPathList = list()

475: generateRandomPathsBySteps = function(path,randomizationParams,N)

489:     randomPathList = list()

564: getDistanceDataForPaths = function(paths,statistic)

1114: plotPathProjectionCenterAndCircle = function(path,

7: #' Test a path for directionality

9: #' This is the core function of this package.  It takes a path, and a

11: #' for the directionality of that path.

13: #' @param path - An n x m matrix representing a series of n points in

15: #' @param from - The starting place along the path which will be

17: #' @param to - The end point of the path.  This defaults to

18: #'     nrow(path).

20: #'     ncol(path)

25: #'     comparison to the given path.

27: #'   pValue - the p-value for the path and statistic in question;

28: #'   sphericalData - a list containing the projections of the path to

39: #' p = testPathForDirectionality(path=straight_path,

42: #' q = testPathForDirectionality(path=crooked_path,from=6,

48:     testPathForDirectionalityTest(path,from,to,d,

53:     path = path[from:to,seq_len(d)]

57:     sphericalData = getSphericalData(path,statistic)

86: #' Project a path onto the unit sphere

88: #' This function takes a path in d dimensional space and projects it onto

92: #' @param path - This is an mxn dimensional matrix. Each row is

94: #' @param from - The starting place along the path which will be

96: #' @param to - The end point of the path.  This defaults to

97: #'     nrow(path).

99: #'     ncol(path)

100: #' @return This returns a projection of the path onto the d-1 sphere

104: #' projection1 = projectPathToSphere(straight_path)

105: #' projection2 = projectPathToSphere(crooked_path,from=6)

108:     projectPathToSphereTest(path,from,to,d)

112:     path = path[from:to,seq_len(d)]

113:     n = nrow(path)

121:         v = path[i,] - path[1,]

150: #' projection = projectPathToSphere(straight_path)

221: #' distances = findSphericalDistance(straight_path_center,

222: #'     straight_path_projection)

253: #' given by the dimensions of the path

255: #' @param path - an m x n matrix.  Each row is considered a point

258: #'     projections of the path to the sphere, the center for those

263: #' sphericalData = getSphericalData(straight_path,'max')

264: getSphericalData = function(path,statistic)

266:     getSphericalDataTest(path,statistic)

269:     to = nrow(path)

270:     d = ncol(path)

272:     return(pathToSphericalData(path,from,to,d,statistic))

277: #' Find the spherical data for a given path

279: #' This function takes a path and returns a list containing

284: #' @param path - This is an mxn dimensional matrix. Each row is

286: #' @param from - The starting place along the path which will be

288: #' @param to - The end point of the path.  This defaults to

289: #'     nrow(path).

291: #'     ncol(path)

294: #'     projections of the path to the sphere, the center for those

299: #' sphericalData = pathToSphericalData(straight_path,from=1,

300: #'                                     to=nrow(straight_path), d=3,

304:     pathToSphericalDataTest(path,from,to,d,statistic)

309:     path = path[from:to,seq_len(d)]

310:     n = nrow(path)

313:     ## Get the projections of the path to the sphere

314:     projections = projectPathToSphere(path)

345: #' Produce random paths modeled on a given path

347: #' This function takes a path and produces N random paths of the same

349: #' permuting the entries in path or by taking steps from the initial

350: #' point of path.  Exact behaviour is controlled by

353: #' @param path - This is an mxn dimensional matrix. Each row is

355: #' @param from - The starting place along the path which will be

357: #' @param to - The end point of the path.  This defaults to

358: #'     nrow(path).

360: #'     ncol(path)

366: #' @return This function returns a list of random paths.  Each path is

371: #' randomPaths = generateRandomPaths(crooked_path,from=6,to=nrow(crooked_path),

372: #'               d=ncol(crooked_path),randomizationParams=randomizationParams,

377:     generateRandomPathsTest(path,from,to,d,randomizationParams,N)

388:     path = path[from:to,seq_len(d)]

391:         return(generateRandomPathsByPermutation(path,

396:         return(generateRandomPathsBySteps(path,

407: ## ' This function produces randomized paths from a given path via

413: ## ' @param path - An n x d matrix.

419:     function(path,randomizationParams,N)

422:     n = nrow(path)

423:     d = ncol(path)

447:         a = as.numeric(path)

450:             b = as.numeric(path)

463: ## ' This function produces randomized paths from a given path by taking

465: ## ' have the same Euclidean length as those of the original path or