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)

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

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

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")){

127: var path = svg.append('svg:g').selectAll('path'),

2499: function ShowShortestPath(){

2: var basePath1="./PPIinfo/";

3: var basePath2="./PPIinfo/";

2630: function ShowShortestPath1(){

2711: var swiss2paths={};

2765: function showPath10(){

2778: function addResultPath10(p){

2784: function addFirstPath10(p){

2800: function addLastPath10(p){

2823: function addPreviousPath10(p){

2842: function addNextPath10(p){

2560: var resultPaths=[];

2561: function ShowPaths(allPaths){

2616: function ShowPathView(index){

2712: function generatePaths(swiss, root){

2729: function ShowShortestPathExp(){

2763: var showPathFirst=0;

2764: var showPathEnd=10;

3044: function getCisPathJS(){

3065: function getCisPathJSRetry(urltry){

3096: function getPathsForTargetProtein(swissID){

3118: function getPathsForTargetProteinRetry(urltry){

53:   .append('svg:path')

68:   .append('svg:path')

94:   .append('svg:path')

109:   .append('svg:path')

115: var drag_line = svg.append('svg:path')

166:   path.attr('d', function(d) {

360:   // path (link) group

381:   path = path.data(links);

384:   path.classed('selected', function(d) { return d === selected_link; })

393:   path.enter().append('svg:path')

414:   path.exit().remove();

2384: ///////////////////////////////////////////////////////////////////////shortest path

2504:        alert("No path between this two proteins!");

2508:        alert("No path between this two proteins!");

2568:     addTh(mycurrent_row, "Path");

2601:         mycurrent_button.id = "path"+x;

2614:     ShowPathView("path0");

2701:        alert("Sorry, detect no path from "+swiss1+" to "+ swiss2);

3097:    var url="./js/"+swissID+"_path.js";

954: 	 document.getElementById("detectPath").disabled=true;

1380:   idx=pathLen-1-idx;

1415: 	var url=basePath2+sourceSwiss+".js";

1679: 	var url=basePath2+swiss1+".js";

1684:            if(this.url==(basePath2+swiss1+".js")){

1820:   var url=basePath2+"A0A5B9.js";

1827:         debugObj("basePath1:"+basePath1);

1831:         basePath1="../geneset20140628/";

1832:         basePath2="../20140628PPI/";

1833:         debugObj("basePath1:"+basePath1);

1845:   var url=basePath2+"gene2swiss.js";

1899: 	var url=basePath2+"swiss2gene.js";

1954: 	var url=basePath2+"swiss2swiss.js";

2021: 	var url=basePath1+"PPI.js";

2411:     	 ShowShortestPath();

2421:           document.getElementById("detectPath").disabled=false;

2426:        document.getElementById("detectPath").disabled=true;

2438:           document.getElementById("detectPath").disabled=false;

2443:        document.getElementById("detectPath").disabled=true;

2515:     document.getElementById("detectPath").disabled=true;

2530:           document.getElementById("detectPath").disabled=false;

2543:            setTimeout("ShowShortestPath1()",1000);

2549:     setTimeout("ShowShortestPath1()",1000);

2574: 	    mycurrent_row.id="pathrow"+x;

2608: 	showPath10();

2611:     document.getElementById("detectPath").disabled=false;

2625: 	  	document.getElementById("pathrow"+x).className="rowNotSelected";

2627: 	document.getElementById("pathrow"+i).className="rowSelected";

2705:     swiss2paths={};

2707:     debugObj(swiss2paths[swiss2]);

2708:     debugObj(swiss2paths[swiss2].length);

2709:     ShowPaths(swiss2paths[swiss2]);

2713:     swiss2paths[swiss]=[];

2715:        swiss2paths[swiss].push(swiss);

2724:         for(var y in swiss2paths[nodes[x]]){

2725:             swiss2paths[swiss].push(swiss2paths[nodes[x]][y]+"#"+swiss);

2760:     ShowShortestPath();

2771:     addResultPath10(p);

2772:     addFirstPath10(p);

2773:     addPreviousPath10(p);

2774:     addNextPath10(p);

2775:     addLastPath10(p);

2796:     resultSPAN.addEventListener("click", function(e){showPathFirst=0;showPath10();}, false);

2819:     resultSPAN.addEventListener("click", function(e){showPathFirst=newFirst;showPath10();}, false);

2838:     resultSPAN.addEventListener("click", function(e){showPathFirst=newFirst;showPath10();}, false);

2857:     resultSPAN.addEventListener("click", function(e){showPathFirst=newFirst;showPath10();}, false);

2879: 	  	document.getElementById("pathrow"+i).style.display="none";

2882:         document.getElementById("pathrow"+i).style.display="";

3020: ...(31 bytes skipped)...ange", function(e){document.getElementById('targetPtxt').value=this.value;checkValid2();ShowShortestPath();}, false);

3108:         json.paths.pop();

3109:     	ShowPaths(json.paths);

3138:         json.paths.pop();

3139:     	ShowPaths(json.paths);

956: 	 document.getElementById("allShortestPaths").style.display="none";

957: 	 document.getElementById("allShortestPathsP").style.display="none";

1253: 	graphName = "cisPathValue#"+graphName;

1267:       if(key.substr(0,13)!="cisPathValue#"){

1285: 	graphName = "cisPathValue#"+graphName;

1306: 	graphName = "cisPathValue#"+graphName;

1327:       if(key.substr(0,13)!="cisPathValue#"){

1418:     callback: "cisPathCallBack",

1682:        callback: "cisPathCallBack",

1823:     callback: "cisPathCallBack",

1850:     callback: "cisPathCallBack",

1880:     callback: "cisPathCallBack",

1905:     callback: "cisPathCallBack",

1935:     callback: "cisPathCallBack",

1960:     callback: "cisPathCallBack",

1990:     callback: "cisPathCallBack",

2025:     callback: "cisPathCallBack",

2063:     callback: "cisPathCallBack",

2110: 	getCisPathJS();

2378:     var graphName="cisPathHTML";

2476: function ShowShortestPathWorker(){

2477:    var worker = new Worker("./D3/cisPathWorker.js");

2480:       var resultPaths=event.data.resultPaths;

2481:       ShowPaths(resultPaths);

2484:       var resultPaths=[];

2485:       ShowPaths(resultPaths);

2514:     document.getElementById("detectPathExp").disabled=true;

2521:     document.getElementById("allShortestPaths").style.display="none";

2522:     document.getElementById("allShortestPathsP").style.display="none";

2529:           document.getElementById("detectPathExp").disabled=false;

2533:           getPathsForTargetProtein(swiss2);

2539:            ShowShortestPathWorker();

2562:     resultPaths=allPaths;

2563:     var table=document.getElementById("allShortestPaths");

2571: 	for(var x in allPaths){

2572: 	    var nodes=allPaths[x].split("#");

2602:         mycurrent_button.addEventListener("click", function(e){ShowPathView(this.id);}, false);

2607: 	showPathFirst=0;

2610:     document.getElementById("detectPathExp").disabled=false;

2612:     document.getElementById("allShortestPaths").style.display="";

2613:     document.getElementById("allShortestPathsP").style.display="";

2617:     var total=resultPaths.length;

2619:     var nodes=resultPaths[i].split("#");

2706:     generatePaths(swiss2, swiss1);

2723:         generatePaths(nodes[x], root);

2767:     var p=document.getElementById("allShortestPathsP");

2780:     var content="Results: "+showPathFirst+"-"+showPathEnd+" of "+resultPaths.length+" ";

2790:     if(showPathFirst==0){

2805: 	var newFirst=(resultPaths.length-resultPaths.length%10);

2806: 	if(newFirst==resultPaths.length){

2807: 	   newFirst=resultPaths.length-10;

2813:     if(showPathEnd==resultPaths.length){

2828:     if(showPathFirst==0){

2834:     var newFirst=showPathFirst-10;

2847:     if(showPathEnd==resultPaths.length){

2853:     var newFirst=showPathFirst+10;

2854:     if(newFirst >= resultPaths.length){

2855:        newFirst = (resultPaths.length-resultPaths.length%10);

2863: 	var total=resultPaths.length;

2864: 	if(showPathFirst >= total){

2865: 	   showPathFirst=(total-total%10);

2867: 	if(showPathFirst == total){

2868: 	   showPathFirst = total-10;

2870:     if(showPathFirst < 0){

2871: 	   showPathFirst = 0;

2873: 	showPathFirst=showPathFirst-(showPathFirst%10);

2874: 	showPathEnd=showPathFirst+10;

2875: 	if(showPathEnd > total){

2876: 	   showPathEnd = total;

2881:     for(var i=showPathFirst;i<showPathEnd;i++){

3049:     callback: "cisPathCallBack",

3061:         getCisPathJSRetry(this.url);

3078:     callback: "cisPathCallBack",

3090:         getCisPathJSRetry(this.url);

3101:      callback: "cisPathCallBack",

3114:         getPathsForTargetProteinRetry(this.url);

3131:     callback: "cisPathCallBack",

3144:         getPathsForTargetProteinRetry(this.url);

3151: 	document.getElementById("detectPathExp").disabled=true;

3156: 	document.getElementById("detectPathExp").disabled=false;

127: var path = svg.append('svg:g').selectAll('path'),

2501: function ShowShortestPath(){

2: var basePath1="./PPIinfo/";

3: var basePath2="./PPIinfo/";

2632: function ShowShortestPath1(){

2719: var swiss2paths={};

2753: function showPath10(){

2766: function addResultPath10(p){

2772: function addFirstPath10(p){

2788: function addLastPath10(p){

2811: function addPreviousPath10(p){

2830: function addNextPath10(p){

2548: var resultPaths=[];

2549: function ShowPaths(allPaths){

2615: function ShowPathView(index){

2720: function generatePaths(swiss, root){

2737: function ShowShortestPathExp(){

2751: var showPathFirst=0;

2752: var showPathEnd=10;

53:   .append('svg:path')

68:   .append('svg:path')

94:   .append('svg:path')

109:   .append('svg:path')

115: var drag_line = svg.append('svg:path')

166:   path.attr('d', function(d) {

360:   // path (link) group

381:   path = path.data(links);

384:   path.classed('selected', function(d) { return d === selected_link; })

393:   path.enter().append('svg:path')

414:   path.exit().remove();

2386: ///////////////////////////////////////////////////////////////////////shortest path

2506:        alert("No path between this two proteins!");

2510:        alert("No path between this two proteins!");

2554:     	 alert("Sorry, detect no path from "+swiss1+" to "+ swiss2);

2566:     addTh(mycurrent_row, "Path");

2599:         mycurrent_button.id = "path"+x;

2613:       ShowPathView("path0");

2705:        alert("Sorry, detect no path from "+name1+" to "+ name2);

954: 	 document.getElementById("detectPath").disabled=true;

1380:   idx=pathLen-1-idx;

1415: 	var url=basePath2+sourceSwiss+".js";

1679: 	var url=basePath2+swiss1+".js";

1684:            if(this.url==(basePath2+swiss1+".js")){

1820:   var url=basePath2+"A0A5B9.js";

1827:         debugObj("basePath1:"+basePath1);

1831:         basePath1="../geneset20140628/";

1832:         basePath2="../20140628PPI/";

1833:         debugObj("basePath1:"+basePath1);

1845:   var url=basePath2+"gene2swiss.js";

1899: 	var url=basePath2+"swiss2gene.js";

1954: 	var url=basePath2+"swiss2swiss.js";

2021: 	var url=basePath1+"PPI.js";

2413:     	 ShowShortestPath();

2423:           document.getElementById("detectPath").disabled=false;

2428:        document.getElementById("detectPath").disabled=true;

2440:           document.getElementById("detectPath").disabled=false;

2445:        document.getElementById("detectPath").disabled=true;

2517:     document.getElementById("detectPath").disabled=true;

2531:            setTimeout("ShowShortestPath1()",1000);

2537:     setTimeout("ShowShortestPath1()",1000);

2558:        document.getElementById("detectPath").disabled=false;

2572: 	    mycurrent_row.id="pathrow"+x;

2606: 	showPath10();

2610:     document.getElementById("detectPath").disabled=false;

2627: 	  	document.getElementById("pathrow"+x).className="rowNotSelected";

2629: 	document.getElementById("pathrow"+i).className="rowSelected";

2709:        document.getElementById("detectPath").disabled=false;

2713:     swiss2paths={};

2715:     debugObj(swiss2paths[swiss2]);

2716:     debugObj(swiss2paths[swiss2].length);

2717:     ShowPaths(swiss2paths[swiss2]);

2721:     swiss2paths[swiss]=[];

2723:        swiss2paths[swiss].push(swiss);

2732:         for(var y in swiss2paths[nodes[x]]){

2733:             swiss2paths[swiss].push(swiss2paths[nodes[x]][y]+"#"+swiss);

2748:     ShowShortestPath();

2759:     addResultPath10(p);

2760:     addFirstPath10(p);

2761:     addPreviousPath10(p);

2762:     addNextPath10(p);

2763:     addLastPath10(p);

2784:     resultSPAN.addEventListener("click", function(e){showPathFirst=0;showPath10();}, false);

2807:     resultSPAN.addEventListener("click", function(e){showPathFirst=newFirst;showPath10();}, false);

2826:     resultSPAN.addEventListener("click", function(e){showPathFirst=newFirst;showPath10();}, false);

2845:     resultSPAN.addEventListener("click", function(e){showPathFirst=newFirst;showPath10();}, false);

2867: 	  	document.getElementById("pathrow"+i).style.display="none";

2870:         document.getElementById("pathrow"+i).style.display="";

956: 	 document.getElementById("allShortestPaths").style.display="none";

957: 	 document.getElementById("allShortestPathsP").style.display="none";

1253: 	graphName = "cisPathValue#"+graphName;

1267:       if(key.substr(0,13)!="cisPathValue#"){

1285: 	graphName = "cisPathValue#"+graphName;

1306: 	graphName = "cisPathValue#"+graphName;

1327:       if(key.substr(0,13)!="cisPathValue#"){

1418:     callback: "cisPathCallBack",

1682:        callback: "cisPathCallBack",

1823:     callback: "cisPathCallBack",

1850:     callback: "cisPathCallBack",

1880:     callback: "cisPathCallBack",

1905:     callback: "cisPathCallBack",

1935:     callback: "cisPathCallBack",

1960:     callback: "cisPathCallBack",

1990:     callback: "cisPathCallBack",

2025:     callback: "cisPathCallBack",

2063:     callback: "cisPathCallBack",

2380:     var graphName="cisPathHTML";

2478: function ShowShortestPathWorker(){

2479:    var worker = new Worker("./D3/cisPathWorker.js");

2482:       var resultPaths=event.data.resultPaths;

2483:       ShowPaths(resultPaths);

2486:       var resultPaths=[];

2487:       ShowPaths(resultPaths);

2516:     document.getElementById("detectPathExp").disabled=true;

2523:     document.getElementById("allShortestPaths").style.display="none";

2524:     document.getElementById("allShortestPathsP").style.display="none";

2527:            ShowShortestPathWorker();

2550:     resultPaths=allPaths;

2551:     if(resultPaths.length==0){

2557:        document.getElementById("detectPathExp").disabled=false;

2561:     var table=document.getElementById("allShortestPaths");

2569: 	for(var x in allPaths){

2570: 	    var nodes=allPaths[x].split("#");

2600:         mycurrent_button.addEventListener("click", function(e){ShowPathView(this.id);}, false);

2605: 	showPathFirst=0;

2609:     document.getElementById("detectPathExp").disabled=false;

2611:     document.getElementById("allShortestPaths").style.display="";

2612:     document.getElementById("allShortestPathsP").style.display="";

2616:     var total=resultPaths.length;

2618:     if(i>=resultPaths.length){

2621:     var nodes=resultPaths[i].split("#");

2708:        document.getElementById("detectPathExp").disabled=false;

2714:     generatePaths(swiss2, swiss1);

2731:         generatePaths(nodes[x], root);

2755:     var p=document.getElementById("allShortestPathsP");

2768:     var content="Results: "+showPathFirst+"-"+showPathEnd+" of "+resultPaths.length+" ";

2778:     if(showPathFirst==0){

2793: 	var newFirst=(resultPaths.length-resultPaths.length%10);

2794: 	if(newFirst==resultPaths.length){

2795: 	   newFirst=resultPaths.length-10;

2801:     if(showPathEnd==resultPaths.length){

2816:     if(showPathFirst==0){

2822:     var newFirst=showPathFirst-10;

2835:     if(showPathEnd==resultPaths.length){

2841:     var newFirst=showPathFirst+10;

2842:     if(newFirst >= resultPaths.length){

2843:        newFirst = (resultPaths.length-resultPaths.length%10);

2851: 	var total=resultPaths.length;

2852: 	if(showPathFirst >= total){

2853: 	   showPathFirst=(total-total%10);

2855: 	if(showPathFirst == total){

2856: 	   showPathFirst = total-10;

2858:     if(showPathFirst < 0){

2859: 	   showPathFirst = 0;

2861: 	showPathFirst=showPathFirst-(showPathFirst%10);

2862: 	showPathEnd=showPathFirst+10;

2863: 	if(showPathEnd > total){

2864: 	   showPathEnd = total;

2869:     for(var i=showPathFirst;i<showPathEnd;i++){

2942: 	document.getElementById("detectPathExp").disabled=true;

2947: 	document.getElementById("detectPathExp").disabled=false;

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

375:         path <- paste0("/Analyses/Basecall_", d, "_000/Log")

376:         exists <- .groupExistsObj(fid, group = path)

378:             did <- H5Dopen(fid, path)

313:     std::string path;

208:     Bamfile(const char * path) : holding(false) { 

209:         in = sam_open(path, "rb");

212:             out << "failed to open BAM file at '" << path << "'";

267:         path=converter.str();

292:             out=std::fopen(path.c_str(), "a");

294:             out=std::fopen(path.c_str(), "w"); // Overwrite any existing file, just to be safe.

298:             err << "failed to open output file at '" << path << "'"; 

326:     const Rcpp::String bampath=check_string(bamfile, "BAM file path");

512:                 outpaths[j]=collected[i][j].path;

595:     Rcpp::String bampath=check_string(incoming, "BAM file path");

334:     Bamfile input(bampath.get_cstring());

596:     Bamfile input(bampath.get_cstring());

507:     Rcpp::List filepaths(nc);

509:         Rcpp::StringVector outpaths(i+1);

515:         filepaths[i]=outpaths;

518:     return Rcpp::List::create(filepaths, 

2294:       path <- system.file("doc", "GeneTonic_manual.html", package = "GeneTonic")

2295:       if (path == "") {

2298:         browseURL(path)

2352:           reactive_values$in_gtl <- readRDS(input$uploadgtl$datapath)

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)

272:                 "path": "/demo/test-files/chr20.gtf"

280:               "path": "/sbgenomics/test-data/chr20.fa"

476:               "path": "/path/to/fastq.ext"

818:               "path": "/root/dir/example.tested.bam"

2894:               "path": "genome.ext"

2936:                 "path": "/test-data/mate_1.fastq.bz2"

2995:                 "path": "/demo/test-data/chr20.gtf"

349: ...(34 bytes skipped)...r sjFormat = \"False\"\n  var gtfgffFormat = \"False\"\n  var list = $job.inputs.sjdbGTFfile\n  var paths_list = []\n  var joined_paths = \"\"\n  \n  if (list) {\n    list.forEach(function(f){return paths_list.push(f.path)})\n    joined_paths = paths_list.join(\" \")\n\n\n    path...(355 bytes skipped)...ne\") {\n      if (sjFormat == \"True\") {\n        return \"--sjdbFileChrStartEnd \".concat(joined_path...(5 bytes skipped)...     }\n      else if (gtfgffFormat == \"True\") {\n        return \"--sjdbGTFfile \".concat(joined_paths)\n      }\n    }\n  }\n}",

445:         "sbg:cmdPreview": "python /opt/sbg_fastq_quality_scale_detector.py --fastq /path/to/fastq.ext /path/to/fastq.ext",

898:               "script": "{\n  filename = $job.inputs.input_bam.path\n  ext = $job.inputs.output_type\n\nif (ext === \"BAM\")\n{\n    return filename.split('.').slice(0...(372 bytes skipped)...

910:               "script": "{\n  filename = $job.inputs.input_bam.path\n  \n  /* figuring out output file type */\n  ext = $job.inputs.output_type\n  if (ext === \"BAM\")...(657 bytes skipped)...

992:             "script": "$job.inputs.genome.path",

1606: ...(48 bytes skipped)...concat($job.inputs.reads)\n  \n  var resp = []\n  \n  if (list.length == 1){\n    resp.push(list[0].path...(178 bytes skipped)...etadata != null){\n        if (list[index].metadata.paired_end == 1){\n          left = list[index].path\n        }else if (list[index].metadata.paired_end == 2){\n          right = list[index].path...(297 bytes skipped)...data != null){\n        if (list[index].metadata.paired_end == 1){\n          left.push(list[index].path)\n        }else if (list[index].metadata.paired_end == 2){\n          right.push(list[index].path)\n        }\n      }\n    }\n    left_join = left.join()\n    right_join = right.join()\n    if (le...(200 bytes skipped)...

3224:               "script": "{\n  file = [].concat($job.inputs.reads)[0].path\n  extension = /(?:\\.([^.]+))?$/.exec(file)[1]\n  if (extension == \"gz\") {\n    return \"--readF...(107 bytes skipped)...

3232: ...(34 bytes skipped)...r sjFormat = \"False\"\n  var gtfgffFormat = \"False\"\n  var list = $job.inputs.sjdbGTFfile\n  var paths_list = []\n  var joined_paths = \"\"\n  \n  if (list) {\n    list.forEach(function(f){return paths_list.push(f.path)})\n    joined_paths = paths_list.join(\" \")\n\n\n    path...(355 bytes skipped)...ne\") {\n      if (sjFormat == \"True\") {\n        return \"--sjdbFileChrStartEnd \".concat(joined_path...(5 bytes skipped)...     }\n      else if (gtfgffFormat == \"True\") {\n        return \"--sjdbGTFfile \".concat(joined_paths)\n      }\n    }\n  }\n}",

3280: ...(138 bytes skipped)...gth, i= 0;\n  while(i<L && a1.charAt(i)=== a2.charAt(i)) i++;\n  return a1.substring(0, i);\n  }\n  path_list = []\n  arr = [].concat($job.inputs.reads)\n  arr.forEach(function(f){return path_list.push(f.path.replace(/\\\\/g,'/').replace( /.*\\//, '' ))})\n  common_prefix = sharedStart(path_list)\n  intermediate = common_prefix.replace( /\\-$|\\_$|\\.$/, '' ).concat(\"._STARgenome\")\n  s...(262 bytes skipped)...

3289: ...(138 bytes skipped)...gth, i= 0;\n  while(i<L && a1.charAt(i)=== a2.charAt(i)) i++;\n  return a1.substring(0, i);\n  }\n  path_list = []\n  arr = [].concat($job.inputs.reads)\n  arr.forEach(function(f){return path_list.push(f.path.replace(/\\\\/g,'/').replace( /.*\\//, '' ))})\n  common_prefix = sharedStart(path_list)\n  return \"./\".concat(common_prefix.replace( /\\-$|\\_$|\\.$/, '' ), \".\")\n}",

3298: ...(138 bytes skipped)...gth, i= 0;\n  while(i<L && a1.charAt(i)=== a2.charAt(i)) i++;\n  return a1.substring(0, i);\n  }\n  path_list = []\n  arr = [].concat($job.inputs.reads)\n  arr.forEach(function(f){return path_list.push(f.path.replace(/\\\\/g,'/').replace( /.*\\//, '' ))})\n  common_prefix = sharedStart(path_list)\n  mate1 = common_prefix.replace( /\\-$|\\_$|\\.$/, '' ).concat(\".Unmapped.out.mate1\")\n  m...(463 bytes skipped)...

1664: CdGDSObj *CdGDSFolder::Path(const UTF8String &FullName)

2171: CdGDSObj *CdGDSVirtualFolder::Path(const UTF8String &FullName)

1298: static const char *ERR_INVALID_PATH  = "The GDS node \"%s\" does not exist.";

1672: CdGDSObj *CdGDSFolder::PathEx(const UTF8String &FullName)

2177: CdGDSObj *CdGDSVirtualFolder::PathEx(const UTF8String &FullName)

1668: 		throw ErrGDSObj(ERR_INVALID_PATH, FullName.c_str());

2174: 	return fLinkFile->Root().Path(FullName);

1666: 	CdGDSObj *rv = PathEx(FullName);

2180: 	return fLinkFile->Root().PathEx(FullName);

495:     path <- .sql_get_rpath(x, rids)

531:     update_time_and_path <- function(x, i) {

540:             locfile_path <- file.path(bfccache(x), id)

402:     rpath <- .sql_add_resource(x, rname, rtype, fpath, ext)

1001:         fpath <- .sql_get_fpath(x, rid)

1185:     paths <- .sql_get_rpath(x, bfcrid(x))

1312:             newpath <- file.path(dir, basename(orig))

1385:     exportPath <- file.path(exdir, "BiocFileCacheExport")

1131:     rpaths <- .sql_get_rpath(x, rids)

1433:     rpaths <- .sql_get_rpath(x, rids)

35: #'   \item{'cache': }{character(1) on-disk location (directory path) of the

54: #'   \item{'rpath': }{resource path. This is the path to the local

75: #' @param cache character(1) On-disk location (directory path) of

101:                  "  Problematic cache: ", path.expand(olddefault),"\n",

116:             cache <- file.path(tempdir(), "BiocFileCache")

224: #' @describeIn BiocFileCache Get a file path for select resources from

239: #' @describeIn BiocFileCache Set the file path of selected resources

241: #' @param value character(1) Replacement file path.

282: #' @return For 'bfcnew': named character(1), the path to save your

286: #' path <- bfcnew(bfc0, "NewResource")

287: #' path

328: #' @param fpath For bfcadd(), character(1) path to current file

330: #'     assumed to also be the path location. For bfcupdate()

333: #'     if the resource is a local file, a relative path in the cache,

336: #'     relative or web paths, based on the path prefix.

340: #'     in current location but save the path in the cache. If 'rtype

356: #' @return For 'bfcadd': named character(1), the path to save your

482: #' @return For 'bfcpath': the file path location to load

496:     path

515: #'     in the cache the path is returned, if it is not it will try to

520: #' @return For 'bfcrpath': The local file path location to load.

541:             locfile <- .lock2(locfile_path, exclusive = TRUE)

550:                     names(update_time_and_path(x, res))

559:                 .unlock2(locfile_path)

562:             names(update_time_and_path(x, res))

589:         update_time_and_path(x, rids)

670:                     "Setting a new remote path results in immediate\n",

1069: #' @return For 'bfcdownload': character(1) path to downloaded resource

1184:     files <- file.path(bfccache(x), setdiff(dir(bfccache(x)),c(.CACHE_FILE, .CACHE_FILE_LOCK)))

1253: #' @return character(1) The outputFile path.

1275:     dir <- file.path(tempdir(), "BiocFileCacheExport")

1316:                 newpath <- file.path(dir, filename)

1343:         outputFile = file.path(origdir, outputFile)

1353:     .util_unlink(file.path(dir, .CACHE_FILE_LOCK))

58: #'   \item{'fpath': }{If rtype is "web", this is the link to the

228: #' @return For '[[': named character(1) rpath for the given resource

236:     .sql_get_rpath(x, i)

251:     .sql_set_rpath(x, i, value)

254:         warning("updating rpath, changing rtype to 'local'")

305:         x, rname, fpath = rname, rtype=c("auto", "relative", "local", "web"),

317:         x, rname, fpath = rname, rtype=c("auto", "relative", "local", "web"),

322:     bfcadd(x=BiocFileCache(), rname=rname, fpath=fpath, rtype=rtype,

338: #'     \code{copy} of \code{fpath} in the cache directory; \code{move}

375: #' bfcadd(bfc0, "TestWeb", fpath=url)

380:         x, rname, fpath = rname,

388:         is.character(fpath), length(fpath) > 0L, !any(is.na(fpath))

394:     stopifnot((length(action) == 1) || (length(action) == length(fpath)))

395:     stopifnot((length(rtype) == 1) || (length(rtype) == length(fpath)))

396:     if (length(action) == 1) action = rep(action, length(fpath))

397:     if (length(rtype) == 1) rtype = rep(rtype, length(fpath))

399:     rtype <- .util_standardize_rtype(rtype, fpath, action)

400:     stopifnot(all(rtype == "web" | file.exists(fpath)))

403:     rid <- names(rpath)

405:     for(i in seq_along(rpath)){

409:                 copy = file.copy(fpath[i], rpath[i]),

410:                 move = file.rename(fpath[i], rpath[i]),

412:                     .sql_set_rpath(x, rid[i], fpath[i])

413:                     rpath[i] <- bfcrpath(x, rids = rid[i])

421:     rpath

455:     tbl <- mutate(tbl, rpath = unname(bfcrpath(x, rids=rids)))

467: setGeneric("bfcpath",

468:     function(x, rids) standardGeneric("bfcpath"),

473: #' @aliases bfcpath,missing-method

474: #' @exportMethod bfcpath

475: setMethod("bfcpath", "missing",

478:     bfcpath(x=BiocFileCache(), rids=rids)

484: #' bfcpath(bfc0, rid3)

485: #' @aliases bfcpath

486: #' @exportMethod bfcpath

487: setMethod("bfcpath", "BiocFileCacheBase",

500: setGeneric("bfcrpath",

501:     function(x, rnames, ..., rids, exact = TRUE) standardGeneric("bfcrpath"),

506: #' @aliases bfcrpath,missing-method

507: #' @exportMethod bfcrpath

508: setMethod("bfcrpath", "missing",

511:     bfcrpath(x=BiocFileCache(), rnames=rnames, ..., rids=rids, exact=exact)

514: #' @describeIn BiocFileCache display rpath of resource. If 'rnames' is

522: #' bfcrpath(bfc0, rids = rid3)

523: #' @aliases bfcrpath

524: #' @exportMethod bfcrpath

525: setMethod("bfcrpath", "BiocFileCacheBase",

532:         .sql_get_rpath(x, i)

586:         bfcrpath(x, rids = rids0)

609: #' @param rpath character() vector of replacement rpaths.

613: #' bfcupdate(bfc0, rid3, rpath=fl3, rname="NewRname")

615: #' bfcupdate(bfc0, "BFC5", fpath="http://google.com")

619:     function(x, rids, rname=NULL, rpath=NULL, fpath=NULL,

625:         is.null(rpath) || (length(rids) == length(rpath)),

626:         is.null(fpath) || (length(rids) == length(fpath))

630:         is.null(rpath) || is.character(rpath),

631:         is.null(fpath) || is.character(fpath)

644:         if (!is.null(rpath)) {

645:             if (!file.exists(rpath[i]))

649:                     "\n  rpath: ", sQuote(rpath[i]),

650:                     "\n  reason: rpath does not exist.",

653:             .sql_set_rpath(x, rids[i], rpath[i])

656:                 warning("updating rpath, changing rtype to 'local'")

661:         if (!is.null(fpath)) {

679:                     x, rids[i], proxy, config, "bfcupdate()", fpath[i], ...

681:                 .sql_set_fpath(x, rids[i], fpath[i])

863:     function(x, query, field=c("rname", "rpath", "fpath"), ..., exact = FALSE)

872:     function(x, query, field=c("rname", "rpath", "fpath"), ..., exact = FALSE)

885: #'     matches pattern agains rname, rpath, and fpath. If exact

890: #'     \code{bfcrpath}, the default is \code{TRUE} (exact matching).

902:     function(x, query, field=c("rname", "rpath", "fpath"), ..., exact = FALSE)

978: #'     'rid'. \code{TRUE}: fpath \code{etag} or \code{modified} time of

979: #'     web resource more recent than in BiocFileCache; \code{FALSE}: fpath

1004:         cache_info <- .httr_get_cache_info(fpath)

1086:     if (ask && any(file.exists(.sql_get_rpath(x, rid)))) {

1097:     bfcrpath(x, rids=rid)

1186:     # normalizePath on windows

1189:         files = normalizePath(files)

1190:         paths = normalizePath(paths)

1192:     untracked <- setdiff(files, paths)

1247: #' @param outputFile character(1) The <filepath>/basename for the

1311:             orig <- .sql_get_rpath(x, i)

1313:             if (file.exists(newpath)) {

1318:             file.copy(orig, newpath)

1386:     stopifnot(!dir.exists(exportPath))

1396:     bfc = BiocFileCache(exportPath)

348: #'     \code{httr::GET}. For 'bfcrpaths': Additional arguments passed

481: #' @describeIn BiocFileCache display rpaths of resource.

1132:     cached <- startsWith(rpaths, bfccache(x))

1135:     status <- .util_unlink(rpaths[cached])

1434:     cached <- startsWith(rpaths, bfccache(x))

1437:         txt0 <- paste("file ", sQuote(rpaths))

1446:     .util_unlink(rpaths[cached])

146:         path <- Sys.getenv("APPDATA", "")

175:         path <- file.path(d, exec)

206:     path <- NULL # cache the path to megadepth

182:     path2 <- Sys.which(cmd)

143: bin_paths <- function(dir = "Megadepth",

15: #' found via the environment variable \code{PATH}.

17: #' If you want to install Megadepth to a custom path, you can set the global

35: #' @importFrom xfun is_windows is_macos same_path

75:     exec <- file.path(tempdir(), exec_name)

144:     extra_path = getOption("megadepth.dir")) {

147:         path <- if (fs::dir_exists(path)) {

148:             file.path(path, dir)

151:         path <- "~/Library/Application Support"

152:         path <- if (fs::dir_exists(path)) file.path(path, dir)

153:         path <- c("/usr/local/bin", path)

155:         path <- c("~/bin", "/snap/bin", "/var/lib/snapd/snap/bin")

157:     path <- c(extra_path, path, pkg_file(dir, mustWork = FALSE))

159:     path <- path[path != ""]

162:         path <- c(tempdir(), path)

164:     path

167: # find an executable from PATH, APPDATA, system.file(), ~/bin, etc

176:         if (utils::file_test("-x", path)) {

179:             path <- ""

183:     if (path == "" || xfun::same_path(path, path2)) {

184:         if (path2 == "") {

187:         return(cmd) # do not use the full path of the command

189:         if (path2 != "") {

194:                 path,

196:                 path2,

202:     normalizePath(path)

208:         if (is.null(path)) {

209:             path <<- find_exec(

215:         path

109:     dirs <- bin_paths()

139:     message("megadepth has been installed to ", normalizePath(destdir))

158:     # remove empty paths potentially created by pkgfile

169:     for (d in bin_paths(dir)) {

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)...