transrate 1.0.0.beta3 → 1.0.0.beta4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a663790460cbe480bce88af21df3609e8b63a073
-  data.tar.gz: 22b4fb0af30dc78afeee914abd8b93d1e7dd7966
+  metadata.gz: e6662137942e3933a714a4950d4de53826b71aad
+  data.tar.gz: 2863b7bc2b0f63af4c43dc31c77f43324dafccfc
 SHA512:
-  metadata.gz: ed8cad8ff40d18fd6ce7b1a78bf8a6dab2ef0b141d98a08c5403e8f766e4b11ab79f96e32f30abdae951c6fee3b5d31c3a2cc1d3c98a5a93c20ea258b6424183
-  data.tar.gz: a60476a414dc3626d80d5d1f8ed967c3dcb79563ce97454b79b5f5595451c4285582650591b5974ac0114980482fadd8f6e6d12c50f392a41cac04fe1562ce86
+  metadata.gz: 30f64bf256bb98ae6031ee635c1187af680974fa97bc719d108a3878cfacaef7216fd5c8c5e0a07be077eca55d6379e1562f425eee3948d86a1f2dc816f1cfef
+  data.tar.gz: fb8fbd6cc684112693fd7241860724938610efa9b8950811b4cfe7b9b5232b28a8101a1c49157fa22a0aff979029628c6141f75a271871cc0a07ffe2402b7666

data/README.md

@@ -2,8 +2,11 @@
   <img alt="Transrate - understand your transcriptome assembly" src="https://github.com/Blahah/transrate/raw/master/docs/transrate_logo_full.png">
 </p>
 
