bio-polyploid-tools 0.1.0

data/lib/bio/db/fastadb.rb

@@ -0,0 +1,164 @@
+#Module to hold the information about the fasta file
+
+module Bio::DB::Fasta
+  class Index
+    include Enumerable
+    attr_reader :entries
+    
+    def initialize
+      @entries=[]
+      @entries_map = Hash.new
+    end
+    
+    #This doesnt validate if you are adding the same entry twice. I may add
+    #a validation for that. 
+    def << (entry)
+      @entries << entry
+      @entries_map[entry.id] = entry
+    end
+    
+    def each(&block)
+      @entries.entries(&block)
+    end  
+    
+    def length
+       @entries.length
+    end
+    
+    #Returns a new Index just with the specified range, as if it was an Array. 
+    #The return object is of type Index. 
+    def [](args)
+      tmp = @entries[args]
+      new_index = Index.new
+      tmp.each do | entry |
+        @new_index << entry
+      end       
+    end
+    
+    def region_for_entry(entry)
+       @entries_map[entry]
+    end
+  end
+  
+  class Entry
+    attr_reader :id, :length
+    
+    def initialize(id, length)
+      @id=id
+      @length=length.to_i
+    end
+    
+    def get_full_region
+      reg = Region.new
+      reg.entry = id
+      reg.start = 0
+      reg.end = @length
+      reg.orientation = :forward
+      reg
+    end
+    
+    def to_region
+      get_full_region
+    end
+  end
+  
+  #Class to wrap a region of a chromosome
+  class Region
+    attr_accessor :entry, :start, :end, :orientation
+    
+    def to_s
+      string = @entry + ":" + @start.to_s + "-" + @end.to_s 
+      string
+    end
+    
+    def self.parse_region(reg_str)
+        string = reg_str.delete("'")
+        fields_1 = string.split(":")
+        fields_2 = fields_1[1].split("-")
+        raise FastaDBException.new(), "Invalid region. #{string}" if fields_1.length != 2 || fields_2.length != 2
+        
+        reg = Region.new
+        reg.entry = fields_1[0]
+        reg.start = fields_2[0].to_i
+        reg.end = fields_2[1].to_i
+        
+        if reg.end < reg.start 
+          reg.orientation = :reverse
+        else
+          reg.orientation = :forward
+        end
+        reg
+    end
+    
+    def size
+      @end - @start
+    end
+  
+  end
+  
+  class FastaDBException < StandardError; end
+  
+  #Class that holds the fasta file. It is used as a database. It heavily relies ond samtools. 
+  class FastaFile
+    
+    attr_reader :index, :fasta_path
+    
+    def FastaFile.finalize(id)
+      #id.close()
+      #puts "Finalizing #{id}  at #{Time.new}"       
+    end
+    
+    def initialize(fasta_filename)
+      @fasta_path = fasta_filename
+      raise FastaDBException.new(), "No path for the refernce fasta file. " if @fasta_path.nil?
+      @fasta_index = Bio::DB::SAM::Tools.fai_load(@fasta_path)
+      if @fasta_index.null? then
+        $stderr.puts "Generating index for: " + @fasta_path
+        Bio::DB::SAM::Tools.fai_build(@fasta_path)
+        @fasta_index =  Bio::DB::SAM::Tools.fai_load(@fasta_path)
+        raise FastaDBException.new(), "Unable to generate fasta index for: " + @fasta_path if @fasta_index.nil? ||  @fasta_index.null?
+      end
+      ObjectSpace.define_finalizer(self,  self.class.method(:finalize).to_proc)
+    end
+    
+    def load_fai_entries()
+      return  @index.length if @index
+      @index = Index.new
+      fai_file = @fasta_path + ".fai"
+      File.open(fai_file).each do | line |
+        fields = line.split("\t")
+        @index << Entry.new(fields[0], fields[1])
+        
+      end     
+      @index.length
+    end
+    
+    def close()
+       Bio::DB::SAM::Tools.fai_destroy(@fasta_index) unless @fasta_index.nil? || @fasta_index.null?
+       @fasta_index = nil
+    end
+    
+    #The region needs to have a method to_region or a method to_s that ha the format "chromosome:start-end" as in samtools
+    def fetch_sequence(region)
+      
+        raise FastaDBException.new(), "No fasta index for " if @fasta_index.nil? || @fasta_index.null? 
+        query = region.to_s
+        query = region.to_region.to_s if region.respond_to?(:to_region) 
+        
+        len = FFI::MemoryPointer.new :int
+        str = Bio::DB::SAM::Tools.fai_fetch(@fasta_index, query, len)
+        raise FastaDBException.new(), "Unable to get sequence for reference: " + query if str.nil?
+        reference = Bio::Sequence.auto(str)
+        
+        # 
+        
+        if region.orientation == :reverse
+          #puts "reversing! #{reference.to_s}"
+          reference.reverse_complement!()
+        end
+        reference
+    end
+    
+     
+  end
+end

