pets 0.1.2

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "gephepred"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/fmeasure_index.rb

@@ -0,0 +1,72 @@
+#! /usr/bin/env ruby
+#Code for calculating F measure for precision-recall curves 
+
+require 'optparse'
+
+##########################
+#METHODS
+##########################
+
+def load_pr_data(file)
+	counter = 0
+	pr_data = {}
+	File.open(file).each do |line|
+		if counter > 0
+			line.chomp!
+			cutoff, prec, rec, meth = line.split("\t")
+			query = pr_data[meth]
+			pr_info = [cutoff.to_f, prec.to_f, rec.to_f]
+			if query.nil?
+				pr_data[meth] = [pr_info]
+			else
+				query << pr_info
+			end
+		end
+		counter += 1
+	end
+	return pr_data
+end
+
+def calculate_youden(pr_data)
+	#the max f_measure is the best cutoff
+	best_cutoffs = []
+	pr_data.each do |meth, pr_values|
+		max_f_measure = 0
+		best_cutoff = 0
+		#next if meth != 'cosine'
+		pr_values.each do |cutoff, prec, rec|
+			f_measure = 2 * prec * rec / (prec + rec)
+			if max_f_measure < f_measure
+				max_f_measure = f_measure
+				best_cutoff = cutoff
+			end
+		end
+		best_cutoffs << [meth, best_cutoff]
+	end
+	return best_cutoffs
+end
+
+##########################
+#OPT-PARSE
+##########################
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{__FILE__} [options]"
+
+  options[:input_file] = nil
+  opts.on("-f", "--input_file PATH", "Input file with precision-recall values") do |input_file|
+    options[:input_file] = input_file
+  end
+
+end.parse!
+
+##########################
+#MAIN
+##########################
+
+pr_data = load_pr_data(options[:input_file])
+best_cutoffs = calculate_youden(pr_data)
+#puts best_cutoffs.inspect
+best_cutoffs.each do |cutoffs|
+	puts cutoffs.join("\t")
+end

data/bin/get_PR_values.rb

@@ -0,0 +1,90 @@
+#! /usr/bin/env ruby
+
+N_CUTS = 200
+
+pp_limit = ARGV[1].to_f if !ARGV[1].nil?
+
+count = 0
+values = []
+File.open(ARGV[0]).each do |line|
+	line.chomp!
+	count += 1
+	next if count == 1
+	fields = line.split("\t")
+	values << [fields.first, fields.last.to_f]
+end
+values.sort!{|v1, v2| v1.last <=> v2.last}
+max_score = values.last.last
+min_score = values.first.last
+
+interval = (max_score - min_score).fdiv(N_CUTS)
+cuts = []
+current = min_score
+while cuts.length < N_CUTS
+	cuts << current
+	current += interval
+end
+
+header =  %w[tp tn fp fn cut pre rec]
+header << 'group' if !ARGV[2].nil?
+puts header.join("\t")
+last_pre = 1
+last_rec = 0
+change_data = false
+pre_range = 0
+rec_range = 0
+all_weigths = []
+total_weigth = 0
+cuts.reverse.each_with_index do |cut, i|
+	tp = 0
+	tn = 0
+	fp = 0
+	fn = 0
+	values.each do |label, score|
+		if score >= cut
+			if label == 'in'
+				tp += 1
+			else
+				fp += 1
+			end
+		else
+			if label == 'out'
+				tn += 1
+			else
+				fn += 1
+			end
+		end
+	end
+	pre = tp.fdiv(tp+fp)
+	rec = tp.fdiv(tp+fn)
+	if !ARGV[1].nil? && pp_limit > 0
+		if !change_data
+			pp = pre/last_pre 
+			if pp >= pp_limit
+				change_data = true
+				#pre_range = last_pre/(N_CUTS - i)
+				pre_range = last_pre#/(N_CUTS - i)
+				rec_range = (1 - last_rec)/(N_CUTS - i)
+				(N_CUTS - i).times do |n|
+					all_weigths << (n+1)**8
+					total_weigth += (n+1)**8
+				end
+			else
+				last_pre = pre
+				last_rec = rec
+			end
+		end
+		if change_data
+			tp = tn = fp = fn = 0
+			last_pre -= pre_range * all_weigths.pop.fdiv(total_weigth)
+			last_rec += rec_range
+			pre = last_pre
+			pre = 0 if pre < 0
+			rec = last_rec
+		end
+	end
+	row = [tp, tn, fp, fn, cut, pre, rec]
+	row << ARGV[2] if !ARGV[2].nil?
+	puts row.join("\t")
+end
+