+Download latest binaries: [![Download](https://api.bintray.com/packages/blahah/generic/transrate/images/download.svg)][bintray]
+
 Need help? Chat to us live: [![Gitter](https://badges.gitter.im/Join Chat.svg)](https://gitter.im/Blahah/transrate?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
+
 ## Development status
 
 [![Gem Version](http://img.shields.io/gem/v/transrate.svg)][gem]
@@ -19,6 +22,7 @@ Need help? Chat to us live: [![Gitter](https://badges.gitter.im/Join Chat.svg)](
 [gemnasium]: https://gemnasium.com/Blahah/transrate
 [codeclimate]: https://codeclimate.com/github/Blahah/transrate
 [coveralls]: https://coveralls.io/r/Blahah/transrate
+[bintray]: https://bintray.com/blahah/generic/transrate/_latestVersion
 
 This software is being actively developed. Please be aware that there may be bugs. If you find any, please report them on the [issue tracker](https://github.com/Blahah/transrate/issues).
 

data/Rakefile

@@ -90,7 +90,7 @@ task :default => :test
 # PACKAGING
 
 PACKAGE_NAME = "transrate"
-VERSION = "1.0.0.beta3"
+VERSION = "1.0.0.beta4"
 TRAVELING_RUBY_VERSION = "20150210-2.2.0"
 
 desc "Package your app"

data/bin/transrate

@@ -32,7 +32,8 @@ opts = Trollop::options do
   banner <<-EOS
 
   Transrate v#{Transrate::VERSION::STRING.dup}
-  by Richard Smith-Unna <rds45@cam.ac.uk> and Chris Boursnell
+  by Richard Smith-Unna, Chris Boursnell, Rob Patro,
+     Julian Hibberd, and Steve Kelly
 
   DESCRIPTION:
   Analyse a de-novo transcriptome assembly using three kinds of metrics:
@@ -64,12 +65,12 @@ opts = Trollop::options do
   EOS
   opt :assembly, "Assembly file(s) in FASTA format, comma-separated",
       :type => String
-  opt :reference, "Reference proteome file in FASTA format",
-      :type => String
   opt :left, "Left reads file in FASTQ format",
       :type => String
   opt :right, "Right reads file in FASTQ format",
       :type => String
+  opt :reference, "Reference proteome file in FASTA format",
+      :type => String
   opt :threads, "Number of threads to use",
       :default => 8,
       :type => Integer
@@ -95,7 +96,7 @@ blast_dep = File.join(gem_dir, 'deps', 'blast.yaml')
 deps, read_deps, ref_deps = nil
 unless opts.install_deps.nil?
 
-  unless %w[all read red].include? opts.install_deps
+  unless %w[all read ref].include? opts.install_deps
     raise TransrateError.new "install-deps #{opts.install_deps} is not valid. " +
     "You must specify one of: all, read, ref."
   end
@@ -110,12 +111,12 @@ if deps || read_deps || ref_deps
   puts "Checking dependencies"
 
   missing = []
-  if opts.install_deps || opts.install_read_deps
+  if deps || read_deps
     Bindeps.require gem_deps
     missing += Bindeps.missing gem_deps
   end
 
-  if opts.install_deps || opts.install_ref_deps
+  if deps || ref_deps
     Bindeps.require blast_dep
     missing += Bindeps.missing blast_dep
   end
@@ -307,9 +308,12 @@ assemblies.split(',').each do |assembly|
     logger.info "No reference provided, skipping comparative diagnostics"
   end
 
+  prefix = "#{opts.outfile}_#{File.basename(assembly)}"
+
   if (opts.left && opts.right)
     score = transrater.assembly_score
-    optimal, cutoff = transrater.assembly_optimal_score
+
+    optimal, cutoff = transrater.assembly_optimal_score prefix
     unless score.nil?
       pretty_print_hash({:TRANSRATE_ASSEMBLY_SCORE => score}, report_width, 4)
       logger.info "-" * report_width
@@ -320,7 +324,7 @@ assemblies.split(',').each do |assembly|
   end
 
   # write contig metrics to file for each contig
-  outfile = "#{opts.outfile}_#{File.basename(assembly)}_contigs.csv"
+  outfile = "#{prefix}_contigs.csv"
   logger.info "Writing contig metrics for each contig to #{outfile}"
   # have option to turn off, default on
   first=true

data/deps/deps.yaml

@@ -23,9 +23,11 @@ salmon:
   binaries:
     - salmon
   libraries:
+    - libgcc_s.so.1
     - libgomp.so.1
     - libm.so.6
     - librt.so.1
+    - libstdc++.so.6
     - libtbb.so
     - libtbb.so.2
     - libtbbmalloc.so
@@ -37,10 +39,11 @@ salmon:
     - libtbb.dylib
     - libtbbmalloc.dylib
     - libtbbmalloc_proxy.dylib
+    - libsalmon_core.a
   version:
-    number: '0.3'
+    number: '0.4'
     command: 'salmon -v'
   url:
     64bit:
-      linux: https://github.com/kingsfordgroup/sailfish/releases/download/v0.3.0/SalmonBeta-v0.3.0_squeeze.tar.gz
-      macosx: https://github.com/kingsfordgroup/sailfish/releases/download/v0.3.0/SalmonBeta-v0.3.0_MacOSX-10.10.2.tar.gz
+      linux: https://github.com/COMBINE-lab/salmon/releases/download/v0.4.0/SalmonBeta-0.4.0_DebianSqueeze.tar.gz
+      macosx: https://github.com/COMBINE-lab/salmon/releases/download/v0.4.0/SalmonBeta-0.4.0_OSX-10.10.tar.gz

data/lib/transrate/assembly.rb

@@ -48,6 +48,10 @@ module Transrate
       @assembly = {}
       @n_bases = 0
       Bio::FastaFormat.open(file).each do |entry|
+        if entry.seq.length == 0
+          logger.error "Entry found with no sequence #{entry.entry_id}"
+          raise AssemblyError
+        end
         @n_bases += entry.length
         contig = Contig.new(entry)
         if @assembly.key?(contig.name)

data/lib/transrate/comparative_metrics.rb

@@ -20,249 +20,136 @@ module Transrate
     end
 
     def run
-      @crbblast = reciprocal_best_blast
-      @reference_coverage = coverage @crbblast
-      @reciprocal_hits = @crbblast.size
-      @rbh_per_reference = @reciprocal_hits.to_f / @reference.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
-      self.run_comp_stats
+      crbblast = run_crb_blast
+      calculate_reference_coverage crbblast
       @has_run = true
     end
 
-    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
+    def calculate_reference_coverage crbblast
+      # The reciprocals hash in crb blast has contig names as the key.
+      # In order to look up by the reference name we need to reverse this.
+      # Scan through the reciprocals and get this Hit objects and add them to
+      #   the @reference object for each reference sequence
+      get_reference_hits crbblast
+      per_query_contig_reference_coverage
+      per_target_contig_reference_coverage crbblast
     end
 
-    def reciprocal_best_blast
-      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 coverage crbblast
-      return @reference_coverage unless @reference_coverage.nil?
-      crbblast.reciprocals.each do |key, list|
-        list.each_with_index do |hit, i|
+    def get_reference_hits crbblast
+      crbblast.reciprocals.each do |query_id, list|
+        list.each do |hit|
           unless @reference.assembly.key? hit.target
             raise TransrateError.new "#{hit.target} not in reference"
           end
           @reference[hit.target].hits << hit
+        end
+      end
+      @comp_stats[:CRBB_hits] = crbblast.size
+      @comp_stats[:n_contigs_with_CRBB] = crbblast.reciprocals.size
+      @comp_stats[:p_contigs_with_CRBB] = crbblast.reciprocals.size/@assembly.size.to_f
+    end
 
-          unless @assembly.assembly.key? hit.query
-            raise TransrateError.new "#{hit.query} not in assembly"
+    def per_query_contig_reference_coverage
+      # for each query contig in the @assembly find out how much it covers
+      # the reference
+      n_refs_with_recip = 0
+      total_crbb_hits = 0
+      @reference.each do |ref_contig_name, ref_contig|
+        ref_contig.hits.each do |hit| # a Hit from query to target
+          query_contig_name = hit.query
+          unless @assembly.assembly.key? query_contig_name
+            raise TransrateError.new "#{query_contig_name} not in assembly"
           end
-          contig = @assembly[hit.query]
-          contig.has_crb = true
-          # how much of the reference is covered by this single contig
-          if crbblast.target_is_prot
-            contig.reference_coverage =
-                        (hit.alnlen - hit.mismatches - hit.gaps) / (3*hit.tlen)
+          @assembly[query_contig_name].has_crb = true
+          @assembly[query_contig_name].hits << hit
+          raise TransrateError.new "query should not be protein" if hit.qprot
+          if hit.tprot
+            coverage = 3*hit.alnlen+2 - 3*hit.mismatches - 3*hit.gaps
+            coverage /= 3.0*hit.tlen
           else
-            contig.reference_coverage =
-                            (hit.alnlen - hit.mismatches - hit.gaps) / hit.tlen
+            coverage = hit.alnlen - hit.mismatches - hit.gaps
+            coverage /= hit.tlen.to_f
           end
-          contig.hits << hit
+          @assembly[query_contig_name].reference_coverage = coverage
+        end
+
+        if ref_contig.hits.size > 0 # this reference has a crbblast hit
+          n_refs_with_recip += 1
         end
+        total_crbb_hits += ref_contig.hits.size
       end
+      @comp_stats[:rbh_per_reference] = total_crbb_hits / @reference.size.to_f
+      @comp_stats[:n_refs_with_CRBB] = n_refs_with_recip
+      @comp_stats[:p_refs_with_CRBB] = n_refs_with_recip / @reference.size.to_f
+    end
+
+    def per_target_contig_reference_coverage crbblast
+      # each target sequence in the reference can have multiple query contigs
+      # hit it. to calculate the reference coverage you can't just add up the
+      # alignment lengths. you have to make sure that overlaps are taken into
+      # account
+      coverage_thresholds = [0.25, 0.5, 0.75, 0.85, 0.95]
+      coverage_totals = [0, 0, 0, 0, 0]
+      prot = crbblast.target_is_prot
       total_coverage = 0
       total_length = 0
-      cov = [0.25, 0.5, 0.75, 0.85, 0.95]
-      @cov ||= [0, 0, 0, 0, 0]
-      @reference.each_value do |ref_contig|
-        key = ref_contig.name
-        list = ref_contig.hits
-        if crbblast.target_is_prot
-          total_length += ref_contig.length * 3
+      @reference.each do |ref_contig_name, ref_contig|
+        if prot
+          covered = Array.new(ref_contig.length*3, false)
         else
-          total_length += ref_contig.length
+          covered = Array.new(ref_contig.length, false)
         end
-        next if list.empty?
-        blocks = []
-        target_length = 0
-        list.each do |hit|
-          target_length = hit.tlen
-          if crbblast.target_is_prot
-            target_length *= 3
-            start, stop = [hit.tstart, hit.tend].minmax
-            start = start*3-2
-            stop = stop*3
-          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
-                found=true
-                # nothing
-              # elsif o == 5 || o == 6 # no overlap
-
-              end
+        ref_contig.hits.each_with_index do |hit, i| # a Hit from query to target
+          if prot
+            if hit.qstart % 3 == 0
+              tstart = 3*hit.tstart-4
+              tend = 3*hit.tend
+            elsif hit.qstart % 3 == 1
+              tstart = 3*hit.tstart-2
+              tend = 3*hit.tend
+            elsif hit.qstart % 3 == 2
+              tstart = 3*hit.tstart-3
+              tend = 3*hit.tend-1
             end
-            if !found
-              blocks << [start, stop]
+            if hit.qlen % 3 == 1
+              tend += 1
+            elsif hit.qlen % 3 == 2
+              tend += 2
             end
-            # if any blocks now overlap then extend one block and remove
-            # the other
+          else
+            tstart = hit.tstart
+            tend = hit.tend
+          end
+          (tstart..tend).each do |b|
+            covered[b-1] = true # blast coords are 1 indexed
           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 = calculate_coverage blocks
-        if target_length > 0
-          ref_p = length_of_coverage / target_length.to_f
-        else
-          ref_p = 0
-        end
+        coverage = covered.reduce(0) { |sum, v| v ? sum + 1 : sum }
+        ref_p = coverage / covered.length.to_f
         ref_contig.reference_coverage = ref_p
-
-        cov.each_with_index do |c, i|
-          if ref_p >= c
-            @cov[i] +=1
+        coverage_thresholds.each_with_index do |n, index|
+          if ref_p >= n
+            coverage_totals[index] += 1
           end
         end
 
-        total_coverage += length_of_coverage
+        total_coverage += coverage
+        total_length += covered.length
       end
 
-      cov.each_with_index do |p, i|
-        @comp_stats["cov#{(100*p).to_i}".to_sym] = @cov[i]
+      # calculate proportion of ref sequences with coveragre over thresholds
+      coverage_thresholds.each_with_index do |p, i|
+        @comp_stats["cov#{(100*p).to_i}".to_sym] = coverage_totals[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 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
+                                        coverage_totals[i]/@reference.size.to_f
       end
+      @comp_stats[:reference_coverage] = total_coverage / total_length.to_f
     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
+    def run_crb_blast
+      crbblast = CRB_Blast::CRB_Blast.new @assembly.file, @reference.file
+      crbblast.run(1e-5, @threads, true)
+      crbblast
     end
 
   end # ComparativeMetrics