transrate 0.1.0 → 0.2.0

data/lib/transrate/bowtie2.rb

@@ -1,42 +1,66 @@
 module Transrate
 
+  class Bowtie2Error < StandardError
+  end
+
   class Bowtie2
 
     require 'which'
     include Which
 
+    attr_reader :index_name, :sam
+
     def initialize
       bowtie2_path = which('bowtie2')
-      raise "could not find bowtie2 in the path" if bowtie2_path.empty?
+      if bowtie2_path.empty?
+        raise Bowtie2Error.new("could not find bowtie2 in the path")
+      end
       @bowtie2 = bowtie2_path.first
       bowtie2_build_path = which('bowtie2-build')
-      raise "could not find bowtie2-build in the path" if bowtie2_build_path.empty?
+      if bowtie2_build_path.empty?
+        raise Bowtie2Error.new("could not find bowtie2-build in the path")
+      end
       @bowtie2_build = bowtie2_build_path.first
+      @index_built = false
+      @index_name = ""
     end
 
-    def map_reads file, left, right=nil, insertsize=200, insertsd=50, outputname=nil
+    def map_reads(file, left,
+                  right, insertsize: 200,
+                  insertsd: 50, outputname: nil,
+                  threads: 8)
+      raise Bowtie2Error.new("Index not built") if !@index_built
       lbase = File.basename(left)
       rbase = File.basename(right)
-      outputname ||= "#{lbase}.#{rbase}.#{File.basename(file)}.sam"
+      index = File.basename(@index_name)
+      @sam = File.expand_path("#{lbase}.#{rbase}.#{index}.sam")
       realistic_dist = insertsize + (3 * insertsd)
-      unless File.exists? outputname
+      unless File.exists? @sam
         # construct bowtie command
-        bowtiecmd = "#{@bowtie2} --very-sensitive-local -k 10 -p 8 -X #{realistic_dist}" # TODO number of cores should be variable '-p 8'
-        bowtiecmd += " --no-unal --quiet"
-        bowtiecmd += " #{File.basename(file)} -1 #{left}"
+        bowtiecmd = "#{@bowtie2} --very-sensitive"
+        bowtiecmd += " -p #{threads} -X #{realistic_dist}"
+        bowtiecmd += " --quiet --no-unal"
+        bowtiecmd += " --seed 1337"
+        bowtiecmd += " -x #{@index_name}"
+        bowtiecmd += " -1 #{left}"
         # paired end?
         bowtiecmd += " -2 #{right}" if right
-        bowtiecmd += " > #{outputname}"
+        bowtiecmd += " -S #{@sam}"
         # run bowtie
-        `#{bowtiecmd}`
+        runner = Cmd.new bowtiecmd
+        runner.run
       end
-      outputname
+      @sam
     end
 
     def build_index file
-      unless File.exists?(file + '.1.bt2')
-        `#{@bowtie2_build} --offrate 1 #{file} #{File.basename(file)}`
+      @index_name = File.basename(file).split(".")[0..-2].join(".")
+      unless File.exists?(@index_name + '.1.bt2')
+        cmd = "#{@bowtie2_build} --quiet --offrate 1 #{file} #{@index_name}"
+        runner = Cmd.new cmd
+        runner.run
       end
+      @index_built = true
     end
 
   end # Bowtie2

data/lib/transrate/cmd.rb

@@ -0,0 +1,19 @@
+require 'open3'
+
+module Transrate
+
+  class Cmd
+
+    attr_accessor :cmd, :stdout, :stderr, :status
+
+    def initialize cmd
+      @cmd = cmd
+    end
+
+    def run
+      @stdout, @stderr, @status = Open3.capture3 @cmd
+    end
+
+  end
+
+end

data/lib/transrate/comparative_metrics.rb

@@ -1,7 +1,8 @@
 require 'set'
+require 'crb-blast'
 
 module Transrate
-  
+
   class ComparativeMetrics
 
     attr_reader :rbh_per_contig
@@ -9,21 +10,26 @@ module Transrate
     attr_reader :reciprocal_hits
     attr_reader :has_run
     attr_reader :reference_coverage
+    attr_reader :n_chimeras, :p_chimeras
 
-    def initialize assembly, reference
+    def initialize assembly, reference, threads
       @assembly = assembly
       @reference = reference
-      @usearch = Usearch.new
+      @threads = threads
     end
 
     def run
-      rbu = reciprocal_best_ublast
-      @ortholog_hit_ratio = ortholog_hit_ratio rbu
-      @collapse_factor = collapse_factor @ra.r2l_hits
-      @reciprocal_hits = rbu.size
+      @crbblast = reciprocal_best_blast
+      @ortholog_hit_ratio = ortholog_hit_ratio @crbblast
+      @collapse_factor = collapse_factor @crbblast.target_results
+      @reciprocal_hits = @crbblast.size
       @rbh_per_reference = @reciprocal_hits.to_f / @reference.size.to_f
       @reference_coverage = @ortholog_hit_ratio * @rbh_per_reference
       @rbh_per_contig = @reciprocal_hits.to_f / @assembly.assembly.size.to_f
