DomFun 0.1.0

data/bin/generate_CAFA2_dataset.rb

@@ -0,0 +1,135 @@
+#! /usr/bin/env ruby
+
+require 'optparse'
+
+##########################
+#MODULES
+#########################
+
+module Enumerable
+
+    def sum
+      self.inject(0){|accum, i| accum + i }
+    end
+
+    def mean
+      self.sum/self.length.to_f
+    end
+
+    def sample_variance
+      m = self.mean
+      sum = self.inject(0){|accum, i| accum +(i-m)**2 }
+      sum/(self.length - 1).to_f
+    end
+
+    def standard_deviation
+      Math.sqrt(self.sample_variance)
+    end
+
+end 
+
+##########################
+#METHODS
+#########################
+# Corregir el input de combined scores
+
+def load_predictions(input_file)
+	predictions = {}
+	File.open(input_file).each do |line|
+		line.chomp! 
+    proteinID, domains, go_term, p_value = line.split("\t")	
+    query = predictions[proteinID]
+    if query.nil?
+      predictions[proteinID] = [[go_term, p_value.to_f]]
+    else
+      query << [go_term, p_value.to_f]
+    end 
+  end
+  return predictions
+end
+
+def translate_protein_ids(cafa_file, predictions)
+  cafa_predictions = []
+  File.open(cafa_file).each do |line|
+    line.chomp!
+    cafa_data = line.split("\t")
+    cafaID = cafa_data[3]
+    proteinID = cafa_data[6]
+    go_associations = predictions[proteinID]
+    unless go_associations.nil?
+      go_associations.each do |goID, value|
+        cafa_predictions << [cafaID, goID, value]
+      end
+    end 
+  end
+  return cafa_predictions
+end
+
+def normalize_association_values(cafa_predictions)
+  raw_association_values = []
+  normalized_prediction_values = []
+  cafa_predictions.each do |protID, goTerm, value|
+    raw_association_values << value.to_f
+  end
+  raw_values_mean = raw_association_values.mean
+  raw_values_sd = raw_association_values.standard_deviation
+  association_values_minus_mean = []
+  raw_association_values.each do |value|
+    z_score = (value - raw_values_mean).fdiv(raw_values_sd)
+    if z_score > 2 
+      z_score = 2
+    elsif z_score < -2
+      z_score = -2
+    end
+    z_score = z_score.fdiv(5) + 0.5
+    association_values_minus_mean << z_score
+  end
+  cafa_predictions.each_with_index do |info, c|
+    protID, goTerm, association_values = info
+    normalized_prediction_values << [protID, goTerm, association_values_minus_mean[c]]
+  end
+  cafa_predictions = normalized_prediction_values
+  return cafa_predictions
+end
+
+##########################
+#OPT-PARSER
+##########################
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{__FILE__} [options]"
+
+  options[:input_predictions] = nil
+  opts.on("-a", "--input_predictions PATH", "Input predictions file") do |input_predictions|
+    options[:input_predictions] = input_predictions
+  end
+
+  options[:input_cafa] = nil
+  opts.on("-c", "--input_cafa PATH", "Input CAFA file to translate UniProtIDs to CAFAIDs") do |input_cafa|
+    options[:input_cafa] = input_cafa
+  end
+
+  options[:output_file] = 'results_to_CAFA2_validation.txt'
+  opts.on("-o", "--output_file PATH", "Output file") do |output_file|
+    options[:output_file] = output_file
+  end
+
+  options[:do_norm] = false
+  opts.on("-n", "--do_norm", "Normalize prediction values") do
+    options[:do_norm] = true
+  end
+
+end.parse!
+
+##########################
+#MAIN
+##########################
+
+predictions = load_predictions(options[:input_predictions])
+cafa_predictions = translate_protein_ids(options[:input_cafa], predictions)
+cafa_predictions = normalize_association_values(cafa_predictions) if options[:do_norm]
+
+handler = File.open(options[:output_file], 'w')
+cafa_predictions.each do |info|
+  handler.puts "#{info.join("\t")}"
+end

data/bin/generate_CAFA2_tripartite_network.rb

