pets 0.2.3 → 0.2.5

data/bin/get_network_nodes.rb

@@ -3,112 +3,34 @@
 # Code to prepare data to get the associations between pathological phenotypes (HPO) and genomic regions (SOR)
 
 ROOT_PATH = File.dirname(__FILE__)
-EXTERNAL_DATA = File.expand_path(File.join(ROOT_PATH, '..', 'external_data'))
-HPO_FILE = File.join(EXTERNAL_DATA, 'hp.obo')
 $: << File.expand_path(File.join(ROOT_PATH, '..', 'lib', 'pets'))
 
 ##############################
 #LIBRARIES
 ##############################
-require 'generalMethods.rb'
 require 'optparse'
-require 'semtools'
+require 'pets'
 
 ###############################
 #METHODS
 ###############################
 
-def loadPatientFile(patient_file, hpo, 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, rejected = hpo.translate_names2codes(phenotypes)
-		phenotypes, rejected = hpo.translate_names(phenotypes)
-		not_found = not_found | rejected
-		phenotypes.each do |hpo_code|
-			get_all_hpos(patient, hpo_code, patient2phenotype, hpo, hpo_count, add_parents) if !hpo.is_removable(hpo_code)
-		end
-		info = [patient, start.to_i, stop.to_i]
-		add_record(patients_genomic_region_by_chr, chr, info)
-	end
-	return patient2phenotype, hpo_count, not_found, patients_genomic_region_by_chr
-end
-
-
-def get_all_hpos(patient, hpo_code, patient2phenotype, hpo, 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.get_parents(hpo_code)
-		hpo_parent_codes = hpo.get_ancestors(hpo_code)
-    	hpo_parent_codes.each do |parent_code|
-			add_record(hpo_count, parent_code, patient)
-			add_record(patient2phenotype, patient, parent_code)
-    	end	
-    end
-end
-
-def build_tripartite_network(patients2hpo, hpo_stats, ic_threshold, patients_by_cluster)
+def build_tripartite_network(patient_data, patients_by_cluster, add_parents, ont)
 	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
+	patient_data.each_profile do |id, profile|
+		profile = profile.map{|term| ont.get_ancestors(term)}.flatten.uniq if add_parents == 'root'
+	  profile.each do |term|
+			tripartite_network << [term, id] 
+	  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 <=> b.first}
-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
 ##############################
@@ -117,33 +39,75 @@ 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] = File.basename(value)
-  end 
+  options[:chromosome_col] = nil
+  opts.on("-c", "--chromosome_col INTEGER/STRING", "Column name if header is true, otherwise 0-based position of the column with the chromosome") do |data|
+    options[:chromosome_col] = data
+  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
+  options[:id_col] = nil
+  opts.on("-d", "--pat_id_col INTEGER/STRING", "Column name if header is true, otherwise 0-based position of the column with the patient id") do |data|
+    options[:id_col] = data
   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
+  options[:end_col] = nil
+  opts.on("-e", "--end_col INTEGER/STRING", "Column name if header is true, otherwise 0-based position of the column with the end mutation coordinate") do |data|
+    options[:end_col] = data
+  end
+  
+ 	options[:ont_col] = nil
+  opts.on("-p", "--hpo_term_col INTEGER/STRING", "Column name if header true or 0-based position of the column with the HPO terms") do |data|
+    options[:ont_col] = data
   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
+  options[:start_col] = nil
+  opts.on("-s", "--start_col INTEGER/STRING", "Column name if header is true, otherwise 0-based position of the column with the start mutation coordinate") do |data|
+    options[:start_col] = data
+  end
+
+  options[:separator] = '|'
+  opts.on("-S", "--hpo_separator STRING", "Set which character must be used to split the HPO profile. Default '|'") do |data|
+    options[:separator] = data
+  end
+
+  options[:names] = false
+  opts.on("-n", "--hpo_names", "Define if the input HPO are human readable names. Default false") do
+    options[:names] = true
+  end
+
+  options[:header] = true
+  opts.on("-H", "--header", "File has a line header. Default true") do 
+    options[:header] = false
+  end
+
+  #===================================================================
+
+  options[:input_file] = nil
+  opts.on("-i", "--input_file PATH", "Input file with patients for parsing phenotypes to HPO codes") do |value|
+    options[:input_file] = value
   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[:cluster_file] = 'cluster_coords.txt'
+  opts.on("-u", "--cluster_file PATH", "Cluster coords output file that will be used to translate SOR nodes") do |value|
+    options[:cluster_file] = File.basename(value)
   end 
 