data/lib/bio/db/primer3.rb

@@ -0,0 +1,673 @@
+
+module Bio::DB::Primer3
+  class Primer3Exception < RuntimeError 
+  end
+
+  def self.run(opts={})
+    puts "Primer3.run running..."
+
+    f_in=opts[:in]
+    f_out=opts[:out]
+    primer_3_in = File.read(f_in)
+    status = systemu "primer3_core", 0=>primer_3_in, 1=>stdout='', 2=>stderr=''
+    # $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
+    
+    def line_1_name
+      "#{gene}:#{position}#{original}>#{snp} #{line_1}}"
+    end
+
+    def initialize
+      @primers_line_1 = SortedSet.new
+      @primers_line_2 = SortedSet.new
+      @reguibs = SortedSet.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 print_primers
+#TODO: Retrieve error messages
+      left_start = 0
+      left_end = 0
+      right_start = 0
+      right_end = 0
+ #     exons = snp_from.exon_list.values
+      
+#      puts "Exons: #{exon_list.size}"
+      
+#      puts "It has the following exons: #{snp_in.exon_list.to_s}"
+      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("|")
+      if primer3_line_1 and primer3_line_2
+        values <<  primer3_line_1.polymorphism
+
+        #Block that searches both if both pairs have a TM
+        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)
+        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)
+        #  $stderr.puts primer_1
+        #  $stderr.puts 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.shortest_pair.left.tm 
+          values << primer_2_tm
+          values << primer3_line_1.shortest_pair.right.tm
+          values << "first" 
+          values << primer3_line_1.shortest_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.shortest_pair.left.tm
+          values << primer3_line_2.shortest_pair.right.tm
+          values << "second"
+          values << primer3_line_2.shortest_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
+            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)
+          end
+
+          if first_candidate and second_candidate and first_candidate < second_candidate 
+            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.shortest_pair.left.tm 
+            values << primer_2_tm
+            values << first_candidate.shortest_pair.right.tm
+            values << "first" 
+            values << first_candidate.shortest_pair.product_size
+          elsif  second_candidate 
+            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.shortest_pair.left.tm
+            values << second_candidate.shortest_pair.right.tm
+            values << "second"
+            values << second_candidate.shortest_pair.product_size
+          elsif  first_candidate 
+            values << primer_2
+            values << first_candidate.left_primer
+            values << first_candidate.right_primer
+            values << first_candidate.type.to_s
+            values << first_candidate.orientation.to_s
+            values << primer_2_tm
+            values << first_candidate.shortest_pair.left.tm
+            values << first_candidate.shortest_pair.right.tm
+            values << "first"
+            values << first_candidate.shortest_pair.product_size
+#          else
+#            values << "" 
+          end
+
+        end
+
+      elsif primer3_line_1 
+        values << primer3_line_1.polymorphism
+        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.shortest_pair.left.tm 
+        values << "NA"
+        values << primer3_line_1.shortest_pair.right.tm
+
+        values << "first+"
+        values << primer3_line_1.shortest_pair.product_size
+      elsif primer3_line_2 
+        values << primer3_line_2.polymorphism
+        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.shortest_pair.left.tm
+        values << primer3_line_2.shortest_pair.right.tm
+        values << "second+"
+        values << primer3_line_2.shortest_pair.product_size
+
+      end 
+      values.join(",")
+    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 = Array.new unless @primer3_errors
+      @template_length = primer3record.sequence_template.size
+       if primer3record.primer_error != nil 
+          primer3_errors << primer3record
+          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
+          @primer3_line_1 = primer3record if not @primer3_line_1  or @primer3_line_1 > primer3record
+        when primer3record.line == @line_2
+          primers_line_1 << 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
+      end
+    end
+  end
+
+  class Primer3Record
+    include Comparable
+    attr_accessor :properties, :polymorphism
+
+    def shortest_pair
+      return @shortest_pair if @shortest_pair
+      @shortest_pair = nil
+      @primerPairs.each do | primer |
+        @shortest_pair = primer if @shortest_pair == nil
+        @shortest_pair = primer if primer.size < @shortest_pair.size
+      end
+      @shortest_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
+      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 <=>(anOther)
+      ret = snp <=> anOther.snp
+      return ret if ret != 0
+
+
+      #Sorting by the types. 
+      if type == :chromosome_specific 
+        if anOther.type != :chromosome_specific
+          return -1
+        end
+      elsif type == :chromosome_semispecific
+        if anOther.type == :chromosome_specific
+          return 1
+        else anOther.type == :chromosome_nonspecific
+          return -1
+        end
+      elsif type == :chromosome_nonspecific
+        if anOther.type != :chromosome_nonspecific
+          return 1
+        end
+      end
+
+      #Sorting if it is in intron or not This will give priority 
+      #to the cases when we know for sure the sequence from the line
+      #and reduce the chances of getting messed with a short indel
+      if self.exon?
+        unless anOther.exon? 
+          return -1
+        end
+      else
+        if anOther.exon?
+          return 1
+        end
+      end
+
+      #Sorting for how long the product is, the shorter, the better 
+      return  product_length <=> anOther.product_length
+
+    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 = shortest_pair.left.coordinates
+      @left_coordinates 
+    end
+
+    def right_coordinates
+      unless @right_coordinates 
+        @right_coordinates = shortest_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 = shortest_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
+        base_original = reverse_complement_string(snp.original )
+        base_snp = 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
+      return tmp_primer
+    end
+
+    def left_primer_with_coordinates(coordinates, other_orientation)
+
+      seq = self.sequence_template
+
+      seq = reverse_complement_string(seq) if self.orientation != other_orientation
+
+      seq[coordinates[0],coordinates[1]] 
+    end
+
+    def 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 = reverse_complement_string(@right_primer)
+      @right_primer
+    end
+    
+    def right_primer
+      return shortest_pair.right.sequence
+    end
+
+    def product_length
+      return shortest_pair.size
+    end
+
+    def initialize
+      @properties = Hash.new
+    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}'"
+      @snp, @line, @type, @in, @polymorphism, @chromosome, @orientation   = self.sequence_id.split(" ")  
+      @type = @type.to_sym
+      if @in
+        @in = @in.to_sym == :exon 
+      else
+        @exon = false
+      end
+
+      if @polymorphism.to_sym == :homeologous
+        @homeologous = true
+      else
+        @homeologous = 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 homeologous?
+      return @homeologous if @parsed
+      parse_header
+      @homeologous
+    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)
+      File.open(filename) do | f |
+        record = Primer3Record.new
+        f.each_line do | line |
+          line.chomp!
+          if line == "="
+
+            record.parse_blocks
+            yield record
+            record = Primer3Record.new
+          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
+
+    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 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
+   
+
+    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) 
+      @snp_hash=Hash.new unless @snp_hash
+      snp = SNP.new
+      snp.gene = snp_in.gene
+      snp.original = snp_in.original
+
+      snp.position = snp_in.position
+      snp.snp = snp_in.snp
+
+#      snp.original.upcase!
+#      snp.snp.upcase! 
+      snp.line_1 = @line_1
+      snp.line_2 = @line_2 
+      snp.snp_from = snp_in
+      #puts "Kasp container, adding #{snp.to_s} #{snp.class}  #{snp_in.class}"
+      #puts "#{snp.regions}"
+      snp.regions = snp_in.exon_list.values.collect { |x| x.target_region.to_s }
+      #puts "#{snp.regions}"
+      @snp_hash[snp.to_s] = snp
+      snp
+    end
+
+    def add_primers_file(filename)
+      Primer3Record.parse_file(filename) do | primer3record |
+        current_snp = @snp_hash["#{primer3record.snp.to_s}:#{primer3record.chromosome}"]
+        current_snp.add_record(primer3record)
+        #puts current_snp.inspect
+      end
+    end
+
+    def print_primers
+      str = ""
+      snp_hash.each do |k, snp|
+        str << snp.print_primers << "\n"
+      end
+      return str
+    end
+
+  end
+
+end
+