@@ -0,0 +1,139 @@
+#! /usr/bin/env ruby
+##########################
+# Rojano E. & Seoane P., July 2019
+# Generate training and testing datasets from CAFA2 and UniProt data.
+# This script translate identifiers and generate the file for the
+# construction of tripartite network (domain-protein-FunSys)
+##########################
+
+REPORT_FOLDER=File.expand_path(File.join(File.dirname(__FILE__), '..', 'templates'))
+ROOT_PATH = File.dirname(__FILE__)
+$: << File.expand_path(File.join(ROOT_PATH, '..', 'lib', 'DomFun'))
+require 'generalMethods.rb'
+require 'optparse'
+require 'csv'
+
+##########################
+#METHODS
+##########################
+
+def load_hash(filename, mode)
+	container = {}
+	File.open(filename).each do |line|
+		line.chomp!
+		key, value = line.split("\t") if mode == 'a'
+		value, key = line.split("\t") if mode == 'b'
+		query = container[key]
+		if query.nil?
+			container[key] = [value]
+		else
+			query << value
+		end
+	end
+	return container
+end
+
+def build_tripartite_network(domain_tuples, annot_tuples, filename)
+	handler = File.open(filename, 'w')
+	annot_tuples.each do |protID, annots|
+		annots.each do |a|
+			handler.puts "#{a}\t#{protID}"
+		end
+	end
+	domain_tuples.each do |protID, doms|
+		doms.each do |d|
+			handler.puts "#{d}\t#{protID}"
+		end
+	end
+	handler.close
+end
+
+def load_cath_info(cath_file, domain_class)
+	proteins_2_domains = {}
+	File.open(cath_file).each do |line|
+		line.chomp!
+		protID, superfam, funfam = line.split("\t")
+		query = proteins_2_domains[protID]
+		if domain_class == 'superfamilyID'
+			domain_type = superfam
+		else
+			domain_type = funfam
+		end
+		if query.nil?
+			proteins_2_domains[protID] = [domain_type]
+		else
+			query << domain_type
+		end
+
+	end
+	return proteins_2_domains
+end
+
+def generate_tuples(prot_annots, prot_domains)
+	domain_tuples = {}
+	annot_tuples = {}
+	prot_annots.each do |protID, annots|
+		domains = prot_domains[protID]
+		unless domains.nil?
+			domains.each do |d|	
+				query = domain_tuples[protID]
+				if query.nil?
+					domain_tuples[protID] = [d]
+				else
+					query << d unless query.include?(d)
+				end
+			end
+		end
+		annots.each do |a|
+			query = annot_tuples[protID]
+			if query.nil?
+				annot_tuples[protID] = [a]
+			else
+				query << a unless query.include?(a)
+			end
+		end
+	end
+	return domain_tuples, annot_tuples
+end
+
+##########################
+#OPT-PARSER
+##########################
+options = {}
+OptionParser.new do |opts|
+	opts.banner = "Usage: #{__FILE__} [options]"
+
+	options[:protein_domains] = nil
+		opts.on("-a", "--protein_domains PATH", "Training proteins with CATH domains") do |data|
+		options[:protein_domains] = data
+	end
+
+	options[:annotated_proteins] = nil
+		opts.on("-b", "--annotated_proteins PATH", "Training proteins with annotations") do |data|
+		options[:annotated_proteins] = data
+	end
+
+	options[:domain_class] = 'funfamID'
+		opts.on("-d", "--domain_class STRING", "Domain identifiers type. Please choose funfamID or superfamilyID") do |data|
+		options[:domain_class] = data
+	end
+
+	options[:output_network] = 'tripartite_network.txt'
+		opts.on("-o", "--output_network PATH", "Output tripartite network from CAFA information") do |data|
+		options[:output_network] = data
+	end
+
+	opts.on_tail("-h", "--help", "Tool information") do
+		puts opts
+		exit
+	end
+
+end.parse!
+
+##########################
+#MAIN
+##########################
+proteins_with_annotations = load_hash(options[:annotated_proteins], 'a')
+proteins_2_domains = load_cath_info(options[:protein_domains], options[:domain_class])
+domain_tuples, annot_tuples = generate_tuples(proteins_with_annotations, proteins_2_domains)
+build_tripartite_network(domain_tuples, annot_tuples, options[:output_network])

data/bin/generate_cafa_control.rb

@@ -0,0 +1,45 @@
+#! /usr/bin/env ruby
+##########################
+# Rojano E. & Seoane P., July 2019
+# Generate control from CAFA data (proteins and GO terms)
+##########################
+
+REPORT_FOLDER=File.expand_path(File.join(File.dirname(__FILE__), '..', 'templates'))
+ROOT_PATH = File.dirname(__FILE__)
+$: << File.expand_path(File.join(ROOT_PATH, '..', 'lib', 'DomFun'))
+require 'optparse'
+require 'generalMethods.rb'
+
+##########################
+#OPT-PARSER
+##########################
+options = {}
+OptionParser.new do |opts|
+	opts.banner = "Usage: #{__FILE__} [options]"
+
+	options[:input_cafa] = nil
+		opts.on("-a", "--input_cafa PATH", "Input CAFA file") do |data|
+		options[:input_cafa] = data
+	end
+
+	options[:output_file] = 'cafa_control.txt'
+		opts.on("-o", "--output_file PATH", "Output control from CAFA data") do |data|
+		options[:output_file] = data
+	end
+
+	opts.on_tail("-h", "--help", "Tool information") do
+		puts opts
+		exit
+	end
+
+end.parse!
+
+##########################
+#MAIN
+##########################
+cafa_data = load_cafa_data(options[:input_cafa])
+handler = File.open(options[:output_file], 'w')
+cafa_data.each do |protein, goTerms|
+	handler.puts "#{protein}\t#{goTerms.join(';')}"
+end
+handler.close