+      @p_contigs_with_recip = @crbblast.reciprocals.size / @assembly.size.to_f
+      @n_contigs_with_recip = @crbblast.reciprocals.size
+      @p_refs_with_recip = @n_refs_with_recip / @reference.size.to_f
+      chimeras @crbblast
       @has_run = true
     end
 
@@ -31,33 +37,247 @@ module Transrate
       {
         :reciprocal_hits => @reciprocal_hits,
         :rbh_per_contig => @rbh_per_contig,
+        :p_contigs_with_recip => @p_contigs_with_recip,
+        :n_contigs_with_recip => @n_contigs_with_recip,
+        :p_refs_with_recip => @p_refs_with_recip,
+        :n_refs_with_recip => @n_refs_with_recip,
         :rbh_per_reference => @rbh_per_reference,
         :reference_coverage => @reference_coverage,
         :ortholog_hit_ratio => @ortholog_hit_ratio,
-        :collapse_factor => @collapse_factor
+        :collapse_factor => @collapse_factor,
+        :n_chimeras => @n_chimeras,
+        :p_chimeras => @p_chimeras,
+        :cov25 => @cov[0],
+        :cov50 => @cov[1],
+        :cov75 => @cov[2],
+        :cov85 => @cov[3],
+        :cov95 => @cov[4],
+        :p_cov25 => @cov[0]/@reference.size.to_f,
+        :p_cov50 => @cov[1]/@reference.size.to_f,
+        :p_cov75 => @cov[2]/@reference.size.to_f,
+        :p_cov85 => @cov[3]/@reference.size.to_f,
+        :p_cov95 => @cov[4]/@reference.size.to_f
       }
     end
 
-    def reciprocal_best_ublast
-      @ra = ReciprocalAnnotation.new @assembly, @reference
-      @ra.run
+    def reciprocal_best_blast
+      crbblast = CRB_Blast.new @assembly.file, @reference.file
+      crbblast.run 1e-5, @threads
+      crbblast
     end
 
-    def ortholog_hit_ratio rbu=nil
+    # coverage of contigs that have reciprocal hits
+    # divided by
+    # number of reciprocal targets
+    def ortholog_hit_ratio crbblast
       return @ortholog_hit_ratio unless @ortholog_hit_ratio.nil?
