transrate 0.2.0 → 0.3.0

data/lib/transrate.rb

@@ -15,6 +15,7 @@ require 'transrate/metric'
 require 'transrate/dimension_reduce'
 require 'transrate/samtools'
 require 'transrate/cmd'
+require 'transrate/transrate.so'
 
 # Transrate is a comprehensive transcriptome assembly
 # quality assessment tool.

data/lib/transrate/assembly.rb

@@ -26,7 +26,7 @@ module Transrate
 
     include Enumerable
     extend Forwardable
-    def_delegators :@assembly, :each, :<<, :size, :length
+    def_delegators :@assembly, :each, :each_value, :<<, :size, :length, :[]
 
     attr_accessor :file
     attr_reader :assembly
@@ -43,11 +43,12 @@ module Transrate
       unless File.exist? @file
         raise IOError.new "Assembly file doesn't exist: #{@file}"
       end
-      @assembly = []
+      @assembly = {}
       @n_bases = 0
       Bio::FastaFormat.open(file).each do |entry|
         @n_bases += entry.length
-        @assembly << Contig.new(entry)
+        contig = Contig.new(entry)
+        @assembly[contig.name] = contig
       end
       @contig_metrics = ContigMetrics.new self
     end
@@ -78,7 +79,7 @@ module Transrate
     # @return [Hash] basic statistics about the assembly
     def basic_stats threads=1
       return @basic_stats if @basic_stats
-      bin = @assembly.dup
+      bin = @assembly.values
       @basic_stats = basic_bin_stats bin
       @basic_stats
     end # basic_stats
@@ -103,7 +104,7 @@ module Transrate
     # representing contigs in the assembly
 
     def basic_bin_stats bin
-      
+
       # cumulative length is a float so we can divide it
       # accurately later to get the mean length
       cumulative_length = 0.0
@@ -194,7 +195,7 @@ module Transrate
       covfile = Samtools.coverage bam
       # get an assembly enumerator
       assembly_enum = @assembly.to_enum
-      contig = assembly_enum.next
+      contig_name, contig = assembly_enum.next
       # precreate an array of the correct size to contain
       # coverage. this is necessary because samtools mpileup
       # doesn't print a result line for bases with 0 coverage
@@ -209,12 +210,13 @@ module Transrate
           break
         end
         # extract the columns
-        name, pos, cov = cols[name_i], cols[pos_i].to_i, cols[cov_i].to_i
-        unless contig.name == name
-          while contig.name != name
+        name = Bio::FastaDefline.new(cols[name_i]).entry_id
+        pos, cov =  cols[pos_i].to_i, cols[cov_i].to_i
+        unless contig_name == name
+          while contig_name != name
             begin
               block.call(contig, contig.coverage)
-              contig = assembly_enum.next
+              contig_name, contig = assembly_enum.next
               contig.coverage = Array.new(contig.length, 0)
             rescue StopIteration => stop_error
               logger.error 'reached the end of assembly enumerator while ' +

data/lib/transrate/bowtie2.rb

@@ -49,6 +49,9 @@ module Transrate
         # run bowtie
         runner = Cmd.new bowtiecmd
         runner.run
+        if !runner.status.success?
+          raise Bowtie2Error.new("Bowtie2 failed\n#{runner.stderr}")
+        end
       end
       @sam
     end
@@ -59,6 +62,10 @@ module Transrate
         cmd = "#{@bowtie2_build} --quiet --offrate 1 #{file} #{@index_name}"
         runner = Cmd.new cmd
         runner.run
+        if !runner.status.success?
+          msg = "Failed to build Bowtie2 index\n#{runner.stderr}"
+          raise Bowtie2Error.new(msg)
+        end
       end
       @index_built = true
     end

data/lib/transrate/comparative_metrics.rb

@@ -10,86 +10,89 @@ module Transrate
     attr_reader :reciprocal_hits
     attr_reader :has_run
     attr_reader :reference_coverage
+    attr_reader :comp_stats
     attr_reader :n_chimeras, :p_chimeras
 
     def initialize assembly, reference, threads
       @assembly = assembly
       @reference = reference
       @threads = threads
+      @comp_stats = Hash.new
     end
 
     def run
       @crbblast = reciprocal_best_blast
-      @ortholog_hit_ratio = ortholog_hit_ratio @crbblast
-      @collapse_factor = collapse_factor @crbblast.target_results
+      @reference_coverage = coverage @crbblast
+      @collapse_factor = collapse_factor @crbblast.reciprocals
       @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
+      count_ref_crbbs
       @p_refs_with_recip = @n_refs_with_recip / @reference.size.to_f
       chimeras @crbblast
+      self.run_comp_stats
       @has_run = true
     end
 
