Found 80062 results in 7813 files, showing top 50 files (show more).
seq2pathway:R/seq2pathway.r: [ ]
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")){
NoRCE:R/pathway.R: [ ]
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
biodbKegg:R/KeggPathwayConn.R: [ ]
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)
CHRONOS:R/pathwayToGraph.R: [ ]
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
cisPath:inst/extdata/D3/cisPath.js: [ ]
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;
KnowSeq:R/DEGsToPathways.R: [ ]
43:         path <- path.index[path.index != ""]
41:         path.index <- substr(get_pathway_text,start,final)
26:       pathway_start <- str_locate_all(pattern = "PATHWAY", get_GO_text)[[1]][2]
27:       pathway_end <- str_locate_all(pattern = "BRITE", get_GO_text)[[1]][1]
28:       pathways <- substr(get_GO_text,pathway_start+1,pathway_end-1)
34:         pathway <- as.character(unlist(str_extract_all(unlist(pathways)[i],"hsa[a-zA-Z0-9]{5}")))
36:         get_pathway <- GET(paste("http://rest.kegg.jp/get/map",substr(pathway,4,nchar(pathway)),sep = ""))
37:         get_pathway_text <- content(get_pathway, "text")
71:   repeated.pathways <- names(which(table(KEGG.data$KEGG_hsa) > 1))
10: DEGsToPathways <- function(geneList){
42:         path.index <- strsplit(path.index,split = " ")[[1]]
44:         path <- path[2]
59:         KEGG.data <- rbind(KEGG.data,c(as.character(path),as.character(name), as.character(description),as.character(class),as.character(gene.name)))
66:   names(KEGG.data) <- c("KEGG_Path","Name","Description","Class","Genes")
1: #' The function uses the DEGs to retrieves the different pathways in which those DEGs involve any interaction.
3: #' The function uses the DEGs to retrieves the different pathways in which those DEGs involve any interaction.
4: #' @param geneList A list which contains the DEGs that will be used to retrieve the related pathways to them.
5: #' @return A list with the pathways that contain relation to the DEGs within the geneList parameter.
18:   cat("Retrieving information about KEGG pathways...\n")
29:       pathways <- strsplit(pathways,split = "\n")
31:       index <- grep("hsa", unlist(pathways))
35:         if (length(pathway) == 0) break
39:         start <- str_locate_all(pattern = "ENTRY", get_pathway_text)[[1]][2]
40:         final <- str_locate_all(pattern = "Pathway", get_pathway_text)[[1]][2]
46:         start <- str_locate_all(pattern = "\nNAME ", get_pathway_text)[[1]][2]
47:         final <- str_locate_all(pattern = "\nDESCRIPTION", get_pathway_text)[[1]][2]
48:         name <- substr(get_pathway_text,start + 8,final - 12)
50:         start <- str_locate_all(pattern = "\nDESCRIPTION ", get_pathway_text)[[1]][2]
51:         final <- str_locate_all(pattern = "\nCLASS", get_pathway_text)[[1]][2]
52:         description <- substr(get_pathway_text,start + 1,final - 6)
55:         start <- str_locate_all(pattern = "\nCLASS ", get_pathway_text)[[1]][2]
56:         final <- str_locate_all(pattern = "\nPATHWAY_MAP", get_pathway_text)[[1]][2]
57:         class <- substr(get_pathway_text,start + 7,final - 12)
69:   # Collapse repeated pathways
72:   for (pathway in repeated.pathways){
73:     index <- which(KEGG.data$KEGG_hsa == pathway,)
85:   #cat("Retrieving information about Reactome pathways...\n")
7: #' DEGsToPathways(c("BRCA1","MLANA"))
cisPath:inst/extdata/D3/cisPathWeb.js: [ ]
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;
DMRforPairs:R/functions.R: [ ]
457:     path = "figures"
450:     dir.create(file.path(getwd(), experiment.name))
452:     dir.create(file.path(paste(getwd(), experiment.name, sep = "/"), 
456:     setwd(file.path(getwd(), experiment.name))
485:                 path = path)
487:             tested$Figure[cr] = paste("<a href=\"./", path, "/", 
490:             tested$Statistics[cr] = paste("<a href=\"./", path, "/", 
493:             write.table(file = paste("./", path, "/", tested$regionID[cr], 
507:                 scores = FALSE, path = path)
509:             tested$Figure[cr] = paste("<a href=\"./", path, "/", 
512:             tested$Statistics[cr] = paste("<a href=\"./", path, "/", 
519:             write.table(file = paste("./", path, "/", tested$regionID[cr], 
533:                 scores = FALSE, path = path)
539:             tested$Figure[cr] = paste("<a href=\"./", path, "/", 
542:             tested$Statistics[cr] = paste("<a href=\"./", path, "/", 
545:             write.table(file = paste("./", path, "/", tested$regionID[cr], 
606:             path, "/", tested_4html_selected$ID, ".png\" height=\"63\" width=\"125\">", 
624:             path, "/", tested_4html_selected$ID, ".png\" height=\"63\" width=\"125\">", 
639:     regionID, clr = NA, annotate = TRUE, scores = TRUE, path) {
642:     path = paste("./", path, "/", sep = "")
651:         clr = clr, annotate = annotate, scores = scores, path = path)
656:     annotate = TRUE, path) {
659:     path = paste("./", path, "/", sep = "")
673:             annotate = annotate, scores = TRUE, path = path)
679:     ID = "CustomRegion", clr = NA, annotate = TRUE, path) {
680:     path = paste("./", path, "/", sep = "")
693:             annotate = annotate, scores = TRUE, path = path)
699:     ID = NA, clr = NA, annotate = TRUE, scores = NA, path) {
730:     png(paste(path, ID, ".png", sep = ""), width = 500, height = 250)
750:     pdf(paste(path, ID, ".pdf", sep = ""), width = 10, height = 10)
ArrayExpress:R/parseMAGE.r: [ ]
516: 	path = mageFiles$path
30: isOneChannel = function(sdrf,path){
31: 	ph = try(read.AnnotatedDataFrame(sdrf, path = path, row.names = NULL, blank.lines.skip = TRUE, fill = TRUE, varMetadata.char = "$", quote="\""))
39: readPhenoData = function(sdrf,path){
42: 	ph = try(read.AnnotatedDataFrame(sdrf, path = path, row.names = NULL, blank.lines.skip = TRUE, fill = TRUE, varMetadata.char = "$", quote="\""))
105: readAEdata = function(path,files,dataCols,green.only){
108: 	source = getDataFormat(path,files)
121: 		rawdata = try(oligo::read.celfiles(filenames = file.path(path,unique(files))))
123: 			stop("Unable to read cel files in",path)
130: 			dataCols= try(getDataColsForAE1(path,files))
133: 		rawdata = try(read.maimages(files=files,path=path,source="generic",columns=dataCols,annotation=headers$ae1))
138: 		rawdata = try(read.maimages(files=files,path=path,source=source,columns=dataCols,green.only=green.only))
142: 		rawdata = try(read.maimages(files=files,path=path,source="generic",columns=dataCols,green.only=green.only))
149: 		stop("Unable to read data files in",path)
169: readFeatures<-function(adf,path,procADFref=NULL){
173: 	lines2skip = skipADFheader(adf,path,!is.null(procADFref))
174: 	features = try(read.table(file.path(path, adf), row.names = NULL, blank.lines.skip = TRUE, fill = TRUE, sep="\t", na.strings=c('?','NA'), sk...(40 bytes skipped)...
223: readExperimentData = function(idf, path){
224: 	idffile = scan(file.path(path,idf),character(),sep = "\n",encoding="UTF-8")
264: skipADFheader<-function(adf,path,proc=F){
270: 	con = file(file.path(path, adf), "r")	
319: getDataFormat=function(path,files){
326: 		allcnames = scan(file.path(path,files[1]),what = "",nlines = 200, sep = "\t",quiet=TRUE)
329: 			allcnames = scan(file.path(path,files[1]),what = "",nlines = 200, sep = "\t",quiet=TRUE,encoding="latin1")
345: 	allcnames = scan(file.path(path,files[1]),what = "",nlines = 1, sep = "\n",quiet=TRUE)
352: getDataColsForAE1 = function(path,files){
362: 						file.path(system.file("doc", package = "ArrayExpress"),"QT_list.txt"),
375: 	allcnames = scan(file.path(path,files[1]),what = "",nlines = 1, sep = "\t",quiet=TRUE)
430: 		if(!all(sapply(2:length(files), function(i) readLines(file.path(path,files[1]),1) == readLines(file.path(path,files[i]),1))))
518: 	try(file.remove(file.path(path, mageFiles$rawFiles)))
519: 	try(file.remove(file.path(path, mageFiles$processedFiles)))
521: 	try(file.remove(file.path(path, mageFiles$sdrf)))
522: 	try(file.remove(file.path(path, mageFiles$idf)))
523: 	try(file.remove(file.path(path, mageFiles$adf)))
524: 	try(file.remove(file.path(path, mageFiles$rawArchive)))
525: 	try(file.remove(file.path(path, mageFiles$processedArchive)))
methylPipe:R/Allfunctions.R: [ ]
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='')
TIN:R/correlationPlot.R: [ ]
104:     path<-getwd()
105:     cat("Plot was saved in ",paste(path,"/",fileName,sep=""),"\n")
flowGraph:R/04_flowgraph_plots.R: [ ]
1574:                         path <- paste0(
1536:             plot_path_ <- paste0(
2: #' @description Creates a cell hierarchy plot given a flowGraph object. If a path is not provided for \code{fg_plot} to save the plot, please use \code{plot_gr} to view plot given t...(28 bytes skipped)...
89: #' @param path A string indicating the path to where the function should save
104: #'  the plot by filling out the \code{path} parameter with a full path to the
117: #'    path=NULL) # set path to a full path to save plot as a PNG
142:     path=NULL, width=9, height=9
279:         if (!is.null(path) & !interactive)
281:                 grepl("[.]png$",path, ignore.case=TRUE),
282:                 path, paste0(path, ".png")),
285:         if (!is.null(path) & interactive & !visNet_plot)
287:                 gp, ifelse(grepl("[.]html$",path, ignore.case=TRUE),
288:                            path, paste0(path, ".html")))
289:         if (!is.null(path) & interactive & visNet_plot)
291:                 gp, file=ifelse(grepl("[.]html$",path, ignore.case=TRUE),
292:                                 path, paste0(path, ".html")),
295:     if (is.null(path)) message("use function plot_gr to plot fg_plot output")
407: #'    path=NULL) # set path to a full path to save plot as a PNG
719: #' @param path A string indicating the path to where the function should save
754:     main=NULL, interactive=FALSE, path=NULL
822:             if (!is.null(path))
824:                     qp, ifelse(grepl("[.]html$",path, ignore.case=TRUE),
825:                                path, paste0(path, ".html")))
829:         if (!is.null(path))
832:                     ifelse(grepl("[.]png$",path, ignore.case=TRUE),
833:                            path, paste0(path, ".png")),
903: #' @param path A string indicating the path to where the function should save
940:     main=NULL, path=NULL
1031:     if (!is.null(path))
1033:             ifelse(grepl("[.]png$",path, ignore.case=TRUE),
1034:                    path, paste0(path, ".png")),
1051:     main=NULL, path=NULL
1063:             main=main, path=path,
1202:     if (!is.null(path)) {
1205:                 "[.]png$",path, ignore.case=TRUE),
1206:                 path, paste0(path, ".png")),
1281: #' @param path A string indicating the path to where the function should save
1316:     main=NULL, interactive=FALSE, path=NULL
1386:         if (!is.null(path))
1389:                     "[.]png$",path, ignore.case=TRUE),
1390:                     path, paste0(path, ".png")), plot=gp)
1426:         if (!is.null(path))
1428:                 gp, ifelse(grepl("[.]html$", path, ignore.case=TRUE),
1429:                            path, paste0(path, ".html")))
1443: #' @param plot_path A string indicating the folder path to where the function
1520:     fg, plot_path, plot_types="node", interactive=FALSE,
1537:                 plot_path, "/", type, "/", paste0(sm, collapse="_"))
1538:             while (dir.exists(plot_path_) & !overwrite)
1539:                 plot_path_ <- paste0(plot_path_,"_")
1540:             dir.create(plot_path_, recursive=TRUE, showWarnings=FALSE)
1551:                     path=paste0(plot_path_, "/pVSdifference.png"))
1567:                     rdir_ <- paste0(plot_path_, "/boxplots")
1580:                             path=path, paired=paired,
1595:                     path=paste0(plot_path_,"/qq.png"),
1605:                         path=paste0(plot_path_,"/cell_hierarchy.png"),
1628:                             paste0(plot_path_,"/cell_hierarchy_",
RpsiXML:R/psi25parser.R: [ ]
165:   path <- paste(basePath, "/ns:experimentList/ns:experimentDescription", sep = "", collapse = "")
253:   path <- paste(basePath, "/ns:interactionList/ns:interaction", 
268:   path <- paste("/ns:interaction/ns:xref/ns:primaryRef[@db='",sourceDb,"']",sep="")
50: XMLvalueByPath <- function(doc, path, namespaces) {
55: nonNullXMLvalueByPath <- function(doc, path, namespaces) {
60: XMLattributeValueByPath <- function(doc, path, name, namespaces) {
65: nonNullXMLattributeValueByPath <- function(doc, path, name, namespaces) {
110: parseXmlAttributesListByPath <- function(doc,
164: getExperimentNodeSetPath <- function(basePath) {
170:   experimentPath <- getExperimentNodeSetPath(basePath)
252: getInteractionNodeSetPath <- function(basePath) {
259:   interactionPath <- getInteractionNodeSetPath(basePath)
267: getInteractionPubmedPath <- function(sourceDb) {
312:   rolePath <-  "/ns:interaction/ns:confidenceList/ns:confidence/ns:value"
487: getEntryBasePath <- function(index) {
488:   basePath <- paste("/ns:entrySet/ns:entry[", index, "]", sep = "", collapse = "")
492: getReleaseDatePath <- function(basePath) {
493:   releaseDatePath <- paste(basePath, "/ns:source", sep = "", collapse = "")
498:   releaseDatePath <- getReleaseDatePath(basePath)
505: getPrimaryInteractorPath <- function(basePath) {
506:   interactorPath <- paste(basePath, "/ns:interactorList/ns:interactor", 
512: getSecondaryInteractorPath <- function(basePath) {
513:   interactorPath <-  paste(basePath, "/ns:interactionList/ns:interaction/ns:participantList/ns:participant/ns:interactor",
519:   interactorPath <- getPrimaryInteractorPath(basePath)
576:   basePath <- getEntryBasePath(index)
674:   basePath <- getEntryBasePath(1)
51:   x <- unlist(xpathApply(doc=doc,path=path,fun=xmlValue, namespaces=namespaces))
56:   x <- XMLvalueByPath(doc=doc,path=path, namespaces=namespaces)
61:   x <- unlist(xpathApply(doc=doc,path=path,fun=xmlGetAttr, name=name, namespaces=namespaces))
66:   x <- XMLattributeValueByPath(doc=doc, path=path, name=name, namespaces=namespaces)
111:                                         path,
114:                                   path=path,
126:                                            path = "/ns:experimentDescription/ns:interactionDetectionMethod/ns:names/ns:shortLabel",
131:                                              path = "/ns:experimentDescription/ns:interactionDetectionMethod/ns:names/ns:fullName",
137:                                               path = "/ns:experimentDescription/ns:bibref/ns:xref/ns:primaryRef[@db='pubmed']", 
143:                                              path = paste("/ns:experimentDescription/ns:xref/ns:primaryRef[@db='",sourceDb,"']",sep=""),
149:                                                path = paste("ns:experimentList/ns:experimentDescription/ns:xref/ns:secondaryRef[@db='",
166:   return(path)
196:   sourceIds <- XMLattributeValueByPath(doc = subDoc, path = "/ns:interactor", 
199:                                        path="/ns:interactor/ns:names/ns:shortLabel",
203:                                           path="/ns:interactor/ns:names/ns:fullName",
208:                                          path = "/ns:interactor/ns:organism/ns:names/ns:fullName",
211:                                            path = "/ns:interactor/ns:organism",
216:                                             path = sprintf("/ns:interactor/ns:xref/ns:primaryRef[@db='%s']|/ns:interactor/ns:xref/ns:secondaryRef[@d...(39 bytes skipped)...
220:                                            path = "/ns:interactor/ns:xref/ns:primaryRef|/ns:interactor/ns:xref/ns:secondaryRef",
224:                                            path = "/ns:interactor/ns:xref/ns:primaryRef|/ns:interactor/ns:xref/ns:secondaryRef",
255:   return(path)
262:                                  path=interactionPath, 
269:   return(path)
281:                                               path = getInteractionPubmedPath(sourceDb),
284:                            path = "/ns:interaction/ns:experimentList/ns:experimentRef",
294:                                              path = "/ns:interaction/ns:experimentList/ns:experimentDescription/ns:interactionDetectionMethod/ns:name...(17 bytes skipped)...
298:                                                path = "/ns:interaction/ns:experimentList/ns:experimentDescription/ns:interactionDetectionMethod/ns:name...(15 bytes skipped)...
302:                                                  path = sprintf("/ns:interaction/ns:experimentList/ns:experimentDescription/ns:xref/ns:primaryRef[@db='%s...(14 bytes skipped)...
306:                                                 path = "/ns:interaction/ns:experimentList/ns:experimentDescription/ns:bibref/ns:xref/ns:primaryRef[@db='...(10 bytes skipped)...
313:   confidenceValue <- nonNullXMLvalueByPath(doc=subDoc,path = rolePath, namespaces=namespaces)
317:   participantRefs <- nonNullXMLvalueByPath(doc=subDoc, path=rolePath, namespaces=namespaces)
321:                                                       path=rolePath,
327:   baitRefs <- nonNullXMLvalueByPath(doc=subDoc, path = rolePath, namespaces=namespaces)
331:                                                path=rolePath,
337:   preyRefs <- nonNullXMLvalueByPath(doc=subDoc, path = rolePath, namespaces=namespaces)
341:                                                path=rolePath,
347:   inhibitorRefs <- nonNullXMLvalueByPath(doc=subDoc, path=rolePath, namespaces=namespaces)
351:   neutralComponentRefs <- nonNullXMLvalueByPath(doc=subDoc, path = rolePath, namespaces=namespaces)
418:                                                    path=paste("/ns:interaction/ns:xref/ns:primaryRef[@db='",sourcedb,"']",sep=""),
423:                                             path="/ns:interaction/ns:names/ns:shortLabel",
427:                                           path="/ns:interaction/ns:names/ns:fullName",
431:                                                path="/ns:interaction/ns:participantList/ns:participant/ns:interactorRef",
435:                                                  path="/ns:interaction/ns:attributeList/ns:attribute[@name]",
500:                                                 path = releaseDatePath, 
125:   interactionType <- nonNullXMLvalueByPath(doc = subDoc,
130:     interactionType <- nonNullXMLvalueByPath(doc = subDoc,
135:   ## it seems that xpathApply treats XPath in a case-insensitive way, to be confirmed
136:   expPubMed <- nonNullXMLattributeValueByPath(doc = subDoc,
142:   sourceId <- nonNullXMLattributeValueByPath(doc = subDoc,
148:     sourceId <- nonNullXMLattributeValueByPath(doc = subDoc,
169: getXmlExperimentNodeSet <- function(doc, basePath, namespaces) {
171:   experimentNodes <- getNodeSet(doc, experimentPath, namespaces)
198:   shortLabels <- nonNullXMLvalueByPath(doc = subDoc,
202:     shortLabels <- nonNullXMLvalueByPath(doc = subDoc,
207:   organismNames <- nonNullXMLvalueByPath(doc = subDoc,
210:   taxIds <- nonNullXMLattributeValueByPath(doc = subDoc,
215:   uniprot <- nonNullXMLattributeValueByPath(doc = subDoc,
219:   xrefDb <- XMLattributeValueByPath(doc = subDoc,
223:   xrefId <- XMLattributeValueByPath(doc = subDoc,
258: getInteractionNodeSet <- function(doc, basePath, namespaces) {
280:   psimi25Id <- nonNullXMLattributeValueByPath(doc = subDoc,
283:   expRef <- XMLvalueByPath(doc = subDoc,
293:     interactionType <- nonNullXMLvalueByPath(doc = subDoc,
297:       interactionType <- nonNullXMLvalueByPath(doc = subDoc,
301:     expPsimi25 <- nonNullXMLattributeValueByPath(doc = subDoc,
305:     expPubMed <- nonNullXMLattributeValueByPath(doc = subDoc,
316:   rolePath <- "/ns:interaction/ns:participantList/ns:participant/ns:interactorRef"
319:     rolePath <- "/ns:interaction/ns:participantList/ns:participant/ns:interactor"
320:     participantRefs <- nonNullXMLattributeValueByPath(doc=subDoc,
326:   rolePath <- "/ns:interaction/ns:participantList/ns:participant[ns:experimentalRoleList/ns:experimentalRole/n...(45 bytes skipped)...
329:     rolePath <- "/ns:interaction/ns:participantList/ns:participant[ns:experimentalRoleList/ns:experimentalRole/n...(42 bytes skipped)...
330:     baitRefs <- nonNullXMLattributeValueByPath(doc=subDoc,
336:   rolePath <- "/ns:interaction/ns:participantList/ns:participant[ns:experimentalRoleList/ns:experimentalRole/n...(45 bytes skipped)...
339:     rolePath <- "/ns:interaction/ns:participantList/ns:participant[ns:experimentalRoleList/ns:experimentalRole/n...(42 bytes skipped)...
340:     preyRefs <- nonNullXMLattributeValueByPath(doc=subDoc,
346:   rolePath <- "/ns:interaction/ns:participantList/ns:participant[ns:experimentalRoleList/ns:experimentalRole/n...(50 bytes skipped)...
350:   rolePath <- "/ns:interaction/ns:participantList/ns:participant[ns:experimentalRoleList/ns:experimentalRole/n...(58 bytes skipped)...
417:   sourceId <- as.character(XMLattributeValueByPath(doc=subDoc,
422:   shortLabel <- as.character(XMLvalueByPath(doc=subDoc,
426:   fullName <- as.character(XMLvalueByPath(doc=subDoc,
430:   interactorRef <- as.character(XMLvalueByPath(doc=subDoc,
434:   attributesList <- parseXmlAttributesListByPath(doc=subDoc,
489:   return(basePath)
494:   return(releaseDatePath)
497: parseReleaseDate <- function(doc, basePath, namespaces) {
499:   releaseDate <- nonNullXMLattributeValueByPath(doc = doc,
508:   return(interactorPath)
515:   return(interactorPath)
518: getInteractorNodeSet <- function(doc, basePath, namespaces) {
520:   interactorNodes <- getNodeSet(doc, interactorPath, namespaces)
522:     interactorPath <- getSecondaryInteractorPath(basePath)
523:     interactorNodes <- getNodeSet(doc, interactorPath, 
558:                                      basePath,
563:                                           basePath=basePath,
580:   experimentNodes <- getXmlExperimentNodeSet(doc=doc, basePath=basePath,
587:                                              basePath=basePath,
592:                                           basePath=basePath,
606:                                             basePath=basePath,
677:                                   basePath=basePath,
681:                                           basePath=basePath,
biocViews:R/repository.R: [ ]
14:         path <- packagesPaths[[type]]
181:     DESCRIPTION_path <- file.path(tmp_pkgdir, "DESCRIPTION")
182:     CITATION_path <- file.path(tmp_pkgdir, "inst", "CITATION")
183:     paths <- c(DESCRIPTION_path, CITATION_path)
193:     DESCRIPTION_tpath <- paste0(pkgname, "/DESCRIPTION")
194:     CITATION_tpath <- paste0(pkgname, "/inst/CITATION")
648:         cPath <- reposInfo[, ctype]
649:         buildPkgPath <- function(pkgs, vers) {
898:     cssPath <- system.file(file.path("css", paste(cssName, ".in", sep="")),
917:     cssPath <- system.file(file.path("css", paste(cssName, ".in", sep="")),
11:     packagesPaths <- file.path(reposRoot, contribPaths)
195:     tpaths <- c(DESCRIPTION_tpath, CITATION_tpath)
20:         message("- write_PACKAGES() to ", path, " ... ", appendLF=FALSE)
21:         t <- system.time(write_PACKAGES(path, type=type))[["elapsed"]]
55:     pkgDir <- file.path(unpackDir, pkg, subDir)
65:     ## reposRoot - Top level path for CRAN-style repos
75:         destDir <- file.path(reposRoot, "manuals")
88:             pkgDir <- file.path(unpackDir, pkg, "man")
89:             RCmd <- file.path(Sys.getenv("R_HOME"), "bin", "R")
104:     tarballs <- list.files(file.path(reposRoot, srcContrib),
130:         refmanDir <- file.path(reposRootPath, refman.dir, pkg, refmanSubDir)
147:         unpack(tarball, unpackDir, file.path(pkg, fileName))
150:     tarballs <- list.files(file.path(reposRoot, srcContrib),
180:     tmp_pkgdir <- file.path(tmpdir, pkgname)
191:     ## Note that the path separator is **always** / in a tarball, even
192:     ## on Windows, so do NOT use file.path() here.
210:     if (!file.exists(DESCRIPTION_path))  # should never happen
216:     if (file.exists(CITATION_path)) {
218:         citation <- try(readCitationFile(CITATION_path, meta=description),
233:     destfile <- file.path(destdir, "citation.html")
280:         file.path(reposRoot, srcContrib),
292:         .write_citation_as_HTML(pkgname, citation, file.path(destDir, pkgname))
300:     ## reposRoot - Top level path for CRAN-style repos
314:       destDir <- file.path(reposRoot, "news")
324:         srcDir <- file.path(srcDir, pkg)
325:         destDir <- file.path(destDir, pkg)
328:         destFile <- file.path(destDir, "NEWS")
332:     tarballs <- list.files(file.path(reposRoot, srcContrib),
354:     ## reposRoot - Top level path for CRAN-style repos
364:         destDir <- file.path(reposRoot, "vignettes")
367:         cleanUnpackDir(tarball, unpackDir, subDir=file.path("inst", "doc"))
374:     tarballs <- list.files(file.path(reposRoot, srcContrib),
388:     ## reposRoot - Top level path for CRAN-style repos
398:       destDir <- file.path(reposRoot, "vignettes")
420:     tarballs <- list.files(file.path(reposRoot, srcContrib),
444:         filedir <- file.path(reposRootPath, dir, pkg)
445:         file <- file.path(filedir, filename)
458:         vigDir <- file.path(reposRootPath, vignette.dir, pkg, vigSubDir)
481:             files <- file.path(reposRootPath, files)
535:     fn <- file.path(reposRootPath, "REPOSITORY")
541:     reposInfo <- read.dcf(file.path(reposRootPath, "REPOSITORY"))
562:     out <- file(file.path(dir, fname), "wt")
564:     ##outgz <- gzfile(file.path(dir, gzname), "wt")
601:     ## Read REPOSITORY file for contrib path info
612:         pkg.dir <- file.path(reposRootPath, reposInfo[, os])
641:     ## Integrate version and archive file path info for the different contrib
642:     ## paths in this repos.  We duplicate the source path info here, but that
659:         packagesFile <- file.path(reposRootPath, cPath, "PACKAGES")
662:                     file.path(reposRootPath, cPath),
663:                     "\nSkipping this contrib path.")
674:                     file.path(reposRootPath, cPath),
675:                     "\nSkipping this contrib path.")
691:     ## Add vignette path info
782:                    desc <- tools:::.read_description(file.path(meatPath, missing_pkgs[i], "DESCRIPTION"))
857:     viewsFile <- file.path(reposRoot, "VIEWS")
892:     writePackageDetailHtml(pkgList, file.path(reposRoot, "html"),
900:     res <- try(copySubstitute(cssPath, file.path(reposRoot, cssName),
911:         f <- file.path(htmlDir, htmlFilename(pkg))
919:     res <- try(copySubstitute(cssPath, file.path(htmlDir, cssName),
934:     f <- file.path(reposRoot, htmlFilename(repos))
939:     con <- file(file.path(dir, "SYMBOLS"), open="w")
963:         tarballs <- list.files(file.path(dir, "src/contrib"),
1: genReposControlFiles <- function(reposRoot, contribPaths, manifestFile=NA, meatPath=NA)
10:     ## Write PACKAGES files for all contrib paths
28:             write_VIEWS(reposRoot, manifestFile=manifestFile, meatPath=meatPath)
127: getRefmanLinks <- function(pkgList, reposRootPath, refman.dir) {
184:     status <- unlink(paths)
441: getFileExistsAttr <- function(pkgList, reposRootPath, dir, filename) {
452: getFileLinks <- function(pkgList, reposRootPath, vignette.dir, ext,
472: getDocumentTitles <- function(docs, ext="pdf", src=c("Rnw", "Rmd"), reposRootPath, fun) {
530: write_REPOSITORY <- function(reposRootPath, contribPaths)
539: read_REPOSITORY <- function(reposRootPath)
585: ##   meatPath <- "~biocbuild/bbs-3.14-bioc/MEAT0"
587: ##   write_VIEWS(reposRoot, manifestFile=manifestFile, meatPath=meatPath)
588: write_VIEWS <- function(reposRootPath, fields = NULL,
590:                         manifestFile=NA, meatPath=NA
602:     reposInfo <- read_REPOSITORY(reposRootPath)
609:     convertToMat <- function(reposRootPath, reposInfo, os, fields, verbose){
628:     dbMat = convertToMat(reposRootPath, reposInfo, os, fields, verbose)
632:             dbMat2 = convertToMat(reposRootPath, reposInfo, os, fields, verbose)
657:             paste(cPath, "/", pkgs, "_", vers, ext, sep="")
682:         dbMat[dbMatIdx, col] <- buildPkgPath(cDat[cDatGood, "Package"],
692:     vigs <- getFileLinks(dbMat[, "Package"], reposRootPath, vignette.dir, "pdf")
693:     vtitles <- getDocumentTitles(vigs, reposRootPath=reposRootPath, fun=getPdfTitle)
695:     rfiles <- getFileLinks(dbMat[, "Package"], reposRootPath, vignette.dir, "R")
697:     htmlDocs <- getFileLinks(dbMat[, "Package"], reposRootPath, vignette.dir, "html", TRUE)
699:     htmlTitles <- getDocumentTitles(htmlDocs, ext="html", src=c("Rmd", "Rhtml"), reposRootPath, getHtmlTitle)
716:     readmes <- getFileExistsAttr(dbMat[, "Package"], reposRootPath, "readmes", "README")
717:     news <- getFileExistsAttr(dbMat[, "Package"], reposRootPath, "news", "NEWS")
718:     install <- getFileExistsAttr(dbMat[, "Package"], reposRootPath, "install", "INSTALL")
719:     license <- getFileExistsAttr(dbMat[, "Package"], reposRootPath, "licenses",
779:             if (!is.na(meatPath)){
822:     .write_repository_db(dbMat, reposRootPath, "VIEWS")
8:     t <- system.time(write_REPOSITORY(reposRoot, contribPaths))[["elapsed"]]
12:     names(packagesPaths) <- names(contribPaths)
13:     for (type in names(packagesPaths)) {
196:     status <- untar(tarball, tpaths, exdir=tmpdir)
523:         res <- xpathApply(doc, "//title", xmlValue)
532:     contrib <- as.list(contribPaths)
533:     names(contrib) <- gsub("-", ".", names(contribPaths))
534:     contrib[["provides"]] <- paste(names(contribPaths), collapse=", ")
MOGAMUN:R/MOGAMUN_FUN.R: [ ]
1232:     for (Path in Dirs) {
1233:         PathForPlots <- ExperimentsPath <- paste0(Path, "/") # path for plots
1659:     GeneralPath <- ExperimentDir
1666:         ExpPath <- paste0(GeneralPath, "/", d, "/")
1289:     # get all files in the path that match the pattern
1763: #         ExperimentsPath - path to the results
1234:         Population <- GetIndividualsAllRuns(ExperimentsPath) # get results
1249:             SimilarityBetweenRunsBoxplot(PathForPlots, Nodes1stRank_AllRuns)
1253:         AccPF <- ObtainAccParetoFront(PathForPlots, Inds1stRank_AllRuns, 
1258:         FilterNetworks(ExperimentsPath, LoadedData, AccPF) 
1265:         SaveFilteredAccPF(DiversePopulation, ExperimentsPath, Threshold) 
1278: # INPUT:  ExperimentsPath - folder containing the results to be processed 
1280: GetIndividualsAllRuns <- function(ExperimentsPath) {
1290:     ResFiles <- list.files(ExperimentsPath, pattern = PatResFiles)
1295:         con <- base::file(paste0(ExperimentsPath, ResFiles[counter]), open="r")
1328: # INPUTS: PathForPlots - folder to save the plot
1331: SimilarityBetweenRunsBoxplot <- function(PathForPlots, Nodes1stRank_AllRuns) {
1362:     svg(paste0(PathForPlots, "A_Boxplot_similarities_between_runs.svg"))
1372: # INPUTS: PathForPlots - folder to save the plot
1378: ObtainAccParetoFront <- function(PathForPlots, Inds1stRank_AllRuns, 
1389:         svg(paste0(PathForPlots, "A_ScatterPlot_AccPF_ALL_INDS.svg"))
1397:         svg(paste0(PathForPlots, "A_ScatterPlot_AccPF_LEGEND_ALL_INDS.svg"))
1409:     svg(paste0(PathForPlots, "A_ScatterPlot_AccPF.svg"))
1466: # INPUTS: ExperimentsPath - folder to save the filtered networks
1471: FilterNetworks <- function(ExperimentsPath, LoadedData, AccPF) {
1495:         write.table(MyFilteredNetwork, file = paste0(ExperimentsPath, 
1501:     myDataFiles <- list.files(ExperimentsPath, pattern = '_FILTERED.csv')
1508:         data <- read.table(paste0(ExperimentsPath, myDataFiles[i]), 
1516:     write.table(myFullListOfInteractions, file = paste0(ExperimentsPath, 
1614: #         ExperimentsPath - folder to save the filtered networks
1617: SaveFilteredAccPF <- function(DiversePopulation, ExperimentsPath, Threshold) {
1621:         write(paste(Ind, collapse=" ", sep=""), file = paste0(ExperimentsPath, 
1643:     write.csv(AllNodesDF_Acc, paste0(ExperimentsPath, 
1662:     Dirs <- list.dirs(GeneralPath, recursive = FALSE, full.names = FALSE)
1669:         Network <- read.csv( paste0(ExpPath, 
1698:         CreateActiveModules(d, ExpPath)
1703:                 filename = paste0(ExpPath, "A_Acc_PF_", d))
1704:         } else { saveSession(filename = paste0(ExpPath, "A_Acc_PF_", d)) }
1765: CreateActiveModules <- function(d, ExperimentsPath) {
1772:         read.csv(paste0(ExperimentsPath, list.files(ExperimentsPath,
1799: MogamunBody <- function(RunNumber, LoadedData, BestIndsPath) {
1800:     BestIndsFile <- paste0(BestIndsPath, "_Run_", RunNumber, ".txt")
1829:         file = paste0(BestIndsPath,"StatisticsPerGeneration_Run", RunNumber, 
CONFESS:R/internal_fluo_NBE.R: [ ]
1419:     path <- c(data$UpdatedPath, data$UpdatedPath[1])
2092:   path <- do.call(rbind, res)[, 1]
1493:     path.update <- path[1:(length(path) - 1)]
2432: path.initiator <- function(data, where) {
1381: fixPath <- function(data, groups) {
2060: estimatePath <- function(data, type, start) {
2116: pathUpdater <- function(data, path) {
2246: updateCentroidsPaths <- function(data, estimates, path.type) {
1370: #' It tests whether the path has been appropariately defined and produces an error if not.
1383:     stop("Insert the cell progression path using the labels of Fluo_inspection")
1387:       "Error in cell progression path: you have specified different number of groups than the one estimated"
1396: #' It sort the adjusted (and transfomed) fluorescence signals according to the path progression.
1399: #' @param path.start Integer. A cluster number indicating the starting cluster that algorithm should use to
1400: #'   build the path. The cluster numbers refer to the plot generated by Fluo_inspection(). Default is 1.
1401: #'   If path.type = "circular" the number does not matter. If path.type = "A2Z" the user should inspect the
1402: #'   Fluo_inspection() plot to detect the beginning of the path. If path.type = "other", the function will
1403: #'   not estimate a path. The user has to manually insert the path progression (the cluster numbers) in
1414: orderFluo <- function(data, path.type, updater = FALSE) {
1415:   if (path.type[1] != "circular" & path.type[1] != "A2Z") {
1416:     stop("The path.type is not correctly specified")
1424:     path <- c(1:max(data$Updated.groups), 1)
1435:   for (i in 1:(length(path) - 1)) {
1436:     center1 <- as.numeric(ms[which(ms[, 1] == path[i]), 2:3])
1437:     center2 <- as.numeric(ms[which(ms[, 1] == path[(i + 1)]), 2:3])
1438:     ww <- which(groups == path[(i + 1)])
1462:   for (i in 1:(length(path) - 1)) {
1464:       as.numeric(ms[which(ms[, 1] == path[(length(path) - i + 1)]), 2:3])
1466:       as.numeric(ms[which(ms[, 1] == path[(length(path) - i)]), 2:3])
1467:     ww <- which(groups == path[(length(path) - i)])
1492:   if (path.type[1] == "A2Z") {
1494:     ww <- which(as.numeric(all[, 4]) == path.update[1])
1497:       which(as.numeric(all[, 4]) == path.update[length(path.update)])
1505:   wh <- which(mydata[, 4] == path[length(path)])
1611: #' @param path.type Character vector. A user-defined vector that characterizes the cell progression dynamics.
1612: #'   The first element can be either "circular" or "A2Z" or "other". If "circular" the path progression is
1613: #'   assummed to exhibit a circle-like behavior. If "A2Z" the path is assumed to have a well-defined start
1629:                     path.type,
1643:                          path.type = path.type)
1644:   if (path.type[1] != "other") {
1657:                            path.type = path.type)
2027: #'   It can be either "clockwise" or "anticlockwise" depending on how the path is expected
2049: #' The main function for automatic path estimation .
2053: #'   It can be either "clockwise" or "anticlockwise" depending on how the path is expected
2055: #' @param start Integer. The cluster number that is assigned as the path starting point
2057: #' @return The sorted cluster indices (path)
2093:   path <- rep(path, 2)
2094:   if (length(which(path == start)) == 0) {
2097:   if (start != path[1]) {
2098:     w <- which(path == start)
2099:     path <- path[w[1]:(w[2] - 1)]
2101:     path <- path[1:(length(path) / 2)]
2103:   return(path)
2108: #' A helper that updates the path sorted clusters after re-estimation by change-point analysis.
2110: #' @param data Data matrix. A matrix of centroids with their path progression indices.
2111: #' @param path Numeric vector. The path progression indices.
2113: #' @return The sorted cluster indices (path)
2118:   for (i in 1:length(path)) {
2120:       matrix(rbind(res, data[which(data[, 4] == path[i]),]), ncol = ncol(res))
2142: #' @return The sorted transformed signal differences (path) and the associated change-points
2231: #' It updates the path sorted clusters after re-estimation by change-point analysis.
2236: #' @param path.type Character vector. A user-defined vector that characterizes the cell progression dynamics.
2237: #'   The first element can be either "circular" or "A2Z" or "other". If "circular" the path progression is
2238: #'   assummed to exhibit a circle-like behavior. If "A2Z" the path is assumed to have a well-defined start
2242: #' @return A list of adjusted fluorescence signals and the updated path after the change-point analysis
2258:   if (path.type[1] != "other" & length(estimates[[2]]) > 0) {
2268:       estimatePath(trigs, type = path.type[2], start =
2271:       pathUpdater(data = estimates[[1]], path = data$UpdatedPath)
2421: #' path.initiator
2423: #' It finds the cluster that initiates the progression path.
2427: #'   the starting point of the progression path.
2429: #' @return A starting point for the progression path
2455:     stop("Invalid starting point. Revise init.path parameter!")
2539: ...(7 bytes skipped)...stimates the average difference between the original and the CV estimated pseudotimes. For circular path
2541: #'   maximum pseudotime is 300) in a circular path, two pseudotimes 1 and 300 differ only by 1 and not by 299.
2544: #' @param path.type Character. The input of path.type parameter in pathEstimator().
2552: aveDiff <- function(data, path.type, maxPseudo) {
2553:   if (path.type != "circular") {
2557:   if (path.type == "circular") {
1368: #' FixPath
1390:   return(c(data, list(UpdatedPath = groups)))
1563:   nn <- data$UpdatedPath
2047: #' estimatePath
2106: #' pathUpdater
2267:     data$UpdatedPath <-
1641:     updateCentroidsPaths(data = data,
1655:       updateCentroidsPaths(data = res1[[1]],
2229: #' updateCentroidsPaths
Director:inst/www/js/d3.v3.js: [ ]
4199:   d3.geo.path = function() {
4201:     function path(object) {
6082:   function d3_layout_bundlePath(link) {
3936:   var d3_geo_pathAreaSum, d3_geo_pathAreaPolygon, d3_geo_pathArea = {
3963:   var d3_geo_pathBoundsX0, d3_geo_pathBoundsY0, d3_geo_pathBoundsX1, d3_geo_pathBoundsY1;
3971:   function d3_geo_pathBoundsPoint(x, y) {
4022:   function d3_geo_pathBufferCircle(radius) {
4038:   function d3_geo_pathCentroidPoint(x, y) {
4057:   function d3_geo_pathCentroidLineEnd() {
4246:   function d3_geo_pathProjectStream(project) {
4209:     path.area = function(object) {
4214:     path.centroid = function(object) {
4219:     path.bounds = function(object) {
4224:     path.projection = function(_) {
4229:     path.context = function(_) {
4235:     path.pointRadius = function(_) {
4238:       return path;
4242:       return path;
4244:     return path.projection(d3.geo.albersUsa()).context(null);
7979:       var rc, cr, rp, ap, p0 = 0, p1 = 0, x0, y0, x1, y1, x2, y2, x3, y3, path = [];
8027:             path.push("M", t30[0], "A", rc1, ",", rc1, " 0 0,", cr, " ", t30[1], "A", r1, ",", r1, " 0 ", 1 - cw ^ d...(128 bytes skipped)...
8029:             path.push("M", t30[0], "A", rc1, ",", rc1, " 0 1,", cr, " ", t12[0]);
8032:           path.push("M", x0, ",", y0);
8037:             path.push("L", t21[0], "A", rc0, ",", rc0, " 0 0,", cr, " ", t21[1], "A", r0, ",", r0, " 0 ", cw ^ d3_sv...(128 bytes skipped)...
8039:             path.push("L", t21[0], "A", rc0, ",", rc0, " 0 0,", cr, " ", t03[0]);
8042:           path.push("L", x2, ",", y2);
8045:         path.push("M", x0, ",", y0);
8046:         if (x1 != null) path.push("A", r1, ",", r1, " 0 ", l1, ",", cw, " ", x1, ",", y1);
8047:         path.push("L", x2, ",", y2);
8048:         if (x3 != null) path.push("A", r0, ",", r0, " 0 ", l0, ",", 1 - cw, " ", x3, ",", y3);
8050:       path.push("Z");
8051:       return path.join("");
8195:     var i = 0, n = points.length, p = points[0], path = [ p[0], ",", p[1] ];
8196:     while (++i < n) path.push("H", (p[0] + (p = points[i])[0]) / 2, "V", p[1]);
8197:     if (n > 1) path.push("H", p[0]);
8198:     return path.join("");
8201:     var i = 0, n = points.length, p = points[0], path = [ p[0], ",", p[1] ];
8202:     while (++i < n) path.push("V", (p = points[i])[1], "H", p[0]);
8203:     return path.join("");
8206:     var i = 0, n = points.length, p = points[0], path = [ p[0], ",", p[1] ];
8207:     while (++i < n) path.push("H", (p = points[i])[0], "V", p[1]);
8208:     return path.join("");
8224:     var quad = points.length != tangents.length, path = "", p0 = points[0], p = points[1], t0 = tangents[0], t = t0, pi = 1;
8226:       path += "Q" + (p[0] - t0[0] * 2 / 3) + "," + (p[1] - t0[1] * 2 / 3) + "," + p[0] + "," + p[1];
8234:       path += "C" + (p0[0] + t0[0]) + "," + (p0[1] + t0[1]) + "," + (p[0] - t[0]) + "," + (p[1] - t[1]) + "," ...(20 bytes skipped)...
8238:         path += "S" + (p[0] - t[0]) + "," + (p[1] - t[1]) + "," + p[0] + "," + p[1];
8243:       path += "Q" + (p[0] + t[0] * 2 / 3) + "," + (p[1] + t[1] * 2 / 3) + "," + lp[0] + "," + lp[1];
8245:     return path;
8259: ...(44 bytes skipped)...s[0], x0 = pi[0], y0 = pi[1], px = [ x0, x0, x0, (pi = points[1])[0] ], py = [ y0, y0, y0, pi[1] ], path = [ x0, ",", y0, "L", d3_svg_lineDot4(d3_svg_lineBasisBezier3, px), ",", d3_svg_lineDot4(d3_svg_lin...(21 bytes skipped)...
8267:       d3_svg_lineBasisBezier(path, px, py);
8270:     path.push("L", pi);
8271:     return path.join("");
8275:     var path = [], i = -1, n = points.length, pi, px = [ 0 ], py = [ 0 ];
8281:     path.push(d3_svg_lineDot4(d3_svg_lineBasisBezier3, px) + "," + d3_svg_lineDot4(d3_svg_lineBasisBezier3, ...(5 bytes skipped)...
8289:       d3_svg_lineBasisBezier(path, px, py);
8291:     return path.join("");
8294:     var path, i = -1, n = points.length, m = n + 4, pi, px = [], py = [];
8300:     path = [ d3_svg_lineDot4(d3_svg_lineBasisBezier3, px), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, py)...(3 bytes skipped)...
8308:       d3_svg_lineBasisBezier(path, px, py);
8310:     return path.join("");
8329:   function d3_svg_lineBasisBezier(path, x, y) {
8330:     path.push("C", d3_svg_lineDot4(d3_svg_lineBasisBezier1, x), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier1...(206 bytes skipped)...
8987:         var range = d3_scaleRange(scale1), path = g.selectAll(".domain").data([ 0 ]), pathUpdate = (path.enter().append("path").attr("class", "domain"), 
8988:         d3.transition(path));
3941:       d3_geo_pathAreaPolygon = 0;
3942:       d3_geo_pathArea.lineStart = d3_geo_pathAreaRingStart;
3945:       d3_geo_pathArea.lineStart = d3_geo_pathArea.lineEnd = d3_geo_pathArea.point = d3_noop;
3946:       d3_geo_pathAreaSum += abs(d3_geo_pathAreaPolygon / 2);
3949:   function d3_geo_pathAreaRingStart() {
3951:     d3_geo_pathArea.point = function(x, y) {
3952:       d3_geo_pathArea.point = nextPoint;
3956:       d3_geo_pathAreaPolygon += y0 * x - x0 * y;
3959:     d3_geo_pathArea.lineEnd = function() {
3964:   var d3_geo_pathBounds = {
3965:     point: d3_geo_pathBoundsPoint,
3972:     if (x < d3_geo_pathBoundsX0) d3_geo_pathBoundsX0 = x;
3973:     if (x > d3_geo_pathBoundsX1) d3_geo_pathBoundsX1 = x;
3974:     if (y < d3_geo_pathBoundsY0) d3_geo_pathBoundsY0 = y;
3975:     if (y > d3_geo_pathBoundsY1) d3_geo_pathBoundsY1 = y;
3977:   function d3_geo_pathBuffer() {
3978:     var pointCircle = d3_geo_pathBufferCircle(4.5), buffer = [];
3993:         pointCircle = d3_geo_pathBufferCircle(_);
4025:   var d3_geo_pathCentroid = {
4026:     point: d3_geo_pathCentroidPoint,
4027:     lineStart: d3_geo_pathCentroidLineStart,
4028:     lineEnd: d3_geo_pathCentroidLineEnd,
4030:       d3_geo_pathCentroid.lineStart = d3_geo_pathCentroidRingStart;
4033:       d3_geo_pathCentroid.point = d3_geo_pathCentroidPoint;
4034:       d3_geo_pathCentroid.lineStart = d3_geo_pathCentroidLineStart;
4035:       d3_geo_pathCentroid.lineEnd = d3_geo_pathCentroidLineEnd;
4043:   function d3_geo_pathCentroidLineStart() {
4045:     d3_geo_pathCentroid.point = function(x, y) {
4046:       d3_geo_pathCentroid.point = nextPoint;
4047:       d3_geo_pathCentroidPoint(x0 = x, y0 = y);
4054:       d3_geo_pathCentroidPoint(x0 = x, y0 = y);
4058:     d3_geo_pathCentroid.point = d3_geo_pathCentroidPoint;
4060:   function d3_geo_pathCentroidRingStart() {
4062:     d3_geo_pathCentroid.point = function(x, y) {
4063:       d3_geo_pathCentroid.point = nextPoint;
4064:       d3_geo_pathCentroidPoint(x00 = x0 = x, y00 = y0 = y);
4075:       d3_geo_pathCentroidPoint(x0 = x, y0 = y);
4077:     d3_geo_pathCentroid.lineEnd = function() {
4081:   function d3_geo_pathContext(context) {
4117:       context.closePath();
4210:       d3_geo_pathAreaSum = 0;
4211:       d3.geo.stream(object, projectStream(d3_geo_pathArea));
4212:       return d3_geo_pathAreaSum;
4216:       d3.geo.stream(object, projectStream(d3_geo_pathCentroid));
4220:       d3_geo_pathBoundsX1 = d3_geo_pathBoundsY1 = -(d3_geo_pathBoundsX0 = d3_geo_pathBoundsY0 = Infinity);
4221:       d3.geo.stream(object, projectStream(d3_geo_pathBounds));
4222:       return [ [ d3_geo_pathBoundsX0, d3_geo_pathBoundsY0 ], [ d3_geo_pathBoundsX1, d3_geo_pathBoundsY1 ] ];
4226:       projectStream = (projection = _) ? _.stream || d3_geo_pathProjectStream(_) : d3_identity;
4231:       contextStream = (context = _) == null ? new d3_geo_pathBuffer() : new d3_geo_pathContext(_);
6077:       var paths = [], i = -1, n = links.length;
6078:       while (++i < n) paths.push(d3_layout_bundlePath(links[i]));
6079:       return paths;
8995:           pathUpdate.attr("d", "M" + range[0] + "," + sign * outerTickSize + "V0H" + range[1] + "V" + sign * outer...(10 bytes skipped)...
8999:           pathUpdate.attr("d", "M" + sign * outerTickSize + "," + range[0] + "H0V" + range[1] + "H" + sign * outer...(10 bytes skipped)...
hca:R/lol.R: [ ]
132:     path <- ls(x, all.names = FALSE)
208:     path <- lol_path(x)
290:     path <- lol_path(x)
272: lol_path <- function(x) x[["path"]]
172:     paths <- lol_path(x)
1: .lol_visit_impl <- function(x, path, index, dict)
5: .lol_visit_impl.default <- function(x, path, index, dict) {
6:     dict[[path]] <- append(dict[[path]], list(index))
7:     attr(dict[[path]], "leaf") <- TRUE
15: .lol_visit_impl.list <- function(x, path, index, dict) {
18:     dict[[path]] <- append(dict[[path]], list(index))
19:     attr(dict[[path]], "leaf") <- FALSE
29:     ## logic for building out path names
30:     ## starting with current node of the nested list and extending the path by
32:     if (identical(path, ".")) {
33:         path <- nms
36:             path <- paste0(path, nms)
38:             path <- paste0(path, ".", nms)
44:         .lol_visit_impl(x[[i]], path[[i]], append(index, i), dict)
48:     function(lol, dict, path = .lol_path(dict), class = "lol")
53:         list(lol = lol, dict = dict, path = path),
75: #'     path, number of occurrences, and leaf status of each unique
76: #'     path.
129: .lol_path <-
133:     is_leaf <- .lol_is_leaf(x)[path]
135:         path = path,
136:         n = unname(.lol_lengths(x)[path]),
139:     arrange(tbl, .data$path)
142: .lol_valid_path <-
143:     function(x, path)
145:     ok <- .is_character_0(path) || path %in% lol_path(x)$path
146:     ok || stop("'path' not in 'x':\n", "  path: '", path, "'")
153: #' @param path character(1) from the tibble returned by `lol_path(x)`.
156: #'     to contain just the elements matching `path` as 'top-level'
164:     function(x, path = character())
168:         .is_character_0(path) || .is_scalar_character(path),
169:         .lol_valid_path(x, path)
173:     idx <- paths$path[startsWith(paths$path, path)]
174:     paths <- paths[paths$path %in% idx,]
175:     dict <-  .lol_dict(x)[paths$path]
190: #'     of rows in `lol_path()`.
209:     ## FIXME: don't allow filtering on 'path$path'
210:     path <- filter(path, ...)
211:     dict <- .lol_dict(x)[path$path]
213:     .lol(.lol_lol(x), dict, path, class(x))
219: #'     corresponding to a single `path`.
222: #'     corresponds to an element found at `path` in the list-of-lists
227:     function(x, path)
231:         .is_scalar_character(path),
232:         .lol_valid_path(x, path)
235:     value <- lapply(.lol_dict(x)[[path]], function(idx) lol[[idx]])
236:     names(value) <-  rep(path, length(value))
257:     function(x, path)
259:     value <- lol_lpull(x, path)
265: #' @description `lol_path()` returns a tibble representing the paths
269: #' plol |> lol_path()
293:         "# number of distinct paths: ", NROW(path), "\n",
297:         "# lol_path():\n",
300:     print(path, ...)
17:     ## building out the various paths
67: #'     individual paths from across the list-of-lists.
74: #'     paths through the list, as well as a tibble summarizing the
177:     .lol(.lol_lol(x), dict, paths, class(x))
183: #' @description `lol_filter()` filters available paths based on
295:         "# number of leaf paths: ", sum(is_leaf), "\n",
HiCBricks:R/Brick_functions.R: [ ]
2002:     Path <- Create_Path(c(Root.folders['matrices'],chr,chr))
498:         Bintable.group.path <- Create_Path(
1361:     Group.path <- Create_Path(c(Reference.object$hdf.matrices.root,chr1,chr2))
1456:     Group.path <- Create_Path(c(Reference.object$hdf.matrices.root,chr,chr))
2522:     Group.path <- Create_Path(c(Reference.object$hdf.matrices.root,
2585:     Group_path <- Create_Path(c(Reference_object$hdf.matrices.root, 
2678:     Group.path <- Create_Path(c(Reference.object$hdf.matrices.root, chr1,
205:     Config_filepath <- .make_configuration_path(output_directory)
895:     Brick_filepath <- BrickContainer_get_path_to_file(Brick,
964:     Brick_filepath <- BrickContainer_get_path_to_file(Brick, 
1339:     Brick_filepath <- BrickContainer_get_path_to_file(Brick, 
1434:     Brick_filepath <- BrickContainer_get_path_to_file(Brick, 
1849:     Brick_filepath <- BrickContainer_get_path_to_file(Brick = Brick, 
2034:     Brick_filepath <- BrickContainer_get_path_to_file(Brick = Brick, 
2524:     Brick_filepath <- BrickContainer_get_path_to_file(Brick = Brick, 
2587:     Brick_filepath <- BrickContainer_get_path_to_file(Brick = Brick, 
2676:     Brick_filepath <- BrickContainer_get_path_to_file(Brick = Brick, 
703:     Brick_paths <- BrickContainer_get_path_to_file(Brick = Brick,
760:     Brick_filepaths <- BrickContainer_list_files(Brick = Brick, 
812:     Brick_filepaths <- BrickContainer_get_path_to_file(Brick,
18: #' A string containing the path to the file to load as the binning table for
141: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"), 
143: #' out_dir <- file.path(tempdir(), "Creator_test")
145: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path, 
178:             "without an explicit path", "definition!", "If you want to create",
180:             "please provide", "the complete path. Or, you can",
182:             paste("file.path(getwd())", sep = ""), 
300: #' the function will provide the path to the created/tracked HDF file.
306: #' out_dir <- file.path(tempdir(),"mcool_test_dir")
307: #' dir.create(path = out_dir)
311: #' destfile = file.path(out_dir,"H1-hESC-HiC-4DNFI7JNCNFB.mcool"))
313: #' mcool <- file.path(out_dir,"H1-hESC-HiC-4DNFI7JNCNFB.mcool")
332:         stop("mcool must be provided as mcool= /path/to/something")
339:         mcool.version <- GetAttributes(Path = Create_Path(
355:         mcool.version <- GetAttributes(Path = NULL, File=mcool, 
391: #' out_dir <- file.path(tempdir(),"mcool_test_dir")
392: #' dir.create(path = out_dir)
397: #' destfile = file.path(out_dir,"H1-hESC-HiC-4DNFI7JNCNFB.mcool"))
399: #' mcool <- file.path(out_dir,"H1-hESC-HiC-4DNFI7JNCNFB.mcool")
452: #' out_dir <- file.path(tempdir(), "mcool_test_dir")
453: #' dir.create(path = out_dir)
457: #' destfile = file.path(out_dir, "H1-hESC-HiC-4DNFI7JNCNFB.mcool"))
459: #' mcool <- file.path(out_dir, "H1-hESC-HiC-4DNFI7JNCNFB.mcool")
476:     mcool.version <- GetAttributes(Path = NULL, File=mcool,
502:         Bintable.group.path <- Create_Path(Bintable.group)
504:     Handler <- ._Brick_Get_Something_(Group.path = Bintable.group.path,
517: #' A string specifying the path to the Brick store created with 
534: #' Bintable_path <- system.file(file.path("extdata", "Bintable_100kb.bins"), 
537: #' out_dir <- file.path(tempdir(), "HiCBricks_chrominfo_test")
541: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable_path, 
670: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"), 
673: #' out_dir <- file.path(tempdir(), "add_ranges_test")
677: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path, 
709:     bplapply(Brick_paths, function(Brick_path){
710:         ._Brick_Add_Ranges_(Brick = Brick_path,
711:         Group.path = Create_Path(c(Reference.object$hdf.ranges.root,
739: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"), 
742: #' out_dir <- file.path(tempdir(), "list_matrices_test")
746: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path, 
766:             Path = Create_Path(
794: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"), 
797: #' out_dir <- file.path(tempdir(), "list_rangekeys_test")
801: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path, 
815:         Group.path = Create_Path(Reference.object$hdf.ranges.root),
836: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"), 
839: #' out_dir <- file.path(tempdir(), "list_rangekeys_exists_test")
843: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path, 
876: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"), 
879: #' out_dir <- file.path(tempdir(), "list_ranges_mcols_test")
883: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path, 
936: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"), 
939: #' out_dir <- file.path(tempdir(), "list_get_ranges_test")
943: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path, 
971:         chromosomes <- ._Brick_Get_Something_(Group.path = Create_Path(
980:             Group.path = Create_Path(
985:         Lengths <- ._Brick_Get_Something_(Group.path = Create_Path(
995:     Dataset <- ._Brick_Get_Something_(Group.path = Create_Path(
1020:                     Group.path = Create_Path(
1038:                     Group.path = Create_Path(c(
1071: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"), 
1074: #' out_dir <- file.path(tempdir(), "list_get_bintable_test")
1077: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path, 
1134: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"), 
1137: #' out_dir <- file.path(tempdir(), "fetch_range_index_test")
1140: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path, 
1232: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"),
1235: #' out_dir <- file.path(tempdir(), "region_position_test")
1238: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path, 
1303: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"), 
1306: #' out_dir <- file.path(tempdir(), "matrix_load_test")
1309: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path, 
1314: #' Matrix_file <- system.file(file.path("extdata", 
1367:         Matrix.file = matrix_file, delim = delim, Group.path = Group.path, 
1400: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"), 
1403: #' out_dir <- file.path(tempdir(), "matrix_load_dist_test")
1406: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path, 
1411: #' Matrix_file <- system.file(file.path("extdata", 
1462:         Matrix.file = matrix_file, delim = delim, Group.path = Group.path,
1481: #' @param mcool \strong{Required}. Path to an mcool file.
1504: #' out_dir <- file.path(tempdir(),"mcool_load_test")
1505: #' dir.create(path = out_dir)
1509: #' destfile = file.path(out_dir,"H1-hESC-HiC-4DNFI7JNCNFB.mcool"))
1511: #' mcool <- file.path(out_dir,"H1-hESC-HiC-4DNFI7JNCNFB.mcool")
1568:     RetVar <- .process_mcool(Brick = Brick, mcool_path = mcool, 
1585: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"), 
1588: #' out_dir <- file.path(tempdir(), "matrix_isdone_test")
1591: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path, 
1596: #' Matrix_file <- system.file(file.path("extdata", 
1629: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"), 
1632: #' out_dir <- file.path(tempdir(), "matrix_issparse_test")
1635: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path, 
1640: #' Matrix_file <- system.file(file.path("extdata", 
1681: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"), 
1684: #' out_dir <- file.path(tempdir(), "matrix_maxdist_test")
1687: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path, 
1692: #' Matrix_file <- system.file(file.path("extdata", 
1736: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"), 
1739: #' out_dir <- file.path(tempdir(), "matrix_exists_test")
1742: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path, 
1747: #' Matrix_file <- system.file(file.path("extdata", 
1775: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"), 
1778: #' out_dir <- file.path(tempdir(), "matrix_minmax_test")
1781: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path, 
1786: #' Matrix_file <- system.file(file.path("extdata", 
1821: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"), 
1824: #' out_dir <- file.path(tempdir(), "matrix_dimension_test")
1827: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path, 
1832: #' Matrix_file <- system.file(file.path("extdata", 
1851:     Extents <- ._GetDimensions(group.path = Create_Path(
1853:         dataset.path = Reference.object$hdf.matrix.name,
1870: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"), 
1873: #' out_dir <- file.path(tempdir(), "matrix_filename_test")
1876: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path, 
1881: #' Matrix_file <- system.file(file.path("extdata", 
1936: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"), 
1939: #' out_dir <- file.path(tempdir(), "val_by_dist_test")
1942: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path, 
1947: #' Matrix_file <- system.file(file.path("extdata", 
2040:         diag(._Brick_Get_Something_(Group.path = Path, Brick = Brick_filepath,
2087: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"), 
2090: #' out_dir <- file.path(tempdir(), "get_matrix_coords_test")
2093: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path, 
2098: #' Matrix_file <- system.file(file.path("extdata", 
2200: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"), 
2203: #' out_dir <- file.path(tempdir(), "get_matrix_test")
2206: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path, 
2211: #' Matrix_file <- system.file(file.path("extdata", 
2309: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"), 
2312: #' out_dir <- file.path(tempdir(), "get_row_vector_test")
2315: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path, 
2320: #' Matrix_file <- system.file(file.path("extdata", 
2463: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"), 
2466: #' out_dir <- file.path(tempdir(), "get_vector_val_test")
2472: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path, 
2477: #' Matrix_file <- system.file(file.path("extdata", 
2526:     Vector <- ._Brick_Get_Something_(Group.path = Group.path, 
2550: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"), 
2553: #' out_dir <- file.path(tempdir(), "get_vector_val_test")
2558: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path, 
2563: #' Matrix_file <- system.file(file.path("extdata", 
2589:     dataset_handle <- ._Brick_Get_Something_(Group.path = Group_path, 
2625: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"), 
2628: #' out_dir <- file.path(tempdir(), "get_matrix_mcols_test")
2631: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path, 
2636: #' Matrix_file <- system.file(file.path("extdata", 
2680:     Vector <- ._Brick_Get_Something_(Group.path = Group.path, 
2694: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"), 
2697: #' out_dir <- file.path(tempdir(), "list_matrix_mcols_test")
2700: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path, 
2717: #' BrickContainer, a string of length 1 as resolution and a path specifying
2724: #' @param out_file Path to the output file to write.
2735: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"), 
2738: #' out_dir <- file.path(tempdir(), "write_file")
2741: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path, 
2746: #' Matrix_file <- system.file(file.path("extdata", 
2755: #' out_file = file.path(out_dir, "example_out.txt"), 
2768:         stop(out_file, " already exists at path")
2820: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"), 
2823: #' out_dir <- file.path(tempdir(), "get_vector_val_test")
2828: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path, 
2833: #' Matrix_file <- system.file(file.path("extdata", 
2870: #' @param table_file Path to the file that will be loaded
2887: #' Bintable.path <- system.file(file.path("extdata", "Bintable_100kb.bins"), 
2890: #' out_dir <- file.path(tempdir(), "get_vector_val_test")
2895: #' My_BrickContainer <- Create_many_Bricks(BinTable = Bintable.path, 
2900: #' Matrix_file <- system.file(file.path("extdata", 
2909: #' out_file = file.path(out_dir, "example_out.txt"), 
2914: #' table_file = file.path(out_dir, "example_out.txt"), 
188:     output_directory <- normalizePath(output_directory)
219:     if(file.exists(Config_filepath)){
223:         Container <- load_BrickContainer(Config_filepath)
282:         Config_filepath)
283:     .write_configuration_file(Container, Config_filepath)
907:     mcol.df <- .prepare_ranges_metadata_mcols(Brick = Brick_filepath, 
973:         Brick = Brick_filepath,
982:             Brick = Brick_filepath,
987:         Brick = Brick_filepath,
997:         Brick = Brick_filepath, 
1022:                 Brick = Brick_filepath, Name = FUN_name, Start = m.start, 
1040:                         rangekey)), Brick = Brick_filepath,
1341:     if(length(Brick_filepath) == 0){
1366:     RetVar <- ._ProcessMatrix_(Brick = Brick_filepath, 
1436:     if(length(Brick_filepath) == 0){
1461:     RetVar <- ._Process_matrix_by_distance(Brick = Brick_filepath,
1854:         File = Brick_filepath, return.what = "size")
2527:         Brick = Brick_filepath, Name = Reference.object$hdf.matrix.name, 
2590:         Brick = Brick_filepath, Name = Reference_object$hdf.matrix.name, 
2681:         Brick = Brick_filepath, Name = what, return.what = "data")
2781:             Brick_filepath = a_row$filepath,
763:     chr1.list <- lapply(seq_len(nrow(Brick_filepaths)), function(i){
764:         Row <- Brick_filepaths[i,]
770:             File = Row$filepaths,
816:         Brick = Brick_filepaths[1], return.what = "group_handle")
oligoClasses:R/methods-GenomeAnnotatedDataFrame.R: [ ]
259:   path <- system.file("extdata", package=pkgname)
260:   if(path=="") stop("Are you sure ", pkgname, " is installed?")
262:   snpBuilds <- list.files(path, pattern="snpProbes_")
GenoGAM:R/GenoGAMDataSet-class.R: [ ]
972:     path <- slot(settings, "hdf5Control")$dir
123: #' @param experimentDesign Either a character object specifying the path to a
620: .getIdentifier <- function(path, fits = FALSE) {
623:     files <- list.files(path)
646:     config$file <- file.path(directory, as.character(config$file))
973:     ident <- .getIdentifier(path)
983:             h5file <- file.path(path, paste0(id, "_", ident))
1000:         h5file <- file.path(path, paste0("dataset", "_", ident))
1014:     smFile <- file.path(path, paste0("sumMatrix", "_", ident))
rtracklayer:R/ucsc.R: [ ]
1597:     path <- ucscURLTable[key]
364:   label_path <- "//select[@name = 'hgta_track']/option/text()"
366:   track_path <- "//select[@name = 'hgta_track']/option/@value"
365:   labels <- sub("\n.*$", "", sapply(getNodeSet(doc, label_path), xmlValue))
367:   tracks <- unlist(getNodeSet(doc, track_path))
1572:             upload <- fileUpload(path(object), "text/plain")
1598:     if (is.na(path))
1601:         path <- paste0(path, '?redirect="manual"')
1603:     paste(object@url, path, sep="")
VarCon:inst/extdata/app.R: [ ]
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
Rgraphviz:src/graphviz/lib/common/types.h: [ ]
105:     typedef struct path {	/* internal specification for an edge spline */
110:     } path;
656: 	Ppolyline_t path;
685: #define ED_path(e) (((Agedgeinfo_t*)AGDATA(e))->path)
714: #define ED_path(e) (e)->u.path
97:     typedef struct pathend_t {
103:     } pathend_t;
158: 	/* we would have called it a path if that term wasn't already used */
174: 	 * It is used as the clipping path */
182: 	int (*pboxfn)(node_t* n, port* p, int side, boxf rv[], int *kptr); /* finds box path to reach port */
34: #include "pathgeom.h"
TPP2D:R/import_funcs.R: [ ]
348:   Experiment <- Path <- Compound <- NULL
570:  Path <- label <- conc <- Compound <- Experiment <- 
371:   givenPaths <- NULL
253:                "Experiment", "Path", "Path", 
254:                "Path", "Condition", "Replicate", 
334: #' @param infoTable character string of a file path to
372:   if (any("Path" %in% colnames(infoTable))) {
373:     if (all(infoTable$Path == "") || all(is.na(infoTable$Path))) {
374:       message("Removing empty 'Path' column from config table")
375:       infoTable <- infoTable %>% select(-Path)
378:       givenPaths <- infoTable$Path
443: #' @param configTable character string of a file path to a config table
485:   files <- configTable$Path
511:                   "RefCol", "Path", "Condition")
573:   if(any(grepl("Path", colnames(configWide)))){
575:       dplyr::select(-Path) %>%
756: #' @param configTable character string of a file path to a config table
433:       expCond = infoTable$Condition, files = givenPaths, 
peakPantheR:R/methods_peakPantheRAnnotation.R: [ ]
1724:             device = "png", path = saveFolder, dpi = 100, width = 21,
1853:     path_cpdMeta <- paste(saveFolder, "/", annotationName,
1871:     path_specMeta <- paste(saveFolder, "/", annotationName,
1883:         path_var <- paste(saveFolder, "/", annotationName, "_", i, ".csv",
1918:     path_summary <- paste(saveFolder, "/", annotationName, "_summary.csv",
1116:     .filepath <- x@filepath[i]
1863:     tmp_filepath <- filepath(object)
2045:     .spectraPaths <- resSpectra$spectraPaths
2182: resetAnnot_spectraPathMetadata <- function(previousAnnotation, spectraPaths,
2186:         .spectraPaths <- filepath(previousAnnotation)
1076:     return(tools::file_path_sans_ext(basename(object@filepath)))
1386: #' @param saveFolder (str) Path of folder where annotationParameters_summary.csv
1399: #' spectraPaths <- c('./path/file1', './path/file2', './path/file3')
1610: #' @param saveFolder (str) Path of folder where annotationParameters_summary.csv
1703:     # @param saveFolder (str) Path where plots will be saved
1727:         # output path
1758: #' @param saveFolder (str) Path of folder where the annotation result csv will
1855:     utils::write.csv(tmp_outCpdMeta, file = path_cpdMeta, row.names = FALSE,
1858:     if (verbose) { message("Compound metadata saved at ", path_cpdMeta) }
1873:     utils::write.csv(tmp_outSpecMeta, file = path_specMeta, row.names = FALSE,
1876:     if (verbose) { message("Spectra metadata saved at ", path_specMeta) }
1885:         utils::write.csv(tmp_var, file = path_var, row.names = TRUE,
1889:             message("Peak measurement \"", i, "\" saved at ", path_var)
1920:     utils::write.csv(tmp_summary, file = path_summary, row.names = TRUE,
1923:     if (verbose) { message("Summary saved at ", path_summary) }
24:             length(object@filepath), " samples. \n", sep = "")
53: # @filepath length. Slot type is not checked as \code{setClass} enforces it.
78: #' # Paths to spectra files
119: #' # Paths to spectra files
160: #' # Paths to spectra files
206: #' # Paths to spectra files
253: #' # Paths to spectra files
286: # filepath
287: setGeneric("filepath", function(object, ...) standardGeneric("filepath"))
288: #' filepath accessor
290: #' @return (str) A character vector of file paths, of length number of spectra
293: #' @aliases filepath
300: #' # Paths to spectra files
319: #' filepath(annotation)
324: setMethod("filepath", "peakPantheRAnnotation", function(object) {
325:     object@filepath
343: #' # Paths to spectra files
386: #' # Paths to spectra files
430: #' # Paths to spectra files
472: #' # Paths to spectra files
512: #' # Paths to spectra files
552: #' # Paths to spectra files
593: #' # Paths to spectra files
636: #' # Paths to spectra files
695: #' # Paths to spectra files
742: #' # Paths to spectra files
788: #' # Paths to spectra files
817: #' nbSamples accessor established on filepath
828: #' # Paths to spectra files
852:     return(length(object@filepath))
868: #' # Paths to spectra files
913: #' # Paths to spectra files
946:     nbSample <- length(object@filepath)
953:         rownames(tmpAnnotation) <- object@filepath
961:         rownames(tmpAnnotation) <- object@filepath
977:     rownames(tmpAnnotation) <- object@filepath
1000: #' # Paths to spectra files
1041: #' filename accessor by spliting filepath
1052: #' # Paths to spectra files
1134:         FIR = .FIR, uROI = .uROI, filepath = .filepath,
1214: #' # Paths to spectra files
1398: #' # Paths to spectra files
1416: #' savePath        <- tempdir()
1419: #' outputAnnotationParamsCSV(emptyAnnotation, saveFolder=savePath, verbose=TRUE)
1488: #' # Paths to spectra files
1627: #' # Paths to spectra files
1652: #' savePath1       <- tempdir()
1653: #' outputAnnotationDiagnostic(annotation, saveFolder=savePath1, savePlots=FALSE,
1771: #' # Paths to spectra files
1796: #' savePath1       <- tempdir()
1797: #' outputAnnotationResult(annotation, saveFolder=savePath1,
1867:     tmp_outSpecMeta <- data.frame(filepath = tmp_filepath,
1941: #' the slots (\code{filepath} (from \code{spectraPaths}), \code{ROI},
1947: #' @param spectraPaths NULL or a character vector of spectra file paths, to set
1972: #' (\code{cpdID}, \code{cpdName}, \code{ROI}, \code{filepath}, \code{TIC},
1984: #' # Paths to spectra files
2188:             message("  Previous \"filepath\" value kept")
2415: #' # Paths to spectra files
80: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),
95: #' annotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,
121: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),
136: #' annotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,
162: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),
177: #' annotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,
208: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),
223: #' annotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,
255: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),
270: #' annotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,
302: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),
317: #' annotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,
345: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),
360: #' annotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,
388: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),
403: #' annotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,
432: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),
447: #' annotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,
474: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),
489: #' annotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,
514: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),
529: #' annotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,
554: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),
569: #' annotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,
595: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),
610: #' annotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,
638: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),
653: #' annotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,
697: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),
712: #' annotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,
744: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),
759: #' annotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,
790: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),
805: #' annotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,
830: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),
845: #' annotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,
870: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),
885: #' annotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,
915: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),
930: #' annotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,
1002: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),
1017: #' annotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,
1054: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),
1069: #' annotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,
1216: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),
1231: #' emptyAnnotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,
1412: #' emptyAnnotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,
1490: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),
1505: #' emptyAnnotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,
1629: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),
1644: #' emptyAnnotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,
1773: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),
1788: #' emptyAnnotation <- peakPantheRAnnotation(spectraPaths=spectraPaths,
1931:     function(previousAnnotation, spectraPaths = NULL, targetFeatTable = NULL,
1939: #' \code{spectraPaths}) or compounds (\code{targetFeatTable}) are passed, the
1986: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),
2000: #' smallAnnotation  <- peakPantheRAnnotation(spectraPaths=spectraPaths, 
2011: #' newSpectraPaths  <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),
2015: #'                                     spectraPaths=newSpectraPaths,
2026:     function(previousAnnotation, spectraPaths, targetFeatTable, uROI, FIR,
2042:     # spectraPaths, spectraMetadata
2043:     resSpectra <- resetAnnot_spectraPathMetadata(previousAnnotation,
2044:                                         spectraPaths, spectraMetadata, verbose)
2061:     # Create new object In all case (old or new value) spectraPaths and
2063:     peakPantheRAnnotation(spectraPaths = .spectraPaths,
2181: # resetAnnotation spectraPaths, spectraMetadata
2185:     if (all(is.null(spectraPaths))) {
2208:         .spectraPaths <- spectraPaths
2210:             message("  New \"spectraPaths\" value set")
2229:     return(list(spectraPaths = .spectraPaths,
2417: #' spectraPaths <- c(system.file('cdf/KO/ko15.CDF', package = 'faahKO'),
2431: #' smallAnnotation  <- peakPantheRAnnotation(spectraPaths=spectraPaths,
scde:R/functions.R: [ ]
5439:             path <- env[['PATH_INFO']]
6044:             path <- env[['PATH_INFO']]
2147:                 pathsizes <- unlist(tapply(vi, gcll, length))
5059: pathway.pc.correlation.distance <- function(pcc, xv, n.cores = 10, target.ndf = NULL) {
6173:                        pathcl <- ifelse(is.null(req$params()$pathcl), 1, as.integer(req$params()$pathcl))
1877: pagoda.pathway.wPCA <- function(varinfo, setenv, n.components = 2, n.cores = detectCores(), min.pathway.size = 10, max.pathway.size = 1e3, n.randomizations = 10, n.internal.shuffles = 0, n.starts = 10, center = TRUE, batch....(55 bytes skipped)...
5558: t.view.pathways <- function(pathways, mat, matw, env, proper.names = rownames(mat), colcols = NULL, zlim = NULL, labRow = NA, vhc = ...(145 bytes skipped)...
5684: pagoda.show.pathways <- function(pathways, varinfo, goenv = NULL, n.genes = 20, two.sided = FALSE, n.pc = rep(1, length(pathways)), colcols = NULL, zlim = NULL, showRowLabels = FALSE, cexCol = 1, cexRow = 1, nstarts = 10, ce...(117 bytes skipped)...
5698: c.view.pathways <- function(pathways, mat, matw, goenv = NULL, batch = NULL, n.genes = 20, two.sided = TRUE, n.pc = rep(1, length(pathways)), colcols = NULL, zlim = NULL, labRow = NA, vhc = NULL, cexCol = 1, cexRow = 1, nstarts = 50, ...(93 bytes skipped)...
461: ##' @param name URL path name for this app
5443:             switch(path,
6047:             switch(path,
1: ##' Single-cell Differential Expression (with Pathway And Gene set Overdispersion Analysis)
6: ##' The scde package also contains the pagoda framework which applies pathway and gene set overdispersion analysis
9: ##' See vignette("pagoda") for a brief tutorial on pathway and gene set overdispersion analysis to identify and characterize cell subpopulations.
1292: ...(39 bytes skipped)...lowed for the estimated adjusted variance (capping of adjusted variance is recommended when scoring pathway overdispersion relative to randomly sampled gene sets)
1789: ##' such as ribosomal pathway variation) and subtracts it from the data so that it is controlled
1815: ##' cc.pattern <- pagoda.show.pathways(ls(go.env)[1:2], varinfo, go.env, show.cell.dendrogram = TRUE, showRowLabels = TRUE)  # Look at...(30 bytes skipped)...
1845: ##' @param min.pathway.size minimum number of observed genes that should be contained in a valid gene set
1846: ##' @param max.pathway.size maximum number of observed genes in a valid gene set
1847: ...(103 bytes skipped)...ith each gene set (can be kept at 5 or 10, but should be increased to 50-100 if the significance of pathway overdispersion will be determined relative to random gene set models)
1873: ##' pwpca <- pagoda.pathway.wPCA(varinfo, go.env, n.components=1, n.cores=10, n.internal.shuffles=50)
1901:         gsl <- gsl[gsl.ng >= min.pathway.size & gsl.ng<= max.pathway.size]
1905:         message("processing ", length(gsl), " valid pathways")
1954: ##' @param pwpca result of the pagoda.pathway.wPCA() call with n.randomizations > 1
1965: ##' pwpca <- pagoda.pathway.wPCA(varinfo, go.env, n.components=1, n.cores=10, n.internal.shuffles=50)
2148:                 names(pathsizes) <- pathsizes
2151:                     rsdv <- unlist(lapply(names(pathsizes), function(s) {
2156:                     return(data.frame(n = as.integer(pathsizes), var = unlist(sdv), round = i, rvar = rsdv))
2160:                 data.frame(n = as.integer(pathsizes), var = unlist(sdv), round = i)
2216: ##' @param pwpca output of pagoda.pathway.wPCA()
2242: ##' pwpca <- pagoda.pathway.wPCA(varinfo, go.env, n.components=1, n.cores=10, n.internal.shuffles=50)
2393:     # determine genes driving significant pathways
2435: ##' @param pwpca output of pagoda.pathway.wPCA()
2453: ##' pwpca <- pagoda.pathway.wPCA(varinfo, go.env, n.components=1, n.cores=10, n.internal.shuffles=50)
2460:     pclc <- pathway.pc.correlation.distance(c(pwpca, clpca$cl.goc), tam$xv, target.ndf = 100, n.cores = n.cores)
2521: ##' pwpca <- pagoda.pathway.wPCA(varinfo, go.env, n.components=1, n.cores=10, n.internal.shuffles=50)
2603: ##' pwpca <- pagoda.pathway.wPCA(varinfo, go.env, n.components=1, n.cores=10, n.internal.shuffles=50)
2654: ##' @param tamr Combined pathways that show similar expression patterns. Output of \code{\link{pagoda.reduce.redundancy}}
2655: ##' @param row.clustering Dendrogram of combined pathways clustering
2667: ##' pwpca <- pagoda.pathway.wPCA(varinfo, go.env, n.components=1, n.cores=10, n.internal.shuffles=50)
2724: ##' @param tamr Combined pathways that show similar expression patterns. Output of \code{\link{pagoda.reduce.redundancy}}
2725: ##' @param tam Combined pathways that are driven by the same gene sets. Output of \code{\link{pagoda.reduce.loading.redundancy}}...(0 bytes skipped)...
2728: ...(15 bytes skipped)...a Weighted PC magnitudes for each gene set provided in the \code{env}. Output of \code{\link{pagoda.pathway.wPCA}}
2732: ##' @param row.clustering Dendrogram of combined pathways clustering. Default NULL.
2733: ##' @param title Title text to be used in the browser label for the app. Default, set as 'pathway clustering'
2739: ...(47 bytes skipped)... env, pwpca, clpca = NULL, col.cols = NULL, cell.clustering = NULL, row.clustering = NULL, title = "pathway clustering", zlim = c(-1, 1)*quantile(tamr$xv, p = 0.95)) {
2764:     # prepare pathway df
3559: .onUnload <- function(libpath) {
3560:     library.dynam.unload("scde", libpath, verbose = TRUE)
5108:         #set scale at top pathway?
5560:     lab <- which(proper.names %in% na.omit(unlist(mget(pathways, envir = env, ifnotfound = NA))))
5564:         lab <- which(proper.names %in% pathways)
5569:     #table(rownames(mat) %in% mget(pathways, envir = env))
5660: ##' View pathway or gene weighted PCA
5662: ##' Takes in a list of pathways (or a list of genes), runs weighted PCA, optionally showing the result.
5663: ##' @param pathways character vector of pathway or gene names
5665: ##' @param goenv environment mapping pathways to genes
5668: ...(5 bytes skipped)...param n.pc optional integer vector giving the number of principal component to show for each listed pathway
5681: ##' @param ... additional arguments are passed to the \code{c.view.pathways}
5687:     x <- c.view.pathways(pathways, varinfo$mat, varinfo$matw, goenv, batch = varinfo$batch, n.genes = n.genes, two.sided = two.si...(213 bytes skipped)...
5695: # takes in a list of pathways with a list of corresponding PC numbers
5696: # recalculates PCs for each individual pathway, weighting gene loading in each pathway and then by total
5697: # pathway variance over the number of genes (rough approximation)
5699:     # are these genes or pathways being passed?
5701:         x <- pathways %in% ls(goenv)
5703:         x <- rep(FALSE, length(pathways))
5705:     if(sum(x) > 0) { # some pathways matched
5707:         message("WARNING: partial match to pathway names. The following entries did not match: ", paste(pathways[!x], collapse = " "))
5709:         # look up genes for each pathway
5710:         pathways <- pathways[x]
5711:         p.genes <- mget(pathways, goenv, ifnotfound = NA)
5713:         x <- pathways %in% rownames(mat)
5716: ...(9 bytes skipped)...       message("WARNING: partial match to gene names. The following entries did not match: ", paste(pathways[!x], collapse = " "))
5718:             p.genes <- list("genes" = pathways[x])
5719:             pathways <- c("genes");
5720:         } else { # neither genes nor pathways are passed
5721:             stop("ERROR: provided names do not match either gene nor pathway names (if the pathway environment was provided)")
5728:     # recalculate wPCA for each pathway
5729:     ppca <- pagoda.path...(130 bytes skipped)...s), n.cores = 1, n.randomizations = 0, n.starts = 2, n.components = max(n.pc), verbose = FALSE, min.pathway.size = 0, max.pathway.size = Inf, n.internal.shuffles = 0)
5731:     if(length(ppca) > 1) { # if more than one pathway was supplied, combine genes using appropriate loadings and use consensus PCA (1st PC) as a patte...(2 bytes skipped)...
5733:         scaled.gene.loadings <- unlist(lapply(seq_along(pathways), function(i) {
5734:             gl <- ppca[[pathways[i]]]$xp$rotation[, n.pc[i], drop = TRUE]*as.numeric(ppca[[pathways[i]]]$xp$sd)[n.pc[i]]/sqrt(ppca[[pathways[i]]]$n)
5735:             names(gl) <- rownames(ppca[[pathways[i]]]$xp$rotation)
5777:     } else { # only one pathway was provided
5970: ##' @field results Output of the pathway clustering and redundancy reduction
5972: ##' @field pathways
5983:     fields = c('results', 'genes', 'pathways', 'mat', 'matw', 'goenv', 'renv', 'name', 'trim', 'batch'),
5986:         initialize = function(results, pathways, genes, mat, matw, goenv, batch = NULL, name = "pathway overdispersion", trim = 1.1/ncol(mat)) {
5995:             pathways <<- pathways
6012:                 gcl <- t.view.pathways(genes, mat = mat, matw = matw, env = goenv, vhc = results$hvc, plot = FALSE, trim = ltrim)
6058: ...(21 bytes skipped)...                <link rel = "stylesheet" type = "text/css" href = "http://pklab.med.harvard.edu/sde/pathcl.css" / >
6064: ...(10 bytes skipped)...                           <script type = "text/javascript" src = "http://pklab.med.harvard.edu/sde/pathcl.js" > </script >
6072:                    '/pathcl.json' = { # report pathway clustering heatmap data
6126:                    '/pathwaygenes.json' = { # report heatmap data for a selected set of genes
6133:                        x <- c.view.pathways(gsub("^#PC\\d+# ", "", pws), mat, matw, goenv = goenv, n.pc = n.pcs, n.genes = ngenes, two.side...(75 bytes skipped)...
6134:                        #x <- t.view.pathways(gsub("^#PC\\d+# ", "", pws), mat, matw, env = goenv, vhc = results$hvc, plot = FALSE, trim = lt...(14 bytes skipped)...
6174:                        ii <- which(results$ct == pathcl)
6251:                    '/pathways.json' = {
6252:                        lgt <- pathways
Rhdf5lib:R/zzz.R: [ ]
21:   path <- Sys.getenv(
31:   patharch <- paste0(path, arch)
36:     ## so we use the 8+3 form of the path and replace slashes
22:     x = "RHDF5LIB_RPATH",
37:     patharch <- gsub(x = utils::shortPathName(patharch),
49:                                       patharch, winlibs)
52:                                       patharch, patharch, .getDynamicLinks())
60:                                       patharch, winlibs)
63:                                       patharch, patharch, patharch, .getDynamicLinks())
71:                                       patharch, winlibs)
74:                                       patharch, patharch, patharch, .getDynamicLinks())
82:                                       patharch, winlibs)
85:                                       patharch, patharch, patharch, patharch, patharch, .getDynamicLinks())
18: #' @rawNamespace if(tools:::.OStype() == "windows") { importFrom(utils, shortPathName) }
monocle:R/order_cells.R: [ ]
1724:   path <- shortest_paths(g, from = starting_cell, end_cells)
90:     path_vertex <- as.vector(get.all.shortest.paths(net, from = 1, to = i, mode="out")$res[[1]])
412:   FF_path <- unlist(get.shortest.paths(new_subtree, from=as.vector(first_fwd), to=as.vector(last_fwd), mode="out", output="vpath")$vpath)
413:   FR_path <- unlist(get.shortest.paths(new_subtree, from=as.vector(first_fwd), to=as.vector(last_rev), mode="out", output="vpath")$vpath)
414:   RF_path <- unlist(get.shortest.paths(new_subtree, from=as.vector(first_rev), to=as.vector(last_fwd), mode="out", output="vpath")$vpath)
415:   RR_path <- unlist(get.shortest.paths(new_subtree, from=as.vector(first_rev), to=as.vector(last_rev), mode="out", output="vpath")$vpath)
433:   path_weights <- c(FF_weight, FR_weight, RF_weight, RR_weight)
435:   opt_path <- paths[[opt_path_idx]]
459: measure_diameter_path <- function(pq_tree, curr_node, path_lengths)
1741:     path_cells <- names(traverse_res$shortest_path[[1]])
432:   paths <- list(FF_path, FR_path, RF_path, RR_path)
174:   first_diam_path_node_idx <- head(as.vector(diam), n=1)
175:   last_diam_path_node_idx <- tail(as.vector(diam), n=1)
189:     diam_path_names <- V(mst)[as.vector(diam)]$name
434:   opt_path_idx <- head((which(path_weights == min(path_weights))), 1)
91:     pd_subset <- subset(pd, State %in% path_vertex & is.na(scale_pseudotime))
94:     # print(path_vertex)
137: #' @param use_weights Whether to use edge weights when finding the diameter path of the tree.
138: #' @param root_node The name of the root node to use for starting the path finding.
169:   V(new_subtree)[root_node_id]$diam_path_len = length(diam)
177:       (igraph::degree(mst, first_diam_path_node_idx) == 1 &&
178:        igraph::degree(mst, last_diam_path_node_idx) == 1))
186:     #diam_path_vertex_names <- as.vector()
190:     last_bb_point_idx <- which(diam_path_names == last_bb_point)[1]
191:     first_bb_point_idx <- which(diam_path_names == first_bb_point)[1]
243: ...(48 bytes skipped)...x(V(sub_pq$subtree)[v]$name, type=V(sub_pq$subtree)[v]$type, color=V(sub_pq$subtree)[v]$color, diam_path_len=V(sub_pq$subtree)[v]$diam_path_len)
364:   #print ("opt_path:")
417:   # print (FF_path)
418:   # print (FR_path)
419:   # print (RF_path)
420:   # print (RR_path)
422:   FF_weight <- sum(E(new_subtree, path=FF_path)$weight)
423:   FR_weight <- sum(E(new_subtree, path=FR_path)$weight)
424:   RF_weight <- sum(E(new_subtree, path=RF_path)$weight)
425:   RR_weight <- sum(E(new_subtree, path=RR_path)$weight)
437:   # print ("opt_path:")
438:   # print (opt_path)
441:   stopifnot (length(opt_path) == length(q_level_list))
443:   directions <- V(new_subtree)[opt_path]$type
455:   return(list(ql=q_levels, wt=min(path_weights)))
465:     path_lengths[curr_node] = 0
466:     return(path_lengths)
484:     path_lengths[curr_node] = children_count
553: #' @param reverse_main_path Whether to reverse the direction of the trajectory
556: ...(8 bytes skipped)...good_branched_ordering <- function(orig_pq_tree, curr_node, dist_matrix, num_branches, reverse_main_path=FALSE)
574:   branch_node_counts <- V(pq_tree)[type == "Q"]$diam_path_len
721: ...(34 bytes skipped)..._helper(branch_tree, curr_branch, cell_ordering_tree, branch_pseudotimes, dist_matrix, reverse_main_path)
1719: # #' @return a list of shortest path...(46 bytes skipped)...estic distance between initial cell and terminal cells and branch point passes through the shortest path
1726:   return(list(shortest_path = path$vpath, distance = distance, branch_points = intersect(branchPoints, unlist(path$vpath))))
1743:     subset_cell <- c(subset_cell, path_cells)
47: #' @importFrom igraph graph.adjacency V graph.dfs get.all.shortest.paths
140: #' @importFrom igraph graph.empty get.edgelist get.all.shortest.paths
151:     sp <- get.all.shortest.paths(mst, from=V(mst)[root_node])
377: #' @importFrom igraph V vertex edge graph.empty get.shortest.paths E
1055: #' @param num_paths the number of end-point cell states to allow in the biological process.
1065:                        num_paths = NULL,
1084:     if (is.null(num_paths)){
1085:       num_paths = 1
1102: ...(4 bytes skipped)...order_list <- extract_good_branched_ordering(res$subtree, res$root, cellPairwiseDistances(cds), num_paths, FALSE)
1118:     if (is.null(num_paths) == FALSE){
1119:       message("Warning: num_paths only valid for method 'ICA' in reduceDimension()")
1166:     if (is.null(num_paths) == FALSE){
1167:       message("Warning: num_paths only valid for method 'ICA' in reduceDimension()")
1720: #' @importFrom igraph shortest.paths shortest_paths degree
1722:   distance <- shortest.paths(g, v=starting_cell, to=end_cells)
maigesPack:R/plot-methods.R: [ ]
190:         Path <- list(Type1=new("graphNEL", vertices, edgeL=arestas1),
326:         Path <- new("graphNEL", vertices, edgeL=arestas)
167:     graphPath <- function(data=NULL, cuttoffPvalue) {
309:     graphPath <- function(data=NULL, cuttoffCor=NULL, cuttoffP=NULL) {
194:         return(Path)
327:         return(Path)
287:     graph <- graphPath(x, cutPval)
426:         graph <- graphPath(x, cutCor, NULL)
431:         graph <- graphPath(x, NULL, cutPval)
SeqArray:R/Internal.R: [ ]
664:     path <- name.gdsn(node, TRUE)
175: .var_path <- function(var.name, prefix)
173: # Variable path
667:         varname <- .var_path(substring(varname, 2L), "@")
668:     fullvarname <- paste(path, varname, sep="/")
676:         if (path == "genotype")
679:             varname2 <- path
693:             if (path == "genotype")
savR:R/savR-methods.R: [ ]
270:   path <- location(project)
373:   path <- getInterOpFilePath(project, format)
571:   path <- normalizePath(paste(project@location, "InterOp", format@filename, sep="/"))
611:   path <- getInterOpFilePath(project,format)
519:     filePath <- suppressWarnings(normalizePath(paste(project@location, "InterOp", format@filename, sep="/") ))
585: getInterOpFilePath <- function(project, format) {
271:   if (!file.exists(path))
272:     stop(paste("Project", path, "does not exist."))
285:   path <- normalizePath(paste(reports, "Intensity", sep="/"))
289:         Cairo::Cairo(file=paste(path, "/Chart_", cycle, "_", tolower(base), ".png", sep=""), width=300, height=800, dpi=72, type="png", ...(11 bytes skipped)...
304:   path <- normalizePath(paste(reports, "NumGT30", sep="/"))
307:       Cairo::Cairo(file=paste(path, "/Chart_", cycle, ".png", sep=""), width=300, height=800, dpi=72, type="png", bg="white")
323:   path <- normalizePath(paste(reports, "ByCycle", sep="/"))
326:       Cairo::Cairo(file=paste(path, "/QScore_L", lane, ".png", sep=""), width=800, height=400, dpi=72, type="png", bg="white")
341:   path <- normalizePath(paste(reports, "FWHM", sep="/"))
345:         Cairo::Cairo(file=paste(path, "/Chart_", cycle, "_", tolower(base), ".png", sep=""), width=300, height=800, dpi=72, type="png", ...(11 bytes skipped)...
374:   fh <- file(path, "rb")
572:   fh <- file(path, "rb")
612:   fh <- file(path, "rb")
7:   retval <- new("savProject", location=normalizePath(object))
10:   ri <- normalizePath(paste(object, "RunInfo.xml", sep="/"))
273:   reports <- normalizePath(destination, mustWork=F)
521:     if (file.exists(filePath)) {
586:   return(normalizePath(paste(project@location, "InterOp", format@filename, sep="/")))
12:   retval@runid <- XML::xmlAttrs(XML::xpathApply(runinfo, "/RunInfo/Run")[[1]])["Id"]
13:   retval@number <- as.integer(XML::xmlAttrs(xpathApply(runinfo, "/RunInfo/Run")[[1]])["Number"])
14:   retval@flowcell <- XML::xmlValue(XML::xpathApply(runinfo, "/RunInfo/Run/Flowcell")[[1]])
15:   retval@instrument <- XML::xmlValue(XML::xpathApply(runinfo, "/RunInfo/Run/Instrument")[[1]])
16:   retval@date <- XML::xmlValue(XML::xpathApply(runinfo, "/RunInfo/Run/Date")[[1]])
18:   for (x in XML::xpathApply(runinfo, "/RunInfo/Run/Reads/Read")) {
30:   layout <- XML::xpathApply(runinfo, "/RunInfo/Run/FlowcellLayout")[[1]]
interactiveDisplay:inst/www/js/d3.v2.js: [ ]
6081:     function path(d, i) {
1451:   function d3_layout_bundlePath(link) {
1910:   function d3_path_circle(radius) {
1119:     var i = 0, n = points.length, p = points[0], path = [ p[0], ",", p[1] ];
1120:     while (++i < n) path.push("V", (p = points[i])[1], "H", p[0]);
1121:     return path.join("");
1124:     var i = 0, n = points.length, p = points[0], path = [ p[0], ",", p[1] ];
1125:     while (++i < n) path.push("H", (p = points[i])[0], "V", p[1]);
1126:     return path.join("");
1141:     var quad = points.length != tangents.length, path = "", p0 = points[0], p = points[1], t0 = tangents[0], t = t0, pi = 1;
1143:       path += "Q" + (p[0] - t0[0] * 2 / 3) + "," + (p[1] - t0[1] * 2 / 3) + "," + p[0] + "," + p[1];
1151:       path += "C" + (p0[0] + t0[0]) + "," + (p0[1] + t0[1]) + "," + (p[0] - t[0]) + "," + (p[1] - t[1]) + "," ...(21 bytes skipped)...
1155:         path += "S" + (p[0] - t[0]) + "," + (p[1] - t[1]) + "," + p[0] + "," + p[1];
1160:       path += "Q" + (p[0] + t[0] * 2 / 3) + "," + (p[1] + t[1] * 2 / 3) + "," + lp[0] + "," + lp[1];
1162:     return path;
1176: ...(44 bytes skipped)...s[0], x0 = pi[0], y0 = pi[1], px = [ x0, x0, x0, (pi = points[1])[0] ], py = [ y0, y0, y0, pi[1] ], path = [ x0, ",", y0 ];
1177:     d3_svg_lineBasisBezier(path, px, py);
1184:       d3_svg_lineBasisBezier(path, px, py);
1192:       d3_svg_lineBasisBezier(path, px, py);
1194:     return path.join("");
1198:     var path = [], i = -1, n = points.length, pi, px = [ 0 ], py = [ 0 ];
1204:     path.push(d3_svg_lineDot4(d3_svg_lineBasisBezier3, px) + "," + d3_svg_lineDot4(d3_svg_lineBasisBezier3, ...(6 bytes skipped)...
1212:       d3_svg_lineBasisBezier(path, px, py);
1214:     return path.join("");
1217:     var path, i = -1, n = points.length, m = n + 4, pi, px = [], py = [];
1223:     path = [ d3_svg_lineDot4(d3_svg_lineBasisBezier3, px), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, py)...(4 bytes skipped)...
1231:       d3_svg_lineBasisBezier(path, px, py);
1233:     return path.join("");
1251:   function d3_svg_lineBasisBezier(path, x, y) {
1252:     path.push("C", d3_svg_lineDot4(d3_svg_lineBasisBezier1, x), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier1...(207 bytes skipped)...
4383:         var tick = g.selectAll("g").data(ticks, String), tickEnter = tick.enter().insert("g", "path").style("opacity", 1e-6), tickExit = d3.transition(tick.exit()).style("opacity", 1e-6).remove(), ti...(67 bytes skipped)...
4384:         var range = d3_scaleRange(scale), path = g.selectAll(".domain").data([ 0 ]), pathEnter = path.enter().append("path").attr("class", "domain"), pathUpdate = d3.transition(path);
6080:   d3.geo.path = function() {
6082:       if (typeof pointRadius === "function") pointCircle = d3_path_circle(pointRadius.apply(this, arguments));
6111:     var pointRadius = 4.5, pointCircle = d3_path_circle(pointRadius), projection = d3.geo.albersUsa(), buffer = [];
6178:     var areaType = path.area = d3_geo_type({
6201:     var centroidType = path.centroid = d3_geo_type({
6220:     path.projection = function(x) {
6222:       return path;
6224:     path.pointRadius = function(x) {
6227:         pointCircle = d3_path_circle(pointRadius);
6229:       return path;
6231:     return path;
4401:             pathUpdate.attr("d", "M" + range[0] + "," + tickEndSize + "V0H" + range[1] + "V" + tickEndSize);
4414:             pathUpdate.attr("d", "M" + range[0] + "," + -tickEndSize + "V0H" + range[1] + "V" + -tickEndSize);
4427:             pathUpdate.attr("d", "M" + -tickEndSize + "," + range[0] + "H0V" + range[1] + "H" + -tickEndSize);
4440:             pathUpdate.attr("d", "M" + tickEndSize + "," + range[0] + "H0V" + range[1] + "H" + tickEndSize);
4923:       var paths = [], i = -1, n = links.length;
4924:       while (++i < n) paths.push(d3_layout_bundlePath(links[i]));
4925:       return paths;
6083:       pathType(d);
6112:     var pathType = d3_geo_type({
6115:         while (++i < n) buffer.push(pathType(features[i].geometry));
6118:         pathType(o.geometry);
6175:         while (++i < n) buffer.push(pathType(geometries[i]));
TEQC:R/multiTEQCreport.R: [ ]
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))
RepViz:R/plotGeneTrack.R: [ ]
125:                                  host = "grch37.ensembl.org", path = "/biomart/martservice",
130:                                  host = "grch38.ensembl.org", path = "/biomart/martservice",
138:                                  host = "grch37.ensembl.org", path = "/biomart/martservice",
crlmm:R/cnrma-functions.R: [ ]
42: 	path <- system.file("extdata", package=pkgname)
1391: 	path <- system.file("extdata", package=pkgname)
43: 	##multiple.builds <- length(grep("hg19", list.files(path)) > 0)
44: 	snp.file <- list.files(path, pattern="snpProbes_hg")
47: 		snp.file <- list.files(path, pattern="snpProbes.rda")
51: 			snp.file <- list.files(path, pattern="snpProbes_hg")
61: ##		load(file.path(path, "snpProbes.rda"))
62: ##	} else load(file.path(path, paste("snpProbes_", genome, ".rda", sep="")))
63: 	load(file.path(path, snp.file))
71: 		load(file.path(path, cn.file))
73: 		##			load(file.path(path, "cnProbes.rda"))
74: 		##		} else load(file.path(path, paste("cnProbes_", genome, ".rda", sep="")))
1392: 	load(file.path(path, "cnProbes.rda"))
1393: 	load(file.path(path, "snpProbes.rda"))
1465: 				   path,
1468: 	load(file.path(path, "snpFile.rda"))
1470: 	load(file.path(path, "cnFile.rda"))
megadepth:R/install.R: [ ]
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)) {
IONiseR:R/fast5Readers.R: [ ]
375:         path <- paste0("/Analyses/Basecall_", d, "_000/Log")
376:         exists <- .groupExistsObj(fid, group = path)
378:             did <- H5Dopen(fid, path)
ELMER:R/plots.R: [ ]
892:   readr::write_delim(pairs, path = filename, append = TRUE)
582:         write_tsv(cbind(as.data.frame(pairs)[,c(1:3,6)],corretlation.tab),path = file.name.table)
596:         write_tsv(cbind(as.data.frame(pairs)[,c(1:3,6)],corretlation.tab),path = file.name.table)
942:       filename <- file.path(dir,track.names[idx])
944:       filename <- file.path(dir,paste0(sample,".bw"))
962: #' dir(path = "analysis",
1036:                   ret <- summarizeTF(path = x,
1071:                         function(path){
1072:                           TF <- readr::read_csv(dir(path = path, pattern = ".significant.TFs.with.motif.summary.csv",
1074:                           motif <- readr::read_csv(dir(path = path, pattern = ".motif.enrichment.csv",
1097:                           function(path){
1098:                             TF <- readr::read_csv(dir(path = path, 
1101:                             motif <- readr::read_csv(dir(path = path, 
1109:                             TF.meth.cor <- get(load(dir(path = path, pattern = ".TFs.with.motif.pvalue.rda", recursive = T, full.names = T)))
1152:                              function(path){
1153:                                TF <- readr::read_csv(dir(path = path, 
1157:                                motif <- readr::read_csv(dir(path = path, 
1167:                                TF.meth.cor <- get(load(dir(path = path, 
1181:                                TF.meth.cor$analysis <- path
signatureSearch:R/utilities.R: [ ]
278:     path <- suppressMessages(eh[[ehid]])
281:         path <- eh[[ehid]]
269:     h5path <- eh[[ehid]]
272:         h5path <- eh[[ehid]]
409:     db_path <- determine_refdb(refdb)
32: #' @param h5file character(1), path to the hdf5 destination file
54: #' the file path and compression level. The empty HDF5 file has under its root
59: #' @param h5file character(1), path to the HDF5 file to be created
61: #' identical path
94: #' @param h5file character(1), path to existing HDF5 file that can be empty or
137: #' @param gctx character(1), path to gctx file from LINCS
142: #' @param h5file character(1), path of the hdf5 destination file
179: #' @param gmtfile character(1), path to gmt file containing gene sets
180: #' @param dest_h5 character(1), path of the hdf5 destination file
270:     tryCatch(h5ls(h5path), error=function(e){
271:         unlink(h5path)
274:     return(h5path)
279:     conn <- tryCatch(dbConnect(SQLite(), path), error=function(e){
280:         unlink(path)
282:         dbConnect(SQLite(), path)
313: #' or path to the HDF5 file built from \code{\link{build_custom_db}} function
341:                 "or path to an HDF5 file representing reference database!")
410:     pmat <- HDF5Array(db_path, name="padj")
411:     rownames(pmat) <- as.character(HDF5Array(db_path, name="rownames"))
412:     colnames(pmat) <- as.character(HDF5Array(db_path, name="colnames"))
540: #' gmt_path <- system.file("extdata/test_gene_sets_n4.gmt", package="signatureSearch")
541: #' geneSets <- read_gmt(gmt_path)
520: #' Pathway information will be returned as a list of gene sets.
546:         stop("Pathway information must be a .gmt file")
TrajectoryGeometry:R/TrajectoryGeometry.R: [ ]
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
467: ## ' requiring the path to stay in the non-negative orthant or allowing
470: ## ' @param path - An n x d matrix.
477:     n = nrow(path)
478:     d = ncol(path)
484:         stepLengths = getStepLengths(path)
493:         randomPath[1,] = path[1,]
515: #' This finds the lengths of the steps along a path
517: #' @param path - This is an mxn dimensional matrix. Each row is
519: #' @param from - The starting place along the path which will be
521: #' @param to - The end point of the path.  This defaults to
522: #'     nrow(path).
524: #'     ncol(path)
525: #' @return This function returns the length of each step in a path.
528: #' stepLengths = getStepLengths(path=crooked_path)
529: #' stepLengths = getStepLengths(path=crooked_path,from=4)
530: getStepLengths = function(path,from=1,to=nrow(path),d=ncol(path))
532:     getStepLengthsTest(path,from,to,d)
536:     path = path[from:to,seq_len(d)]
537:     n = nrow(path)
541:         stepLengths[i] = Norm(path[i+1,] - path[i,])
551: #' for the appropriate center for each path.  Each path
562: #'     generateRandomPaths(path=straight_path,randomizationParam='bySteps',N=5)
604: #' Measure a path's progression
606: #' This function measures the progress of a path in a specified
611: #' @param path - An n x d matrix
612: #' @param from - The point along the path to be taken as the starting
614: #' @param to - The point along the path to be used as the end point.
615: #'     This defaults to nrow(path).
616: #' @param d - The dimension to be used.  This defaults to ncol(path).
620: #'     of the path along the line through its starting point in the
625: #'     pathProgression(straight_path,direction=straight_path_center)
627: #'     pathProgression(crooked_path,from=6,direction=crooked_path_center)
631:     pathProgressionTest(path,from,to,d,direction)
633:     path = path[from:to,seq_len(d)]
635:     distance = numeric(nrow(path)-1)
636:     for(i in 2:nrow(path))
638:         delta = path[i,] - path[1,]
646: #' Sample a path from single cell data
652: #' coordinates of the sampled path. The matrix of attribute values should
657: #' the sampled path give the window number a cell was sampled from.
664: #' @return sampledPath - A path consisting of a matrix of attributes of sampled
675:     ## Set parameters for path.
726: #' and comparing each path to random paths.
731: #' The function returns a list of Answers for each comparison of a sampled path
732: #' to a random path.
746: #'     comparison to the given path (defaults to 1000).
748: #'   information comparing a sampled path to random paths.
750: #'   pValue - the p-value for the path and statistic in question;
751: #'   sphericalData - a list containing the projections of the path to
797:         answers[[i]] = testPathForDirectionality(path, randomizationParams =
835: #'     comparison to the given path (defaults to 1000).
839: #'    entry for each sampled path.
841: #'    sampled path in question
843: #'    pValue - the p-value for the path and statistic in question;
844: #'    sphericalData - a list containing the projections of the path to
1070: #' Plot a path, its projection, its center and its circle
1072: #' This function assumes you have a path in dimension 3 and you have
1075: #' appropriate statistic.  Scales the path to keep it comparable to
1079: #' @param path - A path of dimension 3 in the form of an N x 3 matrix.
1083: #' @param to - Likewise.  It defaults to nrow(path).
1085: #'     path.
1088: #' @param color - The color to use for this path and its associated
1093: #'     path. Defaults to 8.
1095: #'     projected path. Defaults to 8.
1096: #' @param scale - The path will be start (its actual start) at 0 and
1108: #' plotPathProjectionCenterAndCircle(path=straight_path,
1109: #'                                  projection=straight_path_projection,
1110: #'                                  center=straight_path_center,
1111: #'                                  radius=straight_path_radius,
1116:                                             to=nrow(path),
1127:     plotPathProjectionCenterAndCircleTest(path,from,to,projection,
1143:     ## Translate the path to begin at the origin and scale:
1144:     N = nrow(path)
1146:     offset = path[1,]
1149:         path[i,] = path[i,] - offset
1150:         distances[i] = Norm(path[i,])
1152:     path = (scale / max(distances)) * path
1163:     ## Plot the path and mark the relevant portion:
1164:     points3d(path,size=pathPointSize,color=color)
1165:     lines3d(path,lwd=pathLineWidth,color=color)
1167:     points3d(path[from:to,],size=pathPointSize+relevantPortionPointHump,
1169:     lines3d(path[from:to,],lwd=pathLineWidth+relevantPortionLineHump,
4: ## Code for testing directionality in paths:
23: #'     control the production of randomized paths for comparison.
24: #' @param N - The number of random paths to generated for statistical
32: #'     paths;
60:     ## Generate random paths:
66:     ## Compute the distance statistics for random paths:
250: #' This is a simplified wrapper for pathToSphericalData
365: #' @param N - The number of random paths required.
404: ## ' Produce randomized paths by permutation
416: ## ' @param N - The number of paths required.
417: ## ' @return This function returns a list of random paths.
435:                 randomPath[,j] = randomPath[perm,j]
437:             randomPathList[[i]] = randomPath
460: ## ' Produce randomized paths by steps
473: ## ' @param N - The number of paths required.
474: ## ' @return This function returns a list of random paths.
488:     ## Generate the random paths:
496:             randomPath[j+1,] = randomPath[j,] +
501:             idx = randomPath < 0
502:             randomPath[idx] = - randomPath[idx]
505:         randomPathList[[i]] = randomPath
547: #' Produce distance statistics for random paths
549: #' This function takes a list of paths and a choice of
553: #' will be the randomized paths.  It is therefore assumed
556: #' @param paths - A list of paths.  Each of these is an n x d matrix.
561: #' paths =
563: #' distance = getDistanceDataForPaths(paths=paths,statistic='max')
566:     getDistanceDataForPathsTest(paths,statistic)
568:     n = nrow(paths[[1]])
569:     N = length(paths)
573:     ## Iterate over paths:
576:         sphericalData = getSphericalData(paths[[i]],statistic)
668: #' samplePath(chol_attributes, chol_pseudo_time_normalised)
669: #' samplePath(hep_attributes, hep_pseudo_time_normalised)
679:     windowSize = pathLength/nWindows
710:     sampledPath = rbind(sampledPath, chosenAttributes)
717:     rownames(sampledPath) = windowNumber
718:     return(sampledPath)
725: #' This function analyses a single cell trajectory by sampling multiple paths
738: #'     control the production of randomized paths for comparison.
740: #' @param nSamples - The number of sampled paths to generate (default 1000).
745: #' @param N - The number of random paths to generated for statistical
755: #'     paths;
794:     ## Sample paths and test each one for directionality
800:             print(paste(i, "sampled paths analysed"))
818: #'     control the production of randomized paths for comparison.
829: #' @param nSamples - The number of sampled paths to generate (defaults to 1000).
834: #' @param N - The number of random paths to generated for statistical
842: #'    to random paths. The entries consist of:
848: #'     paths;
967: ## Code for plotting paths and their spherical data:
1077: #' called repeatedly to add additional paths in different colors.
1092: #' @param pathPointSize - Sets the size of points which represent the
1100: #'     here when plotting multiple paths.
1104: #'     additional paths to the same figure.
1122:                                             pathPointSize = 8,
1129:                                         pathPointSize,projectionPointSize,
1194: #' metrics for sampled paths to random paths. It can also create plots for
1195: #' comparing two sets of sampled paths by providing the traj2Data argument.
1205: #'  stats - output of wilcox test (paired if comparing sampled to random paths,
1206: #'  unpaired if comparing sampled paths for two different trajectories)
1270:     ## Code for comparing sampled pathways to random pathways
1286:         ## Use paired wilcox test to compare values sampled and random pathways,
1287:         ## as random trajectories are parametised based on the sampled pathways
1317: #'     paths for different trajectory different starting points
1319: #'    comparing sampled paths to random paths for different trajectory starting
67:     distances = getDistanceDataForPaths(randomPaths,statistic)
418: generateRandomPathsByPermutation =
439:         return(randomPathList)
453:             randomPathList[[i]] = matrix(b,nrow=n)
455:         return(randomPathList)
508:     return(randomPathList)
672:     samplePathTest(attributes, pseudotime, nWindows)
spikeLI:R/collapse.R: [ ]
18:         path <- system("pwd",TRUE);
20:                 {postscript(paste(path,paste("/",probe_set[1],sep=""),sep=""));}
21:         else    {postscript(paste(path,paste("/",filename,sep=""),sep=""));}
AffiXcan:R/AffiXcan.R: [ ]
642:     for(path in tbaPaths) {
643:         tba <- readRDS(path)
6: #' @param tbaPaths A vector of strings, which are the paths to
186: #' @param tbaPaths A vector of strings, which are the paths to
623: #' @param tbaPaths, A vector of strings, which are the paths to
654: #' @param tbaPaths A vector of strings, which are the paths to
1064: #' @param tbaPaths A vector of strings, which are the paths to
38: #'  objects listed in the param tbaPaths. Each of these lists contain two
92: #' trainingTbaPaths <- system.file("extdata","training.tba.toydata.rds",
102: #' tbaPaths=trainingTbaPaths, regionAssoc=regionAssoc, cov=trainingCovariates,
105: affiXcanTrain <- function(exprMatrix, assay, tbaPaths, regionAssoc, cov=NULL,
107:     regionsCount <- overlookRegions(tbaPaths)
131:         pca <- affiXcanPca(tbaPaths, varExplained, scale, regionsCount,
141:             pcs <- affiXcanPcs(tbaPaths, affiXcanTraining, scale, BPPARAM,
194: #' every MultiAssayExperiment RDS object indicated in the param tbaPaths; it is
200: #' of MultiAssayExperiment objects from tbaPaths) of the samples that have to
205: #' listed in the param tbaPaths. Each of these lists contain two objects:
221: #' tbaPaths <- system.file("extdata","training.tba.toydata.rds",
223: #' regionsCount <- overlookRegions(tbaPaths)
235: #' pca <- affiXcanPca(tbaPaths=tbaPaths, varExplained=80, scale=TRUE,
238: affiXcanPca <- function(tbaPaths, varExplained=80, scale=TRUE, regionsCount,
244:     for(i in seq(1,length(tbaPaths))) {
246:         tbaMatrixMAE <- readRDS(tbaPaths[i])
376: #' of MultiAssayExperiment objects from tbaPaths) of the samples that have to
401: #' tbaPaths <- system.file("extdata","training.tba.toydata.rds",
403: #' regionsCount <- overlookRegions(tbaPaths)
416: #' pca <- affiXcanPca(tbaPaths=tbaPaths, varExplained=80, scale=TRUE,
516: #' tbaPaths <- system.file("extdata","training.tba.toydata.rds",
518: #' regionsCount <- overlookRegions(tbaPaths)
531: #' pca <- affiXcanPca(tbaPaths=tbaPaths, varExplained=80, scale=TRUE,
627: #' MultiAssayExperiment RDS object indicated in the param tbaPaths
633: #' testingTbaPaths <- system.file("extdata","testing.tba.toydata.rds",
636: #' regionsCount <- overlookRegions(tbaPaths=testingTbaPaths)
638: overlookRegions <- function(tbaPaths) {
663: #' of MultiAssayExperiment objects from tbaPaths) of the samples that have not
680: #' trainingTbaPaths <- system.file("extdata","training.tba.toydata.rds",
682: #' testingTbaPaths <- system.file("extdata","testing.tba.toydata.rds",
688: #' tbaPaths=trainingTbaPaths, regionAssoc=regionAssoc, cov=trainingCovariates,
691: #' pcs <- affiXcanPcs(tbaPaths=testingTbaPaths, affiXcanTraining=training,
694: affiXcanPcs <- function(tbaPaths, affiXcanTraining, scale, BPPARAM=bpparam(),
700:     for(i in seq(1,length(tbaPaths))) {
703:         tbaMatrixMAE <- readRDS(tbaPaths[i])
746: #' trainingTbaPaths <- system.file("extdata","training.tba.toydata.rds",
756: #' tbaPaths=trainingTbaPaths, regionAssoc=regionAssoc, cov=trainingCovariates,
801: #' trainingTbaPaths <- system.file("extdata","training.tba.toydata.rds",
811: #' tbaPaths=trainingTbaPaths, regionAssoc=regionAssoc, cov=trainingCovariates,
814: #' testingTbaPaths <- system.file("extdata","testing.tba.toydata.rds",
817: #' pcs <- affiXcanPcs(tbaPaths=testingTbaPaths, affiXcanTraining=training,
863: #' trainingTbaPaths <- system.file("extdata","training.tba.toydata.rds",
873: #' tbaPaths=trainingTbaPaths, regionAssoc=regionAssoc, cov=trainingCovariates,
876: #' testingTbaPaths <- system.file("extdata","testing.tba.toydata.rds",
879: #' pcs <- affiXcanPcs(tbaPaths=testingTbaPaths, affiXcanTraining=training,
967: #' trainingTbaPaths <- system.file("extdata","training.tba.toydata.rds",
977: #' tbaPaths=trainingTbaPaths, regionAssoc=regionAssoc, cov=trainingCovariates,
980: #' imputedExpr <- affiXcanImpute(tbaPaths=trainingTbaPaths,
1029: #' trainingTbaPaths <- system.file("extdata","training.tba.toydata.rds",
1039: #' tbaPaths=trainingTbaPaths, regionAssoc=regionAssoc, cov=trainingCovariates,
1042: #' imputedExpr <- affiXcanImpute(tbaPaths=trainingTbaPaths,
1078: #' trainingTbaPaths <- system.file("extdata","training.tba.toydata.rds",
1088: #' tbaPaths=trainingTbaPaths, regionAssoc=regionAssoc,
1091: #' testingTbaPaths <- system.file("extdata","testing.tba.toydata.rds",
1094: #' exprmatrix <- affiXcanImpute(tbaPaths=testingTbaPaths,
1096: affiXcanImpute <- function(tbaPaths, affiXcanTraining, scale=TRUE,
1098:     regionsCount <- overlookRegions(tbaPaths)
1104:                     tbaPaths refers to ", regionsCount, " regions\n"))
1109:     pcs <- affiXcanPcs(tbaPaths, affiXcanTraining, scale, BPPARAM)
nempi:other/TCGA.r: [ ]
23: path <- "mutclust/"
31:     if (file.exists(paste0(path, type, "_final.rda")) & !newmut & !newllr & !newsave) {
32:         load(paste0(path, type, "_final.rda"))
39:         if (file.exists(paste0(path, type, "_meth.rda"))) {
40:             load(paste0(path, type, "_meth.rda"))
80:             save(meth, file = paste0(path, type, "_meth.rda"))
86:         if (file.exists(paste0(path, type, "_cnv.rda"))) {
87:             load(paste0(path, type, "_cnv.rda"))
102:             save(cnv, file = paste0(path, type, "_cnv.rda"))
108:         if (file.exists(paste0(path, type, "_query.rda"))) {
109:             load(paste0(path, type, "_query.rda"))
128:             save(data, file = paste0(path, type, "_query.rda"))
137:         if (file.exists(paste0(path, type, "_mut.rda"))) {
138:             load(paste0(path, type, "_mut.rda"))
155:             save(mut, file = paste0(path, type, "_mut.rda"))
159:         if (file.exists(paste0(path, type, "_clin.rda"))) {
160:             load(paste0(path, type, "_clin.rda"))
163:             save(clinical, file = paste0(path, type, "_clin.rda"))
167:         if (file.exists(paste0(path, type, "_mut0.rda")) & !newmut) {
168:             load(paste0(path, type, "_mut0.rda"))
234:             save(M0, Mtype0, file = paste0(path, type, "_mut0.rda"))
263:         if (file.exists(paste0(path, type, "_llr.rda")) & !newllr) {
264:             load(paste0(path, type, "_llr.rda"))
345:             save(tmp, DF, file = paste0(path, type, "_llr.rda"))
381:         save(clinical, D, M, Mtype, DF, class, meth, cnv, file = paste0(path, type, "_final.rda"))
406: path <- "mutclust/"
408: load(paste0(path, type, "_final.rda"))
545: path <- ""
552:     load(paste0(path, type, "_nempi.rda"))
570:     load(paste0(path, type, "_nempi.rda"))
588:     load(paste0(path, type, "_nempi.rda"))
611:     load(paste0(path, type, "_nempi.rda"))
629:     load(paste0(path, type, "_nempi.rda"))
683: ## save(nempires, knnres, rfres, mfres, svmres, nnres, Rho, D2, Pmut, Pmeth, Pcnv, file = paste0(path, type, "_nempi.rda"))
685: path <- "mutclust/"; type <- "TCGA-BRCA"
687: load(paste0(path, type, "_nempi.rda"))
908: load(paste0(path, type, "_nempi.rda"))
sevenbridges:inst/extdata/app/flow_star.json: [ ]
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)...
PloGO2:inst/script/WGCNA_proteomics.R: [ ]
106: path <- system.file("files", package="PloGO2")
107: allDat = read.csv(file.path(path,"rice.csv") )
108: Group = read.csv(file.path(path, "group_rice.csv") ) [,2]
SMITE:R/SMITE.R: [ ]
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)
isobar:R/ProteinGroup-class.R: [ ]
424:                       host="www.ebi.ac.uk",path="/uniprot/biomart/martservice")
ggtree:R/tree-utilities.R: [ ]
720:     path <- c(anc_from[1:i], rev(anc_to[1:(j-1)]))
726:     path <- get.path(phylo, from, to)
694:     path_length <- sapply(1:(root-1), function(x) get.path_length(tr, root, x))
710: get.path <- function(phylo, from, to) {
978:     pathLength <- sapply(1:length(tr$tip.label), function(i) {
725: get.path_length <- function(phylo, from, to, weight=NULL) {
695:     i <- which.max(path_length)
696:     return(get.path(tr, root, i))
699: ##' path from start node to end node
702: ##' @title get.path
721:     return(path)
728:         return(length(path)-1)
743:     for(i in 1:(length(path)-1)) {
744:         ee <- get_edge_index(df, path[i], path[i+1])
979:         get.path_length(tr, i, root, yscale)
982:     ordered_tip <- order(pathLength, decreasing = TRUE)
cTRAP:R/shinyInterface.R: [ ]
475:                 if (is.function(path)) path <- path()
418:                                         path=".", globalUI=FALSE) {
476:                 ENCODEsamples <- loadENCODEsamples(ENCODEmetadata, path=path)
1194:     inputFile  <- file.path(token, sprintf("input_%s.Rda",  rand))
1195:     outputFile <- file.path(token, sprintf("output_%s.rds", rand))
1380: .predictTargetingDrugsServer <- function(id, x, path=".", globalUI=FALSE,
1405:                 corMatrix, path=path)
1469: .drugSetEnrichmentAnalyserServer <- function(id, x, path=NULL) {
1492:                                            path=path)
1665:                                  file="ENCODEmetadata.rds", path=".") {
1670:         .diffExprENCODEloaderServer(id, metadata, cellLine, gene, path=path)