Results for path -file:Rd

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)="path*wayimage"')
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[[path*ways[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",

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)

Search examples:

To list packages, try:

Found 80062 results in 7813 files, showing top 50 files (show more).