-    def comp_stats
-      {
-        :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,
-        :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
-      }
+    def run_comp_stats
+      @comp_stats[:CRBB_hits] = @reciprocal_hits # CRBB hits
+      @comp_stats[:p_contigs_with_CRBB] = @p_contigs_with_recip
+      @comp_stats[:n_contigs_with_CRBB] = @n_contigs_with_recip
+      @comp_stats[:p_refs_with_CRBB] = @p_refs_with_recip
+      @comp_stats[:n_refs_with_CRBB] = @n_refs_with_recip
+      @comp_stats[:rbh_per_reference] = @rbh_per_reference
+      @comp_stats[:reference_coverage] = @reference_coverage
+      @comp_stats[:collapse_factor] = @collapse_factor
+      @comp_stats[:n_chimeras] = @n_chimeras
+      @comp_stats[:p_chimeras] = @p_chimeras
     end
 
     def reciprocal_best_blast
-      crbblast = CRB_Blast.new @assembly.file, @reference.file
-      crbblast.run 1e-5, @threads
+      crbblast = CRB_Blast::CRB_Blast.new @assembly.file, @reference.file
+      crbblast.run(1e-5, @threads, true)
       crbblast
     end
 
     # 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?
+    # divided by number of reciprocal targets
+    def coverage crbblast
+      return @reference_coverage unless @reference_coverage.nil?
+      crbblast.reciprocals.each do |key, list|
+        list.each_with_index do |hit, i|
+          unless @reference.assembly.key? hit.target
+            raise "#{hit.target} not in reference"
+          end
+          @reference[hit.target].hits << hit
 
-      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
+          unless @assembly.assembly.key? hit.query
+            raise "#{hit.query} not in assembly"
+          end
+          contig = @assembly[hit.query]
+          contig.has_crb = true
+          # how much of the reference is covered by this single contig
+          contig.reference_coverage = hit.alnlen / hit.tlen
+          contig.hits << hit
         end
       end
-      @n_refs_with_recip = targets.size
-      total_coverage=0
-      total_length=0
-      targets.each_pair do |key, list|
+      total_coverage = 0
+      total_length = 0
+      cov = [0.25, 0.5, 0.75, 0.85, 0.95]
+      @reference.each_value do |ref_contig|
+        key = ref_contig.name
+        list = ref_contig.hits
+        total_length += crbblast.target_is_prot ? ref_contig.length : ref_contig.length*3
+
+        next if list.empty? # ah this is what was breaking everything
         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
+            start, stop = [hit.tstart, hit.tend].minmax
+            start = start*3-2
+            stop = stop*3
           else
             start, stop = [hit.tstart, hit.tend].minmax
           end
@@ -112,7 +115,8 @@ module Transrate
                 block[0] = start
                 block[1] = stop
                 found=true
-              # elsif o == 4 # full overlap
+              elsif o == 4 # full overlap
+                found=true
                 # nothing
               # elsif o == 5 || o == 6 # no overlap
 
@@ -157,28 +161,53 @@ module Transrate
           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]
+        length_of_coverage = calculate_coverage blocks
         @cov ||= [0, 0, 0, 0, 0]
-        p = length_of_coverage / target_length.to_f
+        if target_length > 0
+          # puts "#{length_of_coverage} / #{target_length.to_f}"
+          ref_p = length_of_coverage / target_length.to_f
+        else
+          ref_p = 0
+        end
+        ref_contig.reference_coverage = ref_p
+
         cov.each_with_index do |c, i|
-          if p >= c
+          if ref_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
+      cov.each_with_index do |p, i|
+        @comp_stats["cov#{(100*p).to_i}".to_sym] = @cov[i]
+        @comp_stats["p_cov#{(100*p).to_i}".to_sym] =
+                                                  @cov[i]/@reference.size.to_f
+      end
+      total_coverage / total_length.to_f
+    end
+
+    # Calculate the total coverage from a set of coverage blocks
+    def calculate_coverage blocks
+      coverage = 0
+      blocks.each do |block|
+        if block[0] and block[1]
+          if block[0]>=0 and block[1]>=0
+            coverage += block[1] - block[0] + 1
+          end
+        else
+          puts "error: key = #{key}, #{blocks}"
+        end
+      end
+      coverage
+    end
+
+    # Count reference proteins with at least one recprocal hit
+    def count_ref_crbbs
+      @n_refs_with_recip = @reference.assembly.inject(0) do |sum, entry|
+        name, contig = entry
+        sum + (contig.hits.length > 0 ? 1 : 0)
+      end
     end
 
     def chimeras crbblast
@@ -210,6 +239,10 @@ module Transrate
         end
         if p/list.size.to_f >= 0.5
           @n_chimeras += 1
+          unless @assembly.assembly.key? key
+            puts "key not in assembly: #{key}"
+          end
+          @assembly[key].is_chimera = true
         end
       end
       @p_chimeras = @n_chimeras / crbblast.reciprocals.length.to_f
@@ -267,20 +300,17 @@ module Transrate
       end
     end
 
-    def collapse_factor hits=nil
+    # Count unique reference proteins per contig
+    def collapse_factor reciprocals
       return @collapse_factor unless @collapse_factor.nil?
-      targets = {}
-      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
+      cf_sum = 0
+      reciprocals.each do |query, hits|
+        uniq_hits = Set.new hits.map{ |h| h.target }
+        cf = uniq_hits.length
+        @assembly[query].collapse_factor = cf
+        cf_sum += cf
       end