data/bin/get_clusters.R

@@ -0,0 +1,18 @@
+#! /usr/bin/env Rscript
+args <- commandArgs(trailingOnly = TRUE)
+
+file <- args[1]
+output <- args[2]
+
+# matrix_data <- read.table(file, sep="\t", header=TRUE, quote = '')
+matrix_data <- read.table(file, sep="\t", quote = '')
+d <- dist(matrix_data, method = "euclidean") # distance matrix
+fit <- hclust(d, method="ward.D2")
+fit$height <- round(fit$height, 6) 
+groups <- cutree(fit, h=1.5) 
+write.table(groups, file=file.path(output, 'cluster_asignation'), sep="\t", quote=FALSE, col.names=FALSE)
+
+pdf(file.path(output, 'figures.pdf'))
+	plot(fit) # display dendogram
+	rect.hclust(fit, h=1.5, border="red") # draw dendogram with red borders around the 5 clusters
+dev.off()

data/bin/get_network_nodes.rb

@@ -0,0 +1,197 @@
+#! /usr/bin/env ruby
+# Rojano E. & Seoane P., March 2019
+# Code to prepare data to get the associations between pathological phenotypes (HPO) and genomic regions (SOR)
+
+
+ROOT_PATH = File.dirname(__FILE__)
+$: << File.expand_path(File.join(ROOT_PATH, '..', 'lib', 'gephepred'))
+
+##############################
+#LIBRARIES
+##############################
+require 'generalMethods.rb'
+require 'optparse'
+require "benchmark"
+
+###############################
+#METHODS
+###############################
+
+def loadPatientFile(patient_file, hpo_storage, hpo_dictionary, add_parents)
+	patient2phenotype = {}
+	hpo_count = {}
+	not_found = []	
+	patients_genomic_region_by_chr = {}
+	File.open(patient_file).each do |line|
+		line.chomp!
+		next if line.include?("#")
+		patient, chr, start, stop, phenotype_profile = line.split("\t", 5)
+		next if phenotype_profile.nil? #For skipping patients without phenotypes
+		phenotypes = phenotype_profile.split('|')
+		phenotypes.each do |hpo_name|
+			hpo_code = hpo_dictionary[hpo_name]
+			if hpo_code.nil?
+				not_found << hpo_name if !not_found.include?(hpo_name)
+			else
+				get_all_hpos(patient, hpo_code, patient2phenotype, hpo_storage, hpo_count, add_parents)
+			end
+		end
+		info = [patient, start.to_i, stop.to_i]
+		add_record(patients_genomic_region_by_chr, chr, info)
+	end
+	if add_parents == 'coh'
+		general_parents_in_cohort = get_parents_in_patients(patient2phenotype, hpo_storage)
+		parent_patient2phenotype = {} # For new parent hpo added to patients. 
+	end
+	return patient2phenotype, hpo_count, not_found, patients_genomic_region_by_chr
+end
+
+def get_parents_in_patients(patient2phenotype, hpo_storage)
+	all_hpo_codes = []
+	patient2phenotype.each do |patient, hpo_codes|
+		all_hpo_codes = all_hpo_codes | hpo_codes
+	end
+end
+
+def get_all_hpos(patient, hpo_code, patient2phenotype, hpo_storage, hpo_count, add_parents)
+	add_record(hpo_count, hpo_code, patient)
+	add_record(patient2phenotype, patient, hpo_code)
+	if add_parents == 'root'
+		hpo_parent_codes = hpo_storage[hpo_code][2]
+    	hpo_parent_codes.each do |parent_code|
+			get_all_hpos(patient, parent_code, patient2phenotype, hpo_storage, hpo_count, add_parents)
+    	end	
+    end
+end
+
+def build_tripartite_network(patients2hpo, hpo_stats, ic_threshold, patients_by_cluster)
+	tripartite_network = []
+	patients_by_cluster.each do |patient, node_ids|
+		node_ids.each do |node_id|
+			tripartite_network << [node_id, patient] 
+		end
+	end
+	patients_list = patients_by_cluster.keys
+	patients2hpo.each do |patient, code|
+		if patients_list.include?(patient)
+		  code.each do |c|
+			tripartite_network << [c, patient] if hpo_stats[c].last >= ic_threshold 
+		  end
+		end
+	end
+	return tripartite_network
+end
+
+def compute_hpo_stats(hpo_count, patient_number)
+	hpo_stats = {}
+	patient_hpo_ic = []
+	hpo_count.each do |hpo_code, patient_ids|
+	    hpo_freq = patient_ids.length.fdiv(patient_number) #hpo frequency in patients
+	    hpo_ic = -Math.log10(hpo_freq)
+	    hpo_stats[hpo_code] = [hpo_freq, hpo_ic]
+	    patient_ids.each do |patient_id|
+	    	patient_hpo_ic << [patient_id, hpo_code, hpo_ic]
+	    end
+	end
+	return hpo_stats, patient_hpo_ic.sort{|a,b| a.first.to_i <=> b.first.to_i}
+end
+
+def write_hash(hash, file_path, header = [])
+	File.open(file_path, 'w') do |handler|
+ 		handler.puts header.join("\t") if !header.empty?
+ 		hash.each do |key, array|
+ 			handler.puts "#{key}\t#{array.join("\t")}"
+ 		end
+ 	end
+end
+
+def write_array(array, file_path)
+	File.open(file_path, 'w') do |handler|
+		array.each do |record|
+			if record.class == String
+				line = record
+			else
+				line = record.join("\t")
+			end
+			handler.puts line  
+		end
+	end
+end
+
+##############################
+#OPTPARSE
+##############################
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{__FILE__} [options]"
+
+  options[:cluster_file] = 'cluster_coords.txt'
+  opts.on("-c", "--cluster_file PATH", "Cluster coords output file that will be used to translate SOR nodes") do |value|
+    options[:cluster_file] = value
+  end 
+
+  options[:excluded_hpo] = nil
+  opts.on("-e", "--excluded_hpo PATH", "List of HPO phenotypes to exclude (low informative)") do |excluded_hpo|
+    options[:excluded_hpo] = excluded_hpo
+  end
+
+  options[:patient_file] = nil
+  opts.on("-i", "--input_file PATH", "Input file with patients for parsing phenotypes to HPO codes") do |value|
+    options[:patient_file] = value
+  end
+
+  options[:mutation_type] = 'A'
+  opts.on("-m", "--mutation_type STRING", "Type of patient mutation, either it is a deletion (d) or duplication (D)") do |type|
+    options[:mutation_type] = type
+  end
+
+  options[:output_file] = 'tripartite_network.txt'
+  opts.on("-o", "--output_file PATH", "Output file for the tripartite network") do |value|
+    options[:output_file] = value
+  end 
+
+  options[:hpo_file] = nil
+  opts.on("-p", "--hpo_file PATH", "Input HPO file for extracting HPO codes") do |value|
+    options[:hpo_file] = value
+  end
+
+  options[:add_parents] = nil
+  opts.on("-r", "--parents STRING", "'root' to add all parents until the ontology root. 'coh' to add parents until the most general term in the cohort.") do |value|
+    options[:add_parents] = value
+  end 
+
+  options[:hpo_stat_file] = 'hpo_stats.txt'
+  opts.on("-s", "--hpo_stat_file PATH", "Output file with HPO codes, their frequency and CI") do |value|
+    options[:hpo_stat_file] = value
+  end 
+
+  options[:thresold] = 0
+  opts.on("-t", "--info_thresold FLOAT", "IC thresold to discard non informative hpo. Default: 0.") do |thresold|
+    options[:thresold] = thresold.to_f
+  end
+
+  opts.on_tail("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+
+end.parse!
+
+###############################
+#MAIN
+###############################
+hpo_black_list = load_hpo_black_list(options[:excluded_hpo])
+hpo_storage = load_hpo_file(options[:hpo_file], hpo_black_list)
+hpo_dictionary = create_hpo_dictionary(hpo_storage)
+patients2hpo, hpo_count, not_found, chr_patients_genomic_region = loadPatientFile(options[:patient_file], hpo_storage, hpo_dictionary, options[:add_parents])
+hpo_stats, patient_hpo_ic = compute_hpo_stats(hpo_count, patients2hpo.length)
+patients_by_cluster, sors = generate_cluster_regions(chr_patients_genomic_region, options[:mutation_type])
+tripartite_network = build_tripartite_network(patients2hpo, hpo_stats, options[:thresold], patients_by_cluster)
+
+write_array(not_found - hpo_black_list, 'missing_hpo_names')
+write_array(sors, options[:cluster_file])
+write_hash(hpo_stats.select{|hp_code, stats| stats.last > options[:thresold]}, options[:hpo_stat_file], %w[HPOcode Frequency IC])
+write_array(tripartite_network, options[:output_file])
+write_array(patient_hpo_ic, 'filtered_hpo.txt')
+

data/bin/lines.R

@@ -0,0 +1,77 @@
+#! /usr/bin/env Rscript
+
+library(ggplot2)
+library(optparse)
+
+#####################
+## OPTPARSE
+#####################
+option_list <- list(
+	make_option(c("-d", "--data_file"), type="character",
+		help="Tabulated file with information about each sample"),
+	make_option(c("-o", "--output"), type="character", default="results",
+		help="Output figure file"),
+	make_option(c("-x", "--x_column"), type="character", 
+		help="Name of column to be used for X dimension"),
+	make_option(c("-y", "--y_column"), type="character", 
+		help="Name of column to be used for Y dimension"),
+	make_option(c("-s", "--set_column"), type="character", default="",
+        	help="Name of column to be used on set groups"),
+	make_option(c("-L", "--no_legend"), action="store_true", default=FALSE,
+	       	help="Remove legend"),
+	make_option(c("-l", "--legend_title"), type="character", default="Association methods",
+	       	help="Title for legend"),
+	make_option(c("-c", "--colours"), type="character", default="",
+		help="Define which color is asigned to each data series. List colours comma separated."),
+	make_option(c("-m", "--set_geom"), type="character", default="line", 
+		help="Choose the type of graphical representation, using points or lines"),
+	make_option(c("-e", "--establish_limits"), action="store_true", default=FALSE,
+ 	 	help="Allow establishing limits for X and Y axis. If true, please set x_limit and y_limit"),
+	make_option(c("-X", "--x_limit"), type="integer", default=0,
+	 	help="Set x axis limit"),
+	make_option(c("-Y", "--y_limit"), type="integer", default=1,
+		help="Set y axis limit")
+
+)
+opt <- parse_args(OptionParser(option_list=option_list))
+
+
+################################################################
+## MAIN
+################################################################
+
+data <- read.table(opt$data_file, sep="\t", header=TRUE)
+
+pdf(paste(opt$output, '.pdf', sep=""))
+	if(opt$set_column != ""){
+		obj <- ggplot(data, aes(x=data[[opt$x_column]], y=data[[opt$y_column]], color=data[[opt$set_column]]))
+	}else{
+		obj <- ggplot(data, aes(x=data[[opt$x_column]], y=data[[opt$y_column]]))
+	}
+        if(opt$colours != ""){
+                colours <- unlist(strsplit(opt$colours, ','))
+                obj <- obj + scale_color_manual(values=c(colours))
+        }
+
+	if(opt$set_geom == 'point'){ 	
+ 		obj <- obj + geom_point()
+ 	}else if(opt$set_geom == 'line'){
+ 		obj <- obj + geom_line()
+	}
+
+	obj <- obj + xlim(0, 1)
+	obj <- obj + ylim(0, 1)
+	
+	if (opt$establish_limits){
+	 	obj <- obj + xlim(opt$x_limit, 1)
+		obj <- obj + ylim(0, opt$y_limit)
+	 }
+	obj <- obj + xlab(opt$x_column)
+	obj <- obj + ylab(opt$y_column)
+	obj <- obj + labs(fill = opt$legend_title)
+	if(opt$no_legend){
+		obj <- obj + guides(color=FALSE)	
+	}
+	obj
+dev.off()
+