data/bin/get_kegg_pathways.R

@@ -0,0 +1,12 @@
+#! /usr/bin/env Rscript
+
+# Get KEGG pathways from hsa identifiers.
+
+###################
+# LIBRARIES
+###################
+
+library(KEGGREST)
+res <- keggLink("pathway", "hsa")
+write.table(cbind(names(res), res), col.names=FALSE, quote=FALSE, sep="\t", row.names=FALSE, file = "kegg_pathways.txt")
+

data/bin/lines.R

@@ -0,0 +1,74 @@
+#! /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("-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)
+	if(opt$no_legend){
+		obj <- obj + guides(color=FALSE)	
+	}
+	obj
+dev.off()
+

data/bin/merge_pairs.rb

@@ -0,0 +1,139 @@
+#! /usr/bin/env ruby
+
+require 'optparse'
+
+#################################
+## METHODS
+#################################
+def load_pairs(file, key)
+	STDERR.puts key
+	pairsA = {}
+	pairsB = {}
+	File.open(file).each do |line|
+		line.chomp!
+		fields = line.split("\t")
+		if fields.first =~ /#{key}/#.include?(key)
+			save_record(pairsA, fields.last, fields.first )
+		else
+			save_record(pairsB, fields.last, fields.first )
+		end
+	end
+	return pairsA, pairsB
+end
+
+def save_record(hash, key, val)
+  query = hash[key]
+  if query.nil?
+    hash[key] = [val]
+  else
+    query << val
+  end
+end
+
+def generate_files(n_files, output)
+	files = []
+	n_files.times do |n|
+		files << File.open("#{output}#{n+1}.txt", 'w')
+	end
+	return files
+end
+
+def connect_pairs_write(pairsA, pairsB, n_files, files)
+	pairsA.each do |keyA, valA|
+	  valB = pairsB[keyA]
+	  if !valB.nil?
+	    valA.each do |vA|
+	      valB.each do |vB|
+	        files[rand(n_files)].puts "#{vA}\t#{keyA}\t#{vB}"
+	      end
+	    end
+	  end
+	end
+end
+
+def get_relations(pairsA, pairsB)
+	relations = {}
+	pairsA.each do |keyA, valA|
+		valB = pairsB[keyA]
+		if !valB.nil?
+			valA.each do |vA|
+		        	valB.each do |vB|
+      					rel_key = vA + '_' + vB 
+					query = relations[rel_key]
+					if query.nil?
+						relations[rel_key] = [keyA]
+		      			else
+      						query << keyA
+			      		end
+			        end
+			end
+	    	end
+	end
+	return relations
+end
+
+##############################
+#OPTPARSE
+##############################
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{__FILE__} [options]"
+
+  options[:input_file] = nil
+  opts.on("-i", "--input_file PATH", "Input file for create adjacency matrix") do |input_file|
+    options[:input_file] = input_file
+  end
+
+  options[:key] = ''
+  opts.on("-k", "--key STRING", "String to split th two groups") do |key|
+    options[:key] = key
+  end
+
+  options[:output] = 'tri_'
+  opts.on("-o", "--output PATH", "Output network pairs") do |output|
+    options[:output] = output
+  end
+
+  options[:n_files] = 10
+  opts.on("-n", "--n_files INTEGER", "Split data onto n files") do |n|
+    options[:n_files] = n.to_i
+  end
+
+  options[:min_connections] = 1
+  opts.on("-m", "--min_connections INTEGER", "Minimun connections to take into account a relation") do |n|
+    options[:min_connections] = n.to_i
+  end
+
+end.parse!
+
+################################
+## MAIN
+################################
+files = generate_files(options[:n_files], options[:output])
+
+pairsA, pairsB = load_pairs(options[:input_file], options[:key])
+if options[:min_connections] == 1
+	connect_pairs_write(pairsA, pairsB, options[:n_files], files)
+else
+	STDERR.puts "MIN. NUMBER OF CONNECTIONS = #{options[:min_connections]}"
+	relations = get_relations(pairsA, pairsB)
+	count = 0
+	discarded = 0
+	relations.each do |rel, connections|
+		if connections.length >= options[:min_connections]
+			fields = rel.split('_')
+			connections.each do |con|
+				files[rand(options[:n_files])].puts "#{fields.first}\t#{con}\t#{fields.last}"
+			end
+		else
+			discarded += connections.length
+		end
+		count += connections.length
+	end
+	STDERR.puts "Relations: #{count}"
+	STDERR.puts "Discarded: #{discarded}"
+end
+files.each do |f|
+  f.close
+end