bio-polymarker 1.3.2

data/lib/bio/db/primer3.rb

@@ -0,0 +1,820 @@
+require 'pp'
+module Bio::DB::Primer3
+  class Primer3Exception < RuntimeError 
+  end
+
+  def self.read_primer_preferences(file, defaults)
+
+    File.open(file) do |f|
+      f.each_line do | line | 
+        line.chomp!
+        arr = line.split("=")
+        defaults[arr[0].downcase.to_sym] = arr[1];
+      end
+    end
+
+    return defaults
+  end
+
+  def self.prepare_input_file(file, opts2={})
+   opts = {
+    :primer_product_size_range => "50-150" ,
+    :primer_max_size => 25 , 
+    :primer_lib_ambiguity_codes_consensus => 1,
+    :primer_liberal_base => 1, 
+    :primer_num_return => 5,
+    :primer_explain_flag => 1,
+    :primer_thermodynamic_parameters_path => File.expand_path(File.dirname(__FILE__) + '../../../../conf/primer3_config/') + '/'
+    }.merge(opts2)
+    
+    opts.each do |key,value|
+      file.puts "#{key.to_s.upcase}=#{value}\n"
+    end
+  end
+
+  def self.run(opts={})
+    puts "Primer3.run running..."
+    timeout = 600
+    f_in=opts[:in]
+    f_out=opts[:out]
+    timeout = opts[:timeout] if opts[:timeout]
+    opts.delete(:in)
+    opts.delete(:out)
+    primer_3_in = File.read(f_in)
+    status = systemu "primer3_core", 0=>primer_3_in, 1=>stdout='', 2=>stderr='' do |cid|
+      sleep timeout
+      Process.kill 9, cid
+    end
+    # $stderr.puts cmdline
+    if status.exitstatus == 0
+      File.open(f_out, 'w') { |f| f.write(stdout) }
+    else
+      raise Primer3Exception.new(), "Error running primer3. Command line was 'primer3_core'\nPrimer3 STDERR was:\n#{stderr}"
+    end
+  end
+
+  class SNP
+
+    attr_accessor :gene, :original, :position, :snp, :chromosome, :line_1, :line_2
+    attr_accessor :primer3_line_1, :primer3_line_2, :template_length
+    attr_accessor :primers_line_1, :primers_line_2
+    attr_accessor :used_contigs
+    attr_accessor :snp_from
+    attr_accessor :regions
+    attr_accessor :primer3_errors
+    attr_accessor :repetitive
+    attr_accessor :hit_count
+    attr_accessor :snp_type
+    
+    def line_1_name
+      "#{gene}:#{position}#{original}>#{snp} #{line_1}}"
+    end
+
+    def initialize
+      @primers_line_1 = SortedSet.new
+      @primers_line_2 = SortedSet.new
+      @regions = SortedSet.new
+      @primer3_errors = Set.new
+    end
+
+    def line_2_name
+      "#{gene}:#{position}#{original}>#{snp} #{line_2}}"
+    end
+
+    def to_s
+      "#{gene}:#{original}#{position}#{snp}:#{snp_from.chromosome}"
+    end
+
+    def find_left_primer_temp(primer)
+      primers_line_1.each do |pr|
+        return pr.find_left_tm(primer) if pr.find_left_tm(primer)
+      end
+      primers_line_2.each do |pr|
+        return pr.find_left_tm(primer) if pr.find_left_tm(primer)
+      end
+      return "NA"
+    end
+
+
+    def find_primer_pair_first
+      primers_line_1.each do |pr|
+        primer = pr.left_primer_snp(self)
+        return pr if find_left_primer_temp(primer) != "NA"
+      end
+      nil
+    end
+
+    def find_primer_pair_second
+      primers_line_2.each do |pr|
+        primer = pr.left_primer_snp(self)
+        return pr if find_left_primer_temp(primer) != "NA"
+      end
+      nil
+    end
+
+    def values
+      return @values if @values
+      left_start = 0
+      left_end = 0
+      right_start = 0
+      right_end = 0
+      total_columns_before_messages=17
+      #puts "Values in primer3"
+      #puts snp_from.inspect
+      @values = Array.new
+      #@values << "#{gene},,#{template_length},"
+      @values << gene
+      @values << "#{original}#{position}#{snp}"
+      @values << template_length
+      @values << snp_from.chromosome
+      @values << regions.size
+      @values << regions.join("|")
+      @values << snp_type
+      if primer3_line_1 and primer3_line_2
+        #Block that searches both if both pairs have a TM
+        primer_1    = primer3_line_1.left_primer_with_coordinates(primer3_line_2.left_coordinates, primer3_line_2.orientation) 
+        primer_1_tm = find_left_primer_temp(primer_1)
+
+        primer_2    = primer3_line_2.left_primer_with_coordinates(primer3_line_1.left_coordinates, primer3_line_1.orientation)
+        primer_2_tm = find_left_primer_temp(primer_2)
+
+        if primer3_line_1 < primer3_line_2 and primer_2_tm != "NA"
+          @values << primer3_line_1.left_primer
+          @values << primer_2
+          @values << primer3_line_1.right_primer 
+          @values << primer3_line_1.type.to_s 
+          @values << primer3_line_1.orientation.to_s 
+          @values << primer3_line_1.best_pair.left.tm 
+          @values << primer_2_tm
+          @values << primer3_line_1.best_pair.right.tm
+          @values << "first" 
+          @values << primer3_line_1.best_pair.product_size
+        elsif  primer_1_tm != "NA"
+          @values << primer_1
+          @values << primer3_line_2.left_primer
+          @values << primer3_line_2.right_primer
+          @values << primer3_line_2.type.to_s
+          @values << primer3_line_2.orientation.to_s
+          @values << primer_1_tm
+          @values << primer3_line_2.best_pair.left.tm
+          @values << primer3_line_2.best_pair.right.tm
+          @values << "second"
+          @values << primer3_line_2.best_pair.product_size
+        else
+
+          first_candidate  = find_primer_pair_first
+          second_candidate = find_primer_pair_second
+
+          if first_candidate
+            primer_2 = primer3_line_2.left_primer_with_coordinates(first_candidate.left_coordinates, first_candidate.orientation)
+            primer_2_tm = find_left_primer_temp(primer_2)
+          end
+          if second_candidate
+            #puts "input to search #{first_candidate.left_coordinates}"
+            primer_1 = primer3_line_1.left_primer_with_coordinates(second_candidate.left_coordinates, second_candidate.orientation) 
+            primer_1_tm = find_left_primer_temp(primer_1)
+            #puts "In the other funky if #{primer_2}"
+          end
+
+          if first_candidate and second_candidate and first_candidate < second_candidate 
+            #puts "A"
+            @values << first_candidate.left_primer
+            @values << primer_2
+            @values << first_candidate.right_primer 
+            @values << first_candidate.type.to_s 
+            @values << first_candidate.orientation.to_s 
+            @values << first_candidate.best_pair.left.tm 
+            @values << primer_2_tm
+            @values << first_candidate.best_pair.right.tm
+            @values << "first-" 
+            @values << first_candidate.best_pair.product_size
+          elsif  second_candidate 
+            #puts "B"
+            @values << primer_1
+            @values << second_candidate.left_primer
+            @values << second_candidate.right_primer
+            @values << second_candidate.type.to_s
+            @values << second_candidate.orientation.to_s
+            @values << primer_1_tm
+            @values << second_candidate.best_pair.left.tm
+            @values << second_candidate.best_pair.right.tm
+            @values << "second-"
+            @values << second_candidate.best_pair.product_size
+          elsif  first_candidate 
+            #puts "C"
+            @values << first_candidate.left_primer
+            @values << primer_2
+            @values << first_candidate.right_primer
+            @values << first_candidate.type.to_s
+            @values << first_candidate.orientation.to_s
+            @values << primer_2_tm
+            @values << first_candidate.best_pair.left.tm
+            @values << first_candidate.best_pair.right.tm
+            @values << "first/"
+            @values << first_candidate.best_pair.product_size
+          end
+        end
+
+      elsif primer3_line_1 
+        @values << primer3_line_1.left_primer
+        @values << primer3_line_1.left_primer_snp(self) 
+        @values << primer3_line_1.right_primer 
+        @values << primer3_line_1.type.to_s 
+        @values << primer3_line_1.orientation.to_s      
+        @values << primer3_line_1.best_pair.left.tm 
+        @values << "NA"
+        @values << primer3_line_1.best_pair.right.tm
+
+        @values << "first+"
+        @values << primer3_line_1.best_pair.product_size
+      elsif primer3_line_2 
+        @values << primer3_line_2.left_primer_snp(self) 
+        @values << primer3_line_2.left_primer
+        @values << primer3_line_2.right_primer
+        @values << primer3_line_2.type.to_s
+        @values << primer3_line_2.orientation.to_s
+        @values << "NA"
+        @values << primer3_line_2.best_pair.left.tm
+        @values << primer3_line_2.best_pair.right.tm
+        @values << "second+"
+        @values << primer3_line_2.best_pair.product_size
+
+      end 
+      if @values.size < total_columns_before_messages
+        @values[total_columns_before_messages] = primer3_errors.to_a.join("|")
+      else
+        @values << nil
+      end
+      return @values
+    end
+
+    def print_primers
+      to_print = values.dup
+      to_print << @repetitive
+      to_print << @hit_count
+      to_print.join(",")
+    end
+
+    def found_primers?
+      return self.values[7] && self.values[7] != nil
+    end
+
+    def first_primer
+      return self.values[7] if self.values[7] && self.values[7] != nil
+      return ""
+    end
+
+    def second_primer
+      return self.values[8] if self.values[8] && self.values[8] != nil
+      return ""
+    end
+
+    def common_primer 
+      return self.values[9] if self.values[9] && self.values[9] != nil
+      return ""
+    end
+
+    def product_size
+      return self.values[16].to_i if self.values[16]&& self.values[16] != nil 
+      return 0
+    end
+
+    def orientation
+      return self.values[11] if self.values[11]&& self.values[11] != nil 
+      return 'unknown'
+    end
+
+
+    def first_product
+      left = first_primer
+      right = common_primer
+      nlen = product_size - left.size - right.size
+      product = left + ('n' * nlen) + Primer3Record.reverse_complement_string(right)
+      #puts "orientation: #{orientation}"
+      
+      product = Primer3Record.reverse_complement_string(product)  if orientation == 'reverse'
+    
+      product
+    end
+
+     def second_product
+      left = second_primer
+      right = common_primer
+      nlen = product_size - left.size - right.size
+      product = left + ('n' * nlen) + Primer3Record.reverse_complement_string(right)
+      product = Primer3Record.reverse_complement_string(product) if orientation == 'reverse'
+      
+
+      product
+    end
+
+
+    def realigned_primers_fasta
+      ret_str = ""
+      realigned_primers.each_pair do |name, seq|
+        ret_str << ">#{self.to_s}-#{name}\n#{seq}\n" 
+      end
+      ret_str 
+    end
+
+
+    def realigned_primers
+     
+      return @realigned_primers if @realigned_primers
+      sequences_to_align = Hash.new
+      sequences_to_align["first_product"]  = first_product
+      sequences_to_align["second_product"] = second_product
+      sequences_to_align.merge!(snp_from.surrounding_exon_sequences)
+      if sequences_to_align.size == 1
+        @realigned_primers = sequences_to_align
+        return @realigned_primers
+      end
+      options = ['--maxiterate', '1000', '--localpair', '--quiet']
+      mafft = Bio::MAFFT.new( "mafft" , options)
+      #puts "Before MAFT:#{sequences_to_align.inspect}"
+      report = mafft.query_align(sequences_to_align)
+      @realigned_primers = report.alignment
+      #puts "MAFFT: #{report.alignment.inspect}" 
+      @realigned_primers
+    end 
+
+    def self.parse(reg_str)
+      reg_str.chomp!
+      snp = SNP.new
+      snp.gene, snp.original, snp.position, snp.snp = reg_str.split(",")
+      snp.position = snp.position.to_i
+      snp.original.upcase!
+      snp.snp.upcase!  
+      snp
+    end
+
+    def self.parse_file(filename)
+      File.open(filename) do | f |
+        f.each_line do | line |
+          snp = SNP.parse(line)
+          if snp.position > 0
+            yield snp
+          end
+        end
+      end
+    end
+
+    
+    def add_record(primer3record)
+      @primer3_errors = Set.new unless @primer3_errors
+      @template_length = primer3record.sequence_template.size
+      if primer3record.primer_error != nil 
+        primer3_errors << primer3record.primer_error
+        return
+      end
+      case
+
+      when primer3record.line == @line_1
+
+        @line_1_template = primer3record.sequence_template
+
+      when primer3record.line == @line_2
+        @line_2_template = primer3record.sequence_template
+      else
+        raise Primer3Exception.new "#{primer3record.line} is not recognized (#{line_1}, #{line_2})"
+      end
+
+      if  primer3record.primer_left_num_returned.to_i > 0 
+        case
+        when primer3record.line == @line_1
+          primers_line_1 << primer3record
+          #puts primer3record.inspect
+          @primer3_line_1 = primer3record if not @primer3_line_1  or @primer3_line_1 > primer3record
+        when primer3record.line == @line_2
+          primers_line_2 << primer3record
+          @primer3_line_2 = primer3record if not @primer3_line_2  or @primer3_line_2 > primer3record
+        else
+          raise Primer3Exception.new "#{primer3record.line} is not recognized (#{line_1}, #{line_2})"
+        end
+      else
+        primer3_errors << "#{primer3record.line}(#{primer3record.orientation}):#{primer3record.primer_left_explain.gsub!(',',';')}"
+        primer3_errors << "common(#{primer3record.orientation}#{primer3record.type}):#{primer3record.primer_right_explain.gsub!(',',';')}"
+        primer3_errors << "pair(#{primer3record.orientation}#{primer3record.type}):#{primer3record.primer_pair_explain.gsub!(',',';')}"
+      end
+    end
+  end
+
+  class Primer3Record
+    include Comparable
+    attr_accessor :properties, :polymorphism
+    attr_accessor :scores
+
+
+    def best_pair
+      return @best_pair if @best_pair
+      @best_pair = nil
+      @primerPairs.each do | primer |
+        @best_pair = primer if @best_pair.nil?
+        @best_pair = primer if primer.size < @best_pair.size
+      end
+      #@best_pair = @primerPairs.min
+      @best_pair
+    end
+
+    def primer_error
+      return @properties[:primer_error] if @properties[:primer_error]
+      return nil
+    end
+    
+    def method_missing(method_name, *args)
+      return @properties[method_name] if @properties[method_name] 
+      $stderr.puts "Missing #{method_name}"
+      $stderr.puts @properties.inspect
+      return "" #if a property is missing, return blank. 
+      raise NoMethodError.new() 
+    end
+
+    def find_left_tm(primer)
+      last = size - 1
+      (0..last).each do | i |
+        seq_prop = "primer_left_#{i}_sequence".to_sym
+        #        $stderr.puts seq_prop
+        temp_property = "primer_left_#{i}_tm".to_sym  
+        #       $stderr.puts "comparing  #{@properties[seq_prop] } == #{primer}"
+        return @properties[temp_property]  if @properties[seq_prop] == primer
+
+      end
+      return nil
+    end
+
+    def score
+      ret = 0
+      ret += @scores[type]
+      ret += @scores[:exon] if exon?
+      ret -= product_length
+      ret
+    end
+
+    def <=>(anOther)
+      return  anOther.score <=> score
+    end
+
+    def parse_coordinates(str)
+      coords = str.split(',')
+      coords[0] = coords[0].to_i
+      coords[1] = coords[1].to_i
+      coords
+    end
+
+
+    def left_coordinates
+      #@left_coordinates = parse_coordinates(self.primer_left_0) unless @left_coordinates 
+      @left_coordinates = best_pair.left.coordinates
+      @left_coordinates 
+    end
+
+    def right_coordinates
+      unless @right_coordinates 
+        @right_coordinates = best_pair.right.coordinates
+        @right_coordinates[0] = @right_coordinates[0] - @right_coordinates[1] + 1
+      end
+      @right_coordinates 
+    end
+
+    def left_primer
+      #@left_primer = self.sequence_template[left_coordinates[0],left_coordinates[1]] unless @left_primer
+      @left_primer = best_pair.left.sequence
+      @left_primer
+    end
+
+    def left_primer_snp(snp)
+      tmp_primer = String.new(left_primer)
+      if self.orientation == :forward
+        base_original = snp.original 
+        base_snp = snp.snp
+      elsif self.orientation == :reverse
+        #puts self.inspect
+        base_original =Primer3Record.reverse_complement_string(snp.original )
+        base_snp = Primer3Record.reverse_complement_string(snp.snp)
+      else
+        raise Primer3Exception.new "#{self.orientation} is not a valid orientation"
+      end
+
+      #puts "#{snp.to_s} #{self.orientation} #{tmp_primer[-1] } #{base_original} #{base_snp}"
+      if tmp_primer[-1] == base_original
+        tmp_primer[-1] = base_snp
+      elsif tmp_primer[-1] == base_snp
+        tmp_primer[-1] = base_original  
+      else
+        raise Primer3Exception.new "#{tmp_primer} doesnt end in a base in the SNP #{snp.to_s}"
+      end
+      #puts "tmp_primer: #{tmp_primer}"
+      return tmp_primer
+    end
+
+    def left_primer_with_coordinates(coordinates, other_orientation)
+
+      seq = self.sequence_template
+      seq = Primer3Record.reverse_complement_string(seq) if self.orientation != other_orientation    
+      seq[coordinates[0],coordinates[1]] 
+    end
+
+    def self.reverse_complement_string(sequenc_str)
+      complement = sequenc_str.tr('atgcrymkdhvbswnATGCRYMKDHVBSWN', 'tacgyrkmhdbvswnTACGYRKMHDBVSWN')
+      complement.reverse!
+    end
+
+    def right_primer_delete
+      @right_primer = self.sequence_template[right_coordinates[0],right_coordinates[1]] unless @right_primer
+      @right_primer = Primer3Record.reverse_complement_string(@right_primer)
+      @right_primer
+    end
+    
+    def right_primer
+      return best_pair.right.sequence
+    end
+
+    def product_length
+      return best_pair.size
+    end
+
+    def initialize
+      @properties = Hash.new
+      @scores = Hash.new
+      @scores[:chromosome_specific] = 1000
+      @scores[:chromosome_semispecific] = 100
+      @scores[:chromosome_nonspecific] = 0
+      @scores[:exon] = 50
+
+    end
+
+    def snp
+      return @snp if @snp
+      parse_header
+      @snp
+    end
+
+    #CL3339Contig1:T509C AvocetS chromosome_specific exon 4D forward 
+    def parse_header
+      #puts "Parsing header: '#{self.sequence_id}'"
+      arr = self.sequence_id.split(" ")
+
+      #if arr.size == 7 This validation can be useful to get the best primers regardless of the chromosome, 
+      #But it is commented as it will require further testing. 
+      @snp, @line, @type, @in, @polymorphism, @chromosome, @orientation  = arr  
+      #else 
+      #  if arr.size == 6
+      #    @snp, @line, @type, @in, @polymorphism, @orientation  = arr
+      #    @chromosome = ""   
+      #  end 
+      #end
+
+      @type = @type.to_sym
+      if @in
+        @in = @in.to_sym == :exon 
+      else
+        @exon = false
+      end
+
+      if @polymorphism.to_sym == :homoeologous
+        @homoeologous = true
+      else
+        @homoeologous = false
+      end
+      @parsed = true
+      @orientation = @orientation.to_sym
+    end
+
+    def orientation
+      return @orientation if @parsed
+      parse_header
+      @orientation
+    end
+
+    def chromosome
+      return @chromosome if @parsed
+      parse_header
+      @chromosome
+    end
+    
+    def homoeologous?
+      return @homoeologous if @parsed
+      parse_header
+      @homoeologous
+    end
+
+    def type
+      return @type if @parsed
+      parse_header
+      @type
+    end
+
+    def exon?
+      return @exon if @parsed
+      parse_header
+      @exon
+    end
+
+    def line
+      return @line if @parsed
+      parse_header
+      @line
+    end
+
+    def size
+      @properties[:primer_pair_num_returned].to_i
+    end
+
+    def parse_blocks
+      total_blocks = size - 1 
+      @primerPairs = Array.new
+      for i in 0..total_blocks
+        @primerPairs << PrimerPair.new(self, i)
+      end
+
+    end
+
+    def self.parse_file(filename, scores: nil)
+      File.open(filename) do | f |
+        record = Primer3Record.new
+        record.scores = scores if scores
+        f.each_line do | line |
+          line.chomp!
+          if line == "="
+
+            record.parse_blocks
+            yield record
+            record = Primer3Record.new
+            record.scores = scores if scores
+          else
+            tokens = line.split("=")
+            i = 0
+            reg = ""
+            #TODO: Look if there is a join function or something similar to go around this... 
+            tokens.each do |tok|
+              if i > 0
+                if i > 1
+                  reg << "="
+                end
+                reg << tok
+              end
+              i+=1
+            end
+            record.properties[tokens[0].downcase.to_sym] = reg
+          end
+        end
+      end
+    end
+  end
+
+
+  class Primer
+    attr_accessor :pair
+    def initialize
+      @values = Hash.new
+    end
+
+    def method_missing(m, *args, &block)
+      return @values[m.to_s] if @values[m.to_s] != nil
+      raise NoMethodError.new(), "There's no method called #{m}, available: #{@values.keys.to_s}."  
+    end
+
+    def set_value(key, value)
+      @values[key] = value
+    end
+
+
+
+  end
+
+  class PrimerPair
+    include Comparable
+    attr_reader :record
+    attr_reader :left, :right
+    
+    def parse_coordinates(str)
+      coords = str.split(',')
+      coords[0] = coords[0].to_i
+      coords[1] = coords[1].to_i
+      coords
+    end
+
+    def size
+      return product_size.to_i
+    end
+
+    def <=>(anOther)
+      penalty.to_f <=> anOther.penalty.to_f
+    end
+
+    def initialize(record, index)
+      raise Primer3Exception.new(), "Index #{index} is greater than the number of records" unless index < record.size
+      @record = record
+      @left = Primer.new
+      @right = Primer.new
+      @values = Hash.new
+      
+
+      @left.set_value("added", false)
+      @right.set_value("added", false)
+      @left.pair = self
+      @right.pair = self
+      index_s = index.to_s
+      record.properties.each do |key, value|
+        tokens = key.to_s.split("_")
+        if tokens.size > 2 and tokens[2] == index_s
+          primer = nil
+          primer = @right if tokens[1] == "right"
+          primer = @left if tokens[1] == "left"
+          if primer != nil
+            primer.set_value("added", true)
+            if tokens.size == 3
+              primer.set_value("coordinates", parse_coordinates(value) )
+            else
+
+              to_add = value
+              to_add = value.to_f unless tokens[3]=="sequence"
+              n_key = tokens[3..6].join("_")
+              primer.set_value(n_key, to_add)
+            end
+          else
+            n_key = tokens[3..6].join("_")
+            @values[n_key] = value  
+          end
+
+        end
+      end
+
+      raise Primer3Exception.new(), "The pair is not complete (l:#{left.added}, r:#{right.added})" if @left.added == false or @right.added == false
+
+    end
+
+    def method_missing(m, *args, &block)  
+
+      return @values[m.to_s] if @values[m.to_s]
+      raise NoMethodError.new(), "There's no method called #{m}. Available methods: #{@values.keys.to_s}"
+    end
+  end
+
+  class KASPContainer
+
+    attr_accessor :line_1, :line_2
+    attr_accessor :snp_hash
+    attr_accessor :scores
+
+    def add_snp_file(filename)
+      @snp_hash=Hash.new unless @snp_hash
+      SNP.parse_file(filename) do |snp|
+        @snp_hash[snp.to_s] = snp
+        snp.line_1 = @line_1
+        snp.line_2 = @line_2
+      end
+    end
+
+    def add_snp(snp_in) 
+      #TODO: Here we need to also copy the errors that will be printed. 
+      @snp_hash=Hash.new unless @snp_hash
+      snp = SNP.new
+      snp.gene = snp_in.gene
+      snp.original = snp_in.original
+      snp.primer3_errors = Set.new snp_in.errors
+      snp.position = snp_in.position
+      snp.snp = snp_in.snp
+      snp.repetitive = snp_in.repetitive
+      #puts snp_in.inspect
+      snp.hit_count = snp_in.hit_count
+      snp.snp_type  = snp_in.snp_type
+      snp.line_1 = @line_1
+      snp.line_2 = @line_2 
+      snp.snp_from = snp_in
+      snp.regions = snp_in.exon_list.values.collect { |x|  x.collect {|y| y.target_region.to_s }}
+      @snp_hash[snp.to_s] = snp
+      snp
+    end
+
+    def add_primers_file(filename)
+      #primer3record.scores = @scores if @scores
+      Primer3Record.parse_file(filename, scores: @scores) do | primer3record |
+        current_snp = @snp_hash["#{primer3record.snp.to_s}:#{primer3record.chromosome}"]
+        current_snp.add_record(primer3record)
+      end
+    end
+
+    def print_primers
+      str = ""
+      snp_hash.each do |k, snp|
+        str << snp.print_primers << "\n"
+      end
+      return str
+    end
+
+    def print_primers_with_tails(tail_a: "GAAGGTCGGAGTCAACGGATT", tail_b: "GAAGGTGACCAAGTTCATGCT")
+      str = ""
+      snp_hash.each do |k, snp|  
+        if snp.found_primers?
+          str << snp.gene << snp.original << "_1st\t" << tail_a << snp.first_primer  << "\n"
+          str << snp.gene << snp.snp      << "_2nd\t" << tail_b << snp.second_primer << "\n"
+          str << snp.gene                 << "_common\t"        << snp.common_primer << "\n"
+        end
+      end
+      return str
+    end
+
+  end
+end
+