-      sum = targets.values.reduce(0.0){ |summer, val| summer += val.size }
-      sum / targets.size
+      cf_sum / reciprocals.size
     end
 
   end # ComparativeMetrics

data/lib/transrate/contig.rb

@@ -1,5 +1,4 @@
 require 'forwardable'
-require 'inline'
 
 module Transrate
 
@@ -9,51 +8,105 @@ module Transrate
     include Enumerable
     extend Forwardable
     def_delegators :@seq, :size, :length
-    attr_accessor :seq, :name, :coverage
+    attr_accessor :seq, :name
+    # read-based metrics
+    attr_accessor :coverage, :uncovered_bases, :mean_coverage, :in_bridges
+    # reference-based metrics
+    attr_accessor :has_crb, :is_chimera, :collapse_factor, :reference_coverage
+    attr_accessor :hits
 
     def initialize(seq, name: nil)
+      seq.seq.gsub!("\0", "") # there is probably a better fix than this
       @seq = seq
+      @seq.data = nil # no need to store raw fasta string
       @name = seq.respond_to?(:entry_id) ? seq.entry_id : name
+      @hits = []
+      @reference_coverage = 0
+      @collapse_factor = 0
+      @is_chimera = false
+      @has_crb = false
+      @in_bridges = 0
+      @mean_coverage = 0
     end
 
     def each &block
       @seq.seq.each_char &block
     end
 
+    # Get all metrics available for this contig
+    def basic_metrics
+      basic = {
+        :length => length,
+        :prop_gc => prop_gc,
+        :gc_skew => gc_skew,
+        :at_skew => at_skew,
+        :cpg_count => cpg_count,
+        :cpg_ratio => cpg_ratio,
+        :orf_length => orf_length,
+        :linguistic_complexity_6 => linguistic_complexity(6)
+      }
+    end
+
+    def read_metrics
+      read = @coverage ? {
+        :uncovered_bases => uncovered_bases,
+        :mean_coverage => mean_coverage,
+        :in_bridges => in_bridges
+      } : {
+        :uncovered_bases => "NA",
+        :mean_coverage => "NA",
+        :in_bridges => in_bridges
+      }
+    end
+
+    def comparative_metrics
+      reference = @has_crb ? {
+        :has_crb => has_crb,
+        :collapse_factor => collapse_factor,
+        :reference_coverage => reference_coverage,
+        :is_chimera => is_chimera,
+        :hits => hits.map{ |h| h.target }.join(";")
+      } : {
+        :has_crb => false,
+        :collapse_factor => "NA",
+        :reference_coverage => "NA",
+        :is_chimera => "NA",
+        :hits => "NA"
+      }
+    end
+
     # Base composition of the contig
+    #
+    # If called and the instance variable @base_composition is nil
+    # then call the c method to count the bases and dibases in the sequence
+    # then get the info out of the c array and store it in the hash
+    # then if it is called again just return the hash as before
     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
+      # else run the C method
+      composition(@seq.seq)
+      alphabet = ['a', 'c', 'g', 't', 'n']
+      @base_composition = {}
+      @dibase_composition={}
+      bases = []
+      dibases = []
+      alphabet.each do |c|
+        bases << "#{c}".to_sym
+      end
+      alphabet.each do |c|
+        alphabet.each do |d|
+          dibases << "#{c}#{d}".to_sym
         end
-        last_base = base
       end
-      @base_composition = base_comp
-      @dibase_composition = dibase_comp
-      return base_comp
+      bases.each_with_index do |a,i|
+        @base_composition[a] = base_count(i)
+      end
+      dibases.each_with_index do |a,i|
+        @dibase_composition[a] = dibase_count(i)
+      end
+      return @base_composition
     end
 
     # Dibase composition of the contig
@@ -124,89 +177,37 @@ module Transrate
 
     # GC skew
     def gc_skew
-      prop_gc / (prop_a + prop_t + prop_gc)
+      (bases_g - bases_c) / (bases_g + bases_c).to_f
     end
 
     # AT skew
     def at_skew
-      prop_a + prop_t / (prop_a + prop_t + prop_gc)
+      (bases_a - bases_t) / (bases_a + bases_t).to_f
     end
 
     # CpG count
     def cpg_count
-      dibase_composition[:cg]
+      dibase_composition[:cg] + dibase_composition[:gc]
     end
 
-    # CpG (C-phosphate-G) ratio
+    # observed-to-expected CpG (C-phosphate-G) ratio
     def cpg_ratio
-      dibase_composition[:cg] / (prop_c * prop_g)
+      r = dibase_composition[:cg] + dibase_composition[:gc]
+      r /= (bases_c * bases_g).to_f
+      r *= (length - bases_n)
+      return r
     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
+      return @orf_length if @orf_length
+      @orf_length = longest_orf(@seq.seq) # call to C
+      return @orf_length
     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
+      return kmer_count(k, @seq.seq)/(4**k).to_f # call to C
     end
-
   end
 
 end