+  options[:excluded_hpo] = nil
+  opts.on("-x", "--excluded_hpo PATH", "List of HPO phenotypes to exclude (low informative)") do |excluded_hpo|
+    options[:excluded_hpo] = excluded_hpo
+  end
+
+  options[:tag] = 'A'
+  opts.on("-m", "--mutation_type STRING", "Type of patient mutation, either it is a deletion (d) or duplication (D)") do |type|
+    options[:tag] = type
+  end
+
   options[:hpo_file] = nil
-  opts.on("-p", "--hpo_file PATH", "Input HPO file for extracting HPO codes") do |value|
+  opts.on("-O", "--hpo_file PATH", "Input HPO file for extracting HPO codes") do |value|
     options[:hpo_file] = value
   end
 
@@ -152,16 +116,6 @@ OptionParser.new do |opts|
     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] = File.basename(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
@@ -176,27 +130,20 @@ output_folder = File.dirname(File.expand_path(options[:output_file]))
 Dir.mkdir(output_folder) if !File.exists?(output_folder)
 
 hpo_file = options[:hpo_file]
-hpo_file = ENV['hpo_file'] if hpo_file.nil?
-hpo_file = HPO_FILE if hpo_file.nil?
-
-# hpo = Ontology.new
-# hpo.load_black_list(options[:excluded_hpo]) if !options[:excluded_hpo].nil?
-# hpo.load_data(hpo_file)
-if !options[:excluded_hpo].nil?
-	hpo = Ontology.new(file: hpo_file, load_file: true, removable_terms: read_excluded_hpo_file(options[:excluded_hpo]))
-else
-	hpo = Ontology.new(file: hpo_file, load_file: true)
-end
-patients2hpo, hpo_count, not_found, chr_patients_genomic_region = loadPatientFile(options[:patient_file], hpo, 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.excluded_codes, File.join(output_folder, 'missing_hpo_names'))
-write_array(not_found - hpo.removable_terms, File.join(output_folder, 'missing_hpo_names'))
+hpo_file = !ENV['hpo_file'].nil? ? ENV['hpo_file'] : HPO_FILE if hpo_file.nil?
+Cohort.load_ontology(:hpo, hpo_file, options[:excluded_hpo])
+Cohort.act_ont = :hpo
+hpo = Cohort.get_ontology(Cohort.act_ont)
+
+patient_data, rejected_hpos_L, rejected_patients_L = Cohort_Parser.load(options)
+rejected_hpos_C, rejected_patients_C = patient_data.check
+rejected_hpos = rejected_hpos_L | rejected_hpos_C
+rejected_patients = rejected_patients_L + rejected_patients_C
+patient_data.remove_incomplete_records
+patient_data.index_vars
+patients_by_cluster, sors = patient_data.generate_cluster_regions(:reg_overlap, options[:tag], 1)
+tripartite_network = build_tripartite_network(patient_data, patients_by_cluster, options[:add_parents], hpo)
+
+write_array(rejected_hpos, File.join(output_folder, 'missing_hpo_names'))
 write_array(sors, File.join(output_folder, options[:cluster_file]))
-write_hash(hpo_stats.select{|hp_code, stats| stats.last > options[:thresold]}, File.join(output_folder, options[:hpo_stat_file]), %w[HPOcode Frequency IC])
-write_array(tripartite_network, options[:output_file])
-write_array(patient_hpo_ic, File.join(output_folder, 'filtered_hpo.txt'))
+write_array(tripartite_network, options[:output_file])

data/bin/get_sorted_profs.rb

@@ -1,33 +1,11 @@
 #! /usr/bin/env ruby
 
-
 ROOT_PATH = File.dirname(__FILE__)
-REPORT_FOLDER = File.expand_path(File.join(ROOT_PATH, '..', 'templates'))
-EXTERNAL_DATA = File.expand_path(File.join(ROOT_PATH, '..', 'external_data'))
-HPO_FILE = File.join(EXTERNAL_DATA, 'hp.json')
 $: << File.expand_path(File.join(ROOT_PATH, '..', 'lib', 'pets'))
 
 require 'optparse'
 require 'report_html'
-require 'semtools'
-require 'generalMethods.rb'
-
-#############################################################################################
-## METHODS
-############################################################################################
-def procces_patient_data(patient_data, hpo)
-	clean_profiles = {}
-	all_hpo = []
-	patient_data.each do |pat_id, data|
-		profile = hpo.clean_profile_hard(data.first.map{|c| c.to_sym})
-		if !profile.empty?
-			clean_profiles[pat_id] = profile
-			all_hpo.concat(profile)
-		end
-	end
-	ref_prof = hpo.clean_profile_hard(all_hpo.uniq)
-	return ref_prof, clean_profiles
-end
+require 'pets'
 
 #############################################################################################
 ## OPTPARSE
@@ -42,9 +20,9 @@ OptionParser.new do |opts|
     options[:chromosome_col] = data
   end
 
-  options[:pat_id_col] = nil
+  options[:id_col] = nil
   opts.on("-d", "--pat_id_col INTEGER/STRING", "Column name if header is true, otherwise 0-based position of the column with the patient id") do |data|
-    options[:pat_id_col] = data
+    options[:id_col] = data
   end
 
   options[:end_col] = nil
@@ -67,9 +45,9 @@ OptionParser.new do |opts|
     options[:input_file] = value
   end
 
-  options[:hpo_col] = nil
+  options[:ont_col] = nil
   opts.on("-p", "--hpo_term_col INTEGER/STRING", "Column name if header true or 0-based position of the column with the HPO terms") do |data|
-    options[:hpo_col] = data
+    options[:ont_col] = data
   end
 
   options[:start_col] = nil
@@ -77,9 +55,14 @@ OptionParser.new do |opts|
     options[:start_col] = data
   end
 
-  options[:hpo_separator] = '|'
+  options[:separator] = '|'
   opts.on("-S", "--hpo_separator STRING", "Set which character must be used to split the HPO profile. Default '|'") do |data|
-    options[:hpo_separator] = data
+    options[:separator] = data
+  end
+
+  options[:term_freq] = 0
+  opts.on("-f", "--general_prof_freq INTEGER", "When reference profile is not given, a general ine is computed with all profiles. If a freq is defined (0-1), all terms with freq minor than limit are removed") do |data|
+    options[:term_freq] = data.to_i
   end
 
   options[:matrix_limits] = [20, 40]
@@ -101,15 +84,21 @@ end.parse!
 #############################################################################################
 ## MAIN
 ############################################################################################
-patient_data = load_patient_cohort(options)
 
 hpo_file = !ENV['hpo_file'].nil? ? ENV['hpo_file'] : HPO_FILE
-hpo = Ontology.new
-hpo.read(hpo_file)
-
-ref_profile, clean_profiles = procces_patient_data(patient_data, hpo)
-ref_profile = hpo.clean_profile_hard(options[:ref_prof]) if !options[:ref_prof].nil?
-hpo.load_profiles({ref: ref_profile})
+Cohort.load_ontology(:hpo, hpo_file)
+Cohort.act_ont = :hpo
+hpo = Cohort.get_ontology(Cohort.act_ont)
+patient_data, _, _ = Cohort_Parser.load(options)
+patient_data.check(hard=true)
+
+clean_profiles = patient_data.profiles
+if !options[:ref_prof].nil?
+  ref_profile = hpo.clean_profile_hard(options[:ref_prof])
+else
+  ref_profile = patient_data.get_general_profile(options[:term_freq])
+end
+hpo.load_profiles({ref: ref_profile}, reset_stored: true)
 
 similarities = hpo.compare_profiles(external_profiles: clean_profiles, sim_type: :lin, bidirectional: false)
 

data/bin/install_deps.rb

@@ -0,0 +1,8 @@
+#! /usr/bin/env ruby
+
+ROOT_PATH = File.dirname(__FILE__)
+EXTERNAL_CODE = File.expand_path(File.join(ROOT_PATH, '..', 'external_code'))
+$: << File.expand_path(File.join(ROOT_PATH, '..', 'lib', 'pets'))
+require 'pets'
+
+system_call(EXTERNAL_CODE, 'install_R_dependencies.R', '')

data/bin/paco_translator.rb

@@ -1,59 +1,10 @@
 #! /usr/bin/env ruby
 
 ROOT_PATH = File.dirname(__FILE__)
-EXTERNAL_DATA = File.expand_path(File.join(ROOT_PATH, '..', 'external_data'))
-HPO_FILE = File.join(EXTERNAL_DATA, 'hp.obo')
 $: << File.expand_path(File.join(ROOT_PATH, '..', 'lib', 'pets'))
 
-require 'generalMethods.rb'
 require 'optparse'
-require 'semtools'
-
-###############
-#METHODS
-###############
-
-def translate_hpo(patient_data, hpo, translate)
-  reject_pats = []
-  patient_data.each do |patientID, patient_record|
-    hpos, chr, start, stop = patient_record
-    if translate == 'names'
-      # hpos, rejected = hpo.translate_codes2names(hpos)
-      hpos, rejected = hpo.translate_ids(hpos)
-    elsif translate =='codes'
-      # hpos, rejected = hpo.translate_names2codes(hpos)
-      hpos, rejected = hpo.translate_names(hpos)
-      STDERR.puts(" The ontology names '#{rejected.join(',')}' were not found") if !rejected.empty?
-    end
-    if hpos.empty?
-      reject_pats << patientID 
-    else
-      patient_record[0] = hpos
-    end
-  end
-  reject_pats.each do | rj_pat|
-    patient_data.delete(rj_pat)
-  end
-end
-
-def save_translated_file(patients_with_hpo_names, output_file, mode)
-  File.open(output_file, 'w') do |f|
-    if mode == 'paco'
-      f.puts "patient_id\tchr\tstart\tstop\tphenotypes"
-    end
-    patients_with_hpo_names.each do |id, patient_record|
-      hpos, chr, start, stop = patient_record
-      id = id.gsub(/_i[0-9]+$/,'')
-      if mode == 'default'
-        f.puts "#{id}\t#{hpos.join('|')}\t#{[chr, start, stop].join("\t")}"
-      elsif mode == 'paco'
-        f.puts "#{id}\t#{[chr, start, stop].join("\t")}\t#{hpos.join('|')}"
-      else
-        abort('Wrong save_mode] option, please try default or paco')
-      end
-    end
-  end
-end
+require 'pets'
 
 ###############
 #OPTIONS
@@ -68,9 +19,9 @@ OptionParser.new do |opts|
     options[:chromosome_col] = data
   end
 
-  options[:pat_id_col] = nil
+  options[:id_col] = nil
   opts.on("-d", "--pat_id_col INTEGER/STRING", "Column name if header is true, otherwise 0-based position of the column with the patient id") do |data|
-    options[:pat_id_col] = data
+    options[:id_col] = data
   end
 
   options[:end_col] = nil
@@ -93,9 +44,9 @@ OptionParser.new do |opts|
     options[:input_file] = value
   end
 
-  options[:hpo_col] = nil
+  options[:ont_col] = nil
   opts.on("-p", "--hpo_term_col INTEGER/STRING", "Column name if header true or 0-based position of the column with the HPO terms") do |data|
-    options[:hpo_col] = data
+    options[:ont_col] = data
   end
 
   options[:start_col] = nil
@@ -103,33 +54,39 @@ OptionParser.new do |opts|
     options[:start_col] = data
   end
 
-  options[:hpo_separator] = '|'
+  options[:separator] = '|'
   opts.on("-S", "--hpo_separator STRING", "Set which character must be used to split the HPO profile. Default '|'") do |data|
-    options[:hpo_separator] = data
+    options[:separator] = data
+  end
+
+  options[:n_phens] = nil
+  opts.on("--n_phens INTEGER", "Remove records with N or less phenotypes") do |data|
+    options[:n_phens] = data.to_i
   end
 
-  options[:save_mode] = 'default'
+  options[:save_mode] = :default
   opts.on("-m", "--save_mode STRING", "Set output data mode") do |data|
-    options[:save_mode] = data
+    options[:save_mode] = data.to_sym
   end
 
-  options[:translate] = nil
-  opts.on("-t", "--translate STRING", "Set 'names' to translate from hpo codes to names or set 'codes' to translate from hpo names to codes. By default, ther is not translation") do |data|
-    options[:translate] = data
+  options[:names] = false
+  opts.on("-n", "--hpo_names", "Define if the input HPO are human readable names. Default false") do
+    options[:names] = true
+  end
+
+  options[:translate] = false
+  opts.on("-t", "--translate", "Set to translate from hpo codes to names. By default, ther is not translation") do 
+    options[:translate] = true
   end
 end.parse!
 
 ###############
 #MAIN
 ###############
-hpo_file = ENV['hpo_file']
-hpo_file = HPO_FILE if hpo_file.nil?
-
-patient_data = load_patient_cohort(options)
-if !options[:translate].nil?
-  # hpo = Ontology.new
-  # hpo.load_data(hpo_file)
-  hpo = Ontology.new(file: hpo_file, load_file: true)
-  translate_hpo(patient_data, hpo, options[:translate])
-end
-save_translated_file(patient_data, options[:output_file], options[:save_mode])
+hpo_file = !ENV['hpo_file'].nil? ? ENV['hpo_file'] : HPO_FILE
+Cohort.load_ontology(:hpo, hpo_file)
+Cohort.act_ont = :hpo
+
+patient_data, rejected_hpos, rejected_patients = Cohort_Parser.load(options)
+rejected_patients_by_phen = patient_data.filter_by_term_number(options[:n_phens]) if !options[:n_phens].nil?
+patient_data.save(options[:output_file], options[:save_mode], options[:translate])

data/bin/phen2reg.rb

@@ -2,16 +2,13 @@
 # Rojano E. & Seoane P., September 2016
 # Program to predict the position from given HPO codes, sorted by their association values.
 
-REPORT_FOLDER=File.expand_path(File.join(File.dirname(__FILE__), '..', 'templates'))
 ROOT_PATH = File.dirname(__FILE__)
 $: << File.expand_path(File.join(ROOT_PATH, '..', 'lib', 'pets'))
 
-require 'generalMethods.rb'
-require 'phen2reg_methods.rb'
 require 'optparse'
 require 'report_html'
 require 'semtools'
-
+require 'pets'
 
 ##########################
 #OPT-PARSER

data/bin/profiles2phenopacket.rb

@@ -0,0 +1,86 @@
+#! /usr/bin/env ruby
+
+ROOT_PATH = File.dirname(__FILE__)
+$: << File.expand_path(File.join(ROOT_PATH, '..', 'lib', 'pets'))
+
+require 'optparse'
+require 'pets'
+
+#############################
+## METHODS
+#############################
+def load_index(path_index)
+  vcf_index = {}
+  File.open(path_index).each do |line|
+    id, path = line.chomp.split("\t")
+    vcf_index[id] = path
+  end
+  return vcf_index
+end
+
+
+##########################
+#OPT-PARSER
+##########################
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{__FILE__} [options]"
+
+  eval(File.open(COMMON_OPTPARSE).read)
+
+  options[:input_file] = nil
+  opts.on("-i", "--input_file PATH", "Input file with patient data") do |data|
+    options[:input_file] = data
+  end
+
+  options[:vcf_index] = nil
+  opts.on("-I", "--vcf_index PATH", "VCF file with patient id pointing to vcf path") do |data|
+    options[:vcf_index] = data
+  end
+
+  options[:names] = false
+  opts.on("-n", "--hpo_names", "Define if the input HPO are human readable names. Default false") do
+    options[:names] = true
+  end
+
+  options[:output_folder] = nil
+  opts.on("-o", "--output_file PATH", "Output folder") do |data|
+    options[:output_folder] = data
+  end
+
+  options[:ont_col] = nil
+  opts.on("-p", "--hpo_term_col INTEGER/STRING", "Column name if header true or 0-based position of the column with the HPO terms") do |data|
+  	options[:ont_col] = data
+  end
+
+  options[:separator] = '|'
+  opts.on("-S", "--hpo_separator STRING", "Set which character must be used to split the HPO profile. Default '|'") do |data|
+  	options[:separator] = data
+  end
+
+  options[:start_col] = nil
+  opts.on("-s", "--start_col INTEGER/STRING", "Column name if header is true, otherwise 0-based position of the column with the start mutation coordinate") do |data|
+  	options[:start_col] = data
+  end
+
+  opts.on_tail("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+
+end.parse!
+
+#############################################################
+## MAIN
+#############################################################
+hpo_file = !ENV['hpo_file'].nil? ? ENV['hpo_file'] : HPO_FILE
+Cohort.load_ontology(:hpo, hpo_file, options[:excluded_hpo])
+Cohort.act_ont = :hpo
+
+patient_data, rejected_hpos_L, rejected_patients_L = Cohort_Parser.load(options)
+rejected_hpos_C, rejected_patients_C = patient_data.check(hard=true)
+patient_data.link2ont(Cohort.act_ont)
+
+vcf_index = load_index(options[:vcf_index]) if !options[:vcf_index].nil?
+patient_data.export_phenopackets(options[:output_folder], options[:genome_assembly], vcf_index: vcf_index)

data/bin/reg2phen.rb

@@ -3,14 +3,12 @@
 #data2predict = file to predict
 #training_file.txt = file with training data (association values and hpo codes).
 
-REPORT_FOLDER=File.expand_path(File.join(File.dirname(__FILE__), '..', 'templates'))
 ROOT_PATH = File.dirname(__FILE__)
 $: << File.expand_path(File.join(ROOT_PATH, '..', 'lib', 'pets'))
 
 require 'optparse'
-require 'generalMethods.rb'
 require 'semtools'
-require 'reg2phen_methods'
+require 'pets'
 
 ##########################
 #OPT-PARSER