-      divisor = (rbu.size * 100).to_f 
-      rbu.reduce(0){ |sum, hit| sum += hit.last.target_coverage } / divisor
+
+      targets = Hash.new
+      crbblast.reciprocals.each_pair do |key, list|
+        list.each do |hit|
+          targets[hit.target] ||= [] # if key doesn't exist add it with a []
+          targets[hit.target] << hit
+        end
+      end
+      @n_refs_with_recip = targets.size
+      total_coverage=0
+      total_length=0
+      targets.each_pair do |key, list|
+        blocks = []
+        target_length = 0
+        list.each do |hit|
+          target_length = hit.tlen
+          if crbblast.target_is_prot
+            target_length *= 3
+            start, stop = [hit.tstart*3, hit.tend*3].minmax
+          else
+            start, stop = [hit.tstart, hit.tend].minmax
+          end
+          if blocks.empty?
+            blocks << [start, stop]
+          else
+            found=false
+            blocks.each do |block|
+              # if query overlaps with any block extend that block
+              o = overlap(block[0], block[1], start, stop)
+              if o == 0 # perfect overlap
+                found=true
+              elsif o == 1 # partial overlap
+                block[0] = start
+                found=true
+              elsif o == 2 # partial overlap
+                block[1] = stop
+                found=true
+              elsif o == 3 # full overlap
+                block[0] = start
+                block[1] = stop
+                found=true
+              # elsif o == 4 # full overlap
+                # nothing
+              # elsif o == 5 || o == 6 # no overlap
+
+              end
+            end
+            if !found
+              blocks << [start, stop]
+            end
+            # if any blocks now overlap then extend one block and remove
+            # the other
+          end
+        end
+        blocks.each_with_index do |block_a,a|
+          blocks.each_with_index do |block_b,b|
+            if a!=b
+              o = overlap(block_a[0], block_a[1], block_b[0], block_b[1])
+              if o == 0 # perfect overlap
+                block_b[0]=-1
+                block_b[1]=-1
+              elsif o == 1 # partial overlap
+                block_a[0] = block_b[0]
+                block_b[0] = -1
+                block_b[1] = -1
+              elsif o == 2 # partial overlap
+                block_a[1] = block_b[1]
+                block_b[0] = -1
+                block_b[1] = -1
+              elsif o == 3 # full overlap
+                block_a[0] = block_b[0]
+                block_a[1] = block_b[1]
+                block_b[0] = -1
+                block_b[1] = -1
+              elsif o == 4 # full overlap
+                block_b[0] = -1
+                block_b[1] = -1
+              # elsif o == 5 || o == 6# no overlap
+                # do nothing
+              # elsif  # no overlap
+                # do nothing
+              end
+            end
+          end # each_with_index b
+        end # each_with_index a
+        # sum blocks to find total coverage
+        length_of_coverage=0
+        blocks.each do |block|
+          if block[0] and block[1]
+            if block[0]>=0 and block[1]>=0
+              length_of_coverage += block[1] - block[0] + 1
+            end
+          else
+            puts "error: key = #{key}, #{blocks}"
+          end
+        end
+        cov = [0.25, 0.5, 0.75, 0.85, 0.95]
+        @cov ||= [0, 0, 0, 0, 0]
+        p = length_of_coverage / target_length.to_f
+        cov.each_with_index do |c, i|
+          if p >= c
+            @cov[i] +=1
+          end
+        end
+        total_coverage += length_of_coverage
+        total_length += target_length
+      end
+      return ortholog_hit_ratio = total_coverage / total_length.to_f
+    end
+
+    def chimeras crbblast
+      @n_chimeras = 0
+      crbblast.reciprocals.each_pair do |key, list|
+        p = 0
+        list.each_with_index do |a, i|
+          list.each_with_index do |b, j|
+            if j>i
+              if a.target == b.target
+                astart, astop = [a.tstart, a.tend].minmax
+                bstart, bstop = [b.tstart, b.tend].minmax
+
+                oa = overlap_amount(astart, astop, bstart, bstop)
+                if oa > 0.75
+                  p += 1
+                end
+              else
+                astart, astop = [a.qstart, a.qend].minmax
+                bstart, bstop = [b.qstart, b.qend].minmax
+
+                oa = overlap_amount(astart, astop, bstart, bstop)
+                if oa < 0.25
+                  p += 1
+                end
+              end
+            end
+          end
+        end
+        if p/list.size.to_f >= 0.5
+          @n_chimeras += 1
+        end
+      end
+      @p_chimeras = @n_chimeras / crbblast.reciprocals.length.to_f
+    end
+
+    def overlap(astart, astop, bstart, bstop)
+      if astart == bstart and astop == bstop
+        return 0
+      elsif astart < bstart
+        if astop > bstart
+          if astop > bstop
+            return 4
+          else
+            return 2
+          end
+        else
+          return 5 # no overlap
+        end
+      else
+        if bstop > astart
+          if bstop > astop
+            return 3
+          else
+            return 1
+          end
+        else
+          return 6 # no overlap
+        end
+      end
+    end
+
+    def overlap_amount(astart, astop, bstart, bstop)
+      if astart == bstart and astop == bstop
+        return 1
+      elsif astart < bstart
+        if astop > bstart
+          if astop > bstop
+            return (bstop-bstart+1)/(astop-astart+1).to_f # 4
+          else
+            return (astop-bstart+1)/(bstop-astart+1).to_f # 2
+          end
+        else
+          return 0 # 5 no overlap
+        end
+      else
+        if bstop > astart
+          if bstop > astop
+            return (astop-astart+1)/(bstop-bstart+1).to_f # 3
+          else
+            return (bstop-astart+1)/(astop-bstart+1).to_f # 1
+          end
+        else
+          return 0 # 6 no overlap
+        end
+      end
     end
 
     def collapse_factor hits=nil
       return @collapse_factor unless @collapse_factor.nil?
       targets = {}
-      hits.each_pair do |query, hit|
-        target = hit.target
-        unless targets.has_key? target 
-          targets[target] = Set.new
+      hits.each_pair do |query, list|
+        list.each do |hit|
+          target = hit.target
+          unless targets.has_key? target
+            targets[target] = Set.new
+          end
+          targets[target] << query
         end
-        targets[target] << query
       end
       sum = targets.values.reduce(0.0){ |summer, val| summer += val.size }
       sum / targets.size

data/lib/transrate/contig.rb

@@ -0,0 +1,212 @@
+require 'forwardable'
+require 'inline'
+
+module Transrate
+
+  # A contig in a transcriptome assembly.
+  class Contig
+
+    include Enumerable
+    extend Forwardable
+    def_delegators :@seq, :size, :length
+    attr_accessor :seq, :name, :coverage
+
+    def initialize(seq, name: nil)
+      @seq = seq
+      @name = seq.respond_to?(:entry_id) ? seq.entry_id : name
+    end
+
+    def each &block
+      @seq.seq.each_char &block
+    end
+
+    # Base composition of the contig
+    def base_composition
+      if @base_composition
+        return @base_composition
+      end
+      base_comp = {
+        :a => 0,
+        :t => 0,
+        :c => 0,
+        :g => 0,
+        :n => 0
+      }
+      dibase_comp = {
+        :cg => 0
+      }
+      last_base = nil
+      @seq.seq.each_char do |base|
+        # single bases
+        key = base.downcase.to_sym
+        base_comp[key] += 1
+        if last_base
+          # pairs of bases
+          dikey = "#{last_base}#{base}".downcase.to_sym
+          if dibase_comp[dikey]
+            dibase_comp[dikey] += 1
+          else
+            dibase_comp[dikey] = 1
+          end
+        end
+        last_base = base
+      end
+      @base_composition = base_comp
+      @dibase_composition = dibase_comp
+      return base_comp
+    end
+
+    # Dibase composition of the contig
+    def dibase_composition
+      if @dibase_composition
+        return @dibase_composition
+      end
+      base_composition
+      @dibase_composition
+    end
+
+    # Number of bases that are C
+    def bases_c
+      base_composition[:c]
+    end
+
+    # Proportion of bases that are C
+    def prop_c
+      bases_c / length.to_f
+    end
+
+    # Number of bases that are G
+    def bases_g
+      base_composition[:g]
+    end
+
+    # Proportion of bases that are G
+    def prop_g
+      bases_g / length.to_f
+    end
+
+    # Number of bases that are A
+    def bases_a
+      base_composition[:a]
+    end
+
+    # Proportion of bases that are A
+    def prop_a
+      bases_a / length.to_f
+    end
+
+    # Number of bases that are T
+    def bases_t
+      base_composition[:t]
+    end
+
+    # Proportion of bases that are T
+    def prop_t
+      bases_t / length.to_f
+    end
+
+    def bases_n
+      base_composition[:n]
+    end
+
+    def prop_n
+      bases_n / length.to_f
+    end
+
+    # GC
+    def bases_gc
+      bases_g + bases_c
+    end
+
+    def prop_gc
+      prop_g + prop_c
+    end
+
+    # GC skew
+    def gc_skew
+      prop_gc / (prop_a + prop_t + prop_gc)
+    end
+
+    # AT skew
+    def at_skew
+      prop_a + prop_t / (prop_a + prop_t + prop_gc)
+    end
+
+    # CpG count
+    def cpg_count
+      dibase_composition[:cg]
+    end
+
+    # CpG (C-phosphate-G) ratio
+    def cpg_ratio
+      dibase_composition[:cg] / (prop_c * prop_g)
+    end
+
+    # Find the longest orf in the contig
+    def orf_length
+      longest = longest_orf @seq.seq
+      return longest
+    end
+
+    # Inlined C longest-ORF function
+    inline do |builder|
+      builder.c <<SRC
+        static
+        void
+        longest_orf(VALUE _s) {
+          int i,sl,longest=0;
+          int len[6];
+          char * c_str;
+
+          sl = RSTRING_LEN(_s);
+          c_str = StringValueCStr(_s);
+          for (i=0;i<6;i++) {
+            len[i]=0;
+          }
+          for (i=0;i<sl-2;i++) {
+            if (c_str[i]=='T' &&
+              ((c_str[i+1]=='A' && c_str[i+2]=='G') ||
+              (c_str[i+1]=='A' && c_str[i+2]=='A') ||
+              (c_str[i+1]=='G' && c_str[i+2]=='A'))) {
+              if (len[i%3] > longest) {
+                longest = len[i%3];
+              }
+              len[i%3]=0;
+            } else {
+              len[i%3]++;
+            }
+            if (c_str[i+2]=='A' &&
+              ((c_str[i]=='C' && c_str[i+1]=='T') ||
+              (c_str[i]=='T' && c_str[i+1]=='T') ||
+              (c_str[i]=='T' && c_str[i+1]=='C'))) {
+              if (len[3+i%3] > longest) {
+                longest = len[3+i%3];
+              }
+              len[3+i%3]=0;
+            } else {
+              len[3+i%3]++;
+            }
+          }
+          if (len[i%3] > longest) {
+            longest = len[i%3];
+          }
+          if (len[3+i%3] > longest) {
+            longest = len[3+i%3];
+          }
+          return INT2NUM(longest);
+        }
+SRC
+    end
+
+    def linguistic_complexity k
+      d = 4 ** k
+      set = Set.new
+      (0..@seq.length-k).each do |i|
+        set << @seq.seq.slice(i,k).upcase # slice(start, length)
+      end # count how many kmers in seq
+      set.size / d.to_f
+    end
+
+  end
+
+end