genevalidator 1.6.12 → 2.1.3

data/lib/genevalidator/pool.rb

@@ -1,4 +1,3 @@
-# coding: utf-8
 # From http://burgestrand.se/code/ruby-thread-pool/
 #
 # Copyright © 2012, Kim Burgestrand kim@burgestrand.se
@@ -21,8 +20,6 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-require 'thread'
-
 # Class that creates a thread safe pool.
 class Pool
   def initialize(size)
@@ -58,8 +55,8 @@ if $PROGRAM_NAME == __FILE__
 
   20.times do |i|
     p.schedule do
-      sleep rand(4) + 2
-      $stderr.puts "Job #{i} finished by thread #{Thread.current[:id]}\n"
+      sleep rand(2..5)
+      warn "Job #{i} finished by thread #{Thread.current[:id]}\n"
     end
   end
   at_exit { p.shutdown }

data/lib/genevalidator/query.rb

@@ -22,7 +22,7 @@ module GeneValidator
     end
 
     def protein_translation
-      (@type == :protein) ? raw_sequence : @protein_translation
+      @type == :protein ? raw_sequence : @protein_translation
     end
 
     ##

data/lib/genevalidator/tabular_parser.rb

@@ -5,7 +5,6 @@ require 'genevalidator/exceptions'
 require 'genevalidator/hsp'
 require 'genevalidator/query'
 
-#
 module GeneValidator
   ##
   # This class parses the tabular output of BLAST (outfmt 6 & 7)
@@ -31,14 +30,9 @@ module GeneValidator
     ##
     #
     def analayse_tabular_file(filename)
-      results = []
-      file    = File.read(filename)
-      lines   = CSV.parse(file, col_sep: "\t", skip_lines: /^#/,
-                                headers: @column_names)
-      lines.each do |line|
-        results << line.to_hash
-      end
-      results
+      lines = CSV.parse(File.read(filename), col_sep: "\t", skip_lines: /^#/,
+                                             headers: @column_names)
+      lines.map(&:to_hash)
     end
 
     ##
@@ -63,7 +57,7 @@ module GeneValidator
       move_to_next_query
       hit_seq
     rescue StopIteration
-      return []
+      []
     end
 
     private
@@ -72,29 +66,14 @@ module GeneValidator
     #
     def initialise_classes(current_id, tab_results = @tab_results)
       hits = tab_results.partition { |h| h['qseqid'] == current_id }[0]
-      hit_list = []
       grouped_hits = hits.group_by { |row| row['sseqid'] }
 
-      grouped_hits.each do |query_id, row|
+      grouped_hits.map do |_query_id, rows|
         hit_seq = Query.new
-        hit_seq.init_tabular_attribute(row[0])
-
-        initialise_all_hsps(query_id, hits, hit_seq)
-
+        hit_seq.init_tabular_attribute(rows[0])
+        hit_seq.hsp_list = rows.map { |row| Hsp.new(tabular_input: row) }
         hit_seq.type = :protein
-        hit_list.push(hit_seq)
-      end
-      hit_list
-    end
-
-    ##
-    #
-    def initialise_all_hsps(current_query_id, hits, hit_seq)
-      hsps = hits.select { |row| row['sseqid'] == current_query_id }
-      hsps.each do |row|
-        hsp = Hsp.new
-        hsp.init_tabular_attribute(row)
-        hit_seq.hsp_list.push(hsp)
+        hit_seq
       end
     end
   end

data/lib/genevalidator/validation.rb

@@ -49,11 +49,14 @@ module GeneValidator
           break
         end
 
+        arr_idx = @config[:idx] - 1
+        next unless @config[:json_output][arr_idx].nil?
+
         if @opt[:num_threads] == 1
-          (Validate.new).validate(prediction, blast_hits, @config[:idx])
+          Validate.new.validate(prediction, blast_hits, @config[:idx])
         else
           p.schedule(prediction, blast_hits, @config[:idx]) do |pred, hits, idx|
-            (Validate.new).validate(pred, hits, idx)
+            Validate.new.validate(pred, hits, idx)
           end
         end
       end
@@ -63,18 +66,16 @@ module GeneValidator
 
     ##
     # get info about the query
-    def get_info_on_query_sequence(input_file = @opt[:input_fasta_file],
-                                        seq_type = @config[:type])
-      start_offset = @query_idx[@config[:idx] + 1] - @query_idx[@config[:idx]]
-      end_offset   = @query_idx[@config[:idx]]
-      query        = IO.binread(input_file, start_offset, end_offset)
+    def get_info_on_query_sequence(seq_type = @config[:type],
+                                   index = @config[:idx])
+      query        = GeneValidator.extract_input_fasta_sequence(index)
       parse_query  = query.scan(/>([^\n]*)\n([A-Za-z\n]*)/)[0]
 
       prediction                = Query.new
-      prediction.definition     = parse_query[0].gsub("\n", '')
+      prediction.definition     = parse_query[0].delete("\n")
       prediction.identifier     = prediction.definition.gsub(/ .*/, '')
       prediction.type           = seq_type
-      prediction.raw_sequence   = parse_query[1].gsub("\n", '')
+      prediction.raw_sequence   = parse_query[1].delete("\n")
       prediction.length_protein = prediction.raw_sequence.length
       prediction.length_protein /= 3 if seq_type == :nucleotide
       prediction
@@ -82,10 +83,10 @@ module GeneValidator
 
     # Adds 'maker' to @opt[:validations] if the first definiton in the input
     # fasta file contains MAKER's QI (quality index) score
-    def check_if_maker_input?(input_file = @opt[:input_fasta_file])
-      query        = IO.binread(input_file, @query_idx[1], @query_idx[0])
+    def check_if_maker_input?
+      query        = GeneValidator.extract_input_fasta_sequence(0)
       parse_query  = query.scan(/>([^\n]*)\n([A-Za-z\n]*)/)[0]
-      definition   = parse_query[0].gsub("\n", '')
+      definition   = parse_query[0].delete("\n")
       number       = '-?\d*\.?\d*'
       qi_match     = definition.match(/QI:#{number}\|#{number}\|#{number}\|
                                       #{number}\|#{number}\|#{number}\|
@@ -107,8 +108,7 @@ module GeneValidator
   # Class that runs the validations (Instatiated for each query)
   class Validate
     extend Forwardable
-    def_delegators GeneValidator, :opt, :config, :mutex_array, :overview,
-                   :query_idx
+    def_delegators GeneValidator, :opt, :config, :overview, :query_idx
 
     ##
     # Initilizes the object
@@ -121,7 +121,6 @@ module GeneValidator
     def initialize
       @opt         = opt
       @config      = config
-      @mutex_array = mutex_array
       @run_output  = nil
       @overview    = overview
       @query_idx   = query_idx
@@ -142,7 +141,7 @@ module GeneValidator
       @run_output.validations = vals.map(&:validation_report)
       check_validations_output(vals)
 
-      compute_scores
+      compute_run_score
       generate_run_output
     end
 
@@ -154,27 +153,24 @@ module GeneValidator
     # Output:
     # new array of hit +Sequence+ objects
     def remove_identical_hits(prediction, hits)
-      identical_hits = []
-      hits.each do |hit|
+      hits.delete_if do |hit|
         low_identity = hit.hsp_list.select { |hsp| hsp.pidentity < 99 }
         no_data      = hit.hsp_list.select { |hsp| hsp.pidentity.nil? }
         low_identity += no_data
-        # check the coverage
-        coverage = Array.new(prediction.length_protein, 0)
-        hit.hsp_list.each do |hsp|
-          match_to   = hsp.match_query_to
-          match_from = hsp.match_query_from
-          len        = match_to - match_from + 1
-          coverage[match_from - 1..match_to - 1] = Array.new(len, 1)
-        end
-
-        if low_identity.length == 0 && coverage.uniq.length == 1
-          identical_hits.push(hit)
-        end
+        coverage      = check_hit_coverage(prediction, hit)
+        low_identity.empty? && coverage.uniq.length == 1
       end
+    end
 
-      identical_hits.each { |hit| hits.delete(hit) }
-      hits
+    def check_hit_coverage(prediction, hit)
+      coverage = Array.new(prediction.length_protein, 0)
+      hit.hsp_list.each do |hsp|
+        match_to   = hsp.match_query_to
+        match_from = hsp.match_query_from
+        len        = match_to - match_from + 1
+        coverage[match_from - 1..match_to - 1] = Array.new(len, 1)
+      end
+      coverage
     end
 
     def create_validation_tests(prediction, hits)
@@ -197,45 +193,48 @@ module GeneValidator
 
     def check_validations(vals)
       # check the class type of the elements in the list
-      vals.each { |v| fail ValidationClassError unless v.is_a? ValidationTest }
+      vals.each { |v| raise ValidationClassError unless v.is_a? ValidationTest }
       # check alias duplication
       aliases = vals.map(&:cli_name)
-      fail AliasDuplicationError unless aliases.length == aliases.uniq.length
+      raise AliasDuplicationError unless aliases.length == aliases.uniq.length
     rescue ValidationClassError => e
-      $stderr.puts e
+      warn e
       exit 1
     rescue AliasDuplicationError => e
-      $stderr.puts e
+      warn e
       exit 1
     end
 
     def check_validations_output(vals)
-      fail NoValidationError if @run_output.validations.length == 0
+      raise NoValidationError if @run_output.validations.empty?
       vals.each do |v|
-        fail ReportClassError unless v.validation_report.is_a? ValidationReport
+        raise ReportClassError unless v.validation_report.is_a? ValidationReport
       end
     rescue NoValidationError => e
-      $stderr.puts e
+      warn e
       exit 1
     rescue ReportClassError => e
-      $stderr.puts e
+      warn e
       exit 1
     end
 
-    def compute_scores
+    def compute_run_score
       validations        = @run_output.validations
       scores             = {}
       scores[:successes] = validations.count { |v| v.result == v.expected }
-      scores[:fails] = validations.count { |v| v.validation != :unapplicable && v.validation != :error && v.result != v.expected }
-      scores         = length_validation_scores(validations, scores)
+      scores[:fails] = validations.count do |v|
+        v.validation != :unapplicable && v.validation != :error &&
+          v.result != v.expected
+      end
+      scores = length_validation_scores(validations, scores)
 
-      @run_output.successes     = scores[:successes]
-      @run_output.fails         = scores[:fails]
-      total_query               = scores[:successes].to_i + scores[:fails]
-      if total_query == 0
+      @run_output.successes = scores[:successes]
+      @run_output.fails     = scores[:fails]
+      num_total_validations = scores[:successes].to_i + scores[:fails]
+      if num_total_validations.zero?
         @run_output.overall_score = 0
       else
-        @run_output.overall_score = (scores[:successes] * 90 / total_query).round
+        @run_output.overall_score = (scores[:successes] * 90 / num_total_validations).round
       end
     end
 
@@ -260,49 +259,8 @@ module GeneValidator
     end
 
     def generate_run_output
-      @run_output.generate_html
-      @run_output.generate_json
       @run_output.print_output_console
-      generate_run_overview
-    end
-
-    def generate_run_overview
-      vals        = @run_output.validations
-      no_mafft    = 0
-      no_internet = 0
-      errors      = []
-      vals.each do |v|
-        unless v.errors.nil?
-          no_mafft += v.errors.count { |e| e == NoMafftInstallationError }
-          no_internet += v.errors.count { |e| e == NoInternetError }
-        end
-        errors.push(v.short_header) if v.validation == :error
-      end
-
-      no_evidence = vals.count { |v| v.result == :unapplicable || v.result == :warning } == vals.length
-      nee = (no_evidence) ? 1 : 0
-
-      good_scores = (@run_output.overall_score >= 75) ? 1 : 0
-      bad_scores  = (@run_output.overall_score >= 75) ? 0 : 1
-
-      @mutex_array.synchronize do
-        @overview[:no_queries] += 1
-        @overview[:scores].push(@run_output.overall_score)
-        @overview[:good_scores] += good_scores
-        @overview[:bad_scores] += bad_scores
-        @overview[:nee] += nee
-        @overview[:no_mafft] += no_mafft
-        @overview[:no_internet] += no_internet
-        errors.each { |err| @overview[:map_errors][err] += 1 }
-
-        vals.each do |v|
-          next if v.run_time == 0 || v.run_time.nil?
-          next if v.validation == :unapplicable || v.validation == :error
-          p = Pair1.new(@overview[:run_time][v.short_header].x + v.run_time,
-                        @overview[:run_time][v.short_header].y + 1)
-          @overview[:run_time][v.short_header] = p
-        end
-      end
+      @run_output.generate_json
     end
   end
 end

data/lib/genevalidator/validation_alignment.rb

@@ -17,9 +17,11 @@ module GeneValidator
     attr_reader :result
 
     def initialize(short_header, header, description, gaps = 0, extra_seq = 0,
-                    consensus = 1, threshold = 20, expected = :yes)
+                   consensus = 1, threshold = 20, expected = :yes)
 
-      @short_header, @header, @description = short_header, header, description
+      @short_header = short_header
+      @header = header
+      @description = description
       @gaps         = (gaps * 100).round.to_s + '%'
       @extra_seq    = (extra_seq * 100).round.to_s + '%'
       @consensus    = (consensus * 100).round.to_s + '%'
@@ -47,7 +49,9 @@ module GeneValidator
       else
         t = 'These results suggest that there may be some problems with' \
             ' the query sequence.'
-        t1, t2, t3 = '', '', '' # Create empty string variables
+        t1 = ''
+        t2 = ''
+        t3 = '' # Create empty string variables
         if (1 - consensus.to_i) > @threshold
           t1 = ' There is low conservation of residues between the' \
                ' statistical profile and the query sequence (the cut-off' \
@@ -114,7 +118,7 @@ module GeneValidator
       @raw_seq_file_load  = config[:raw_seq_file_load]
       @db                 = opt[:db]
       @multiple_alignment = []
-      @num_threads        = opt[:num_threads]
+      @num_threads        = opt[:mafft_threads]
       @type               = config[:type]
     end
 
@@ -123,32 +127,31 @@ module GeneValidator
     # of the first n hits
     # Output:
     # +AlignmentValidationOutput+ object
-    def run(n = 10)
+    def run
+      n = opt[:min_blast_hits] < 10 ? 10 : opt[:min_blast_hits]
       n = 50 if n > 50
 
-      fail NotEnoughHitsError unless hits.length >= n
-      fail unless prediction.is_a?(Query) && hits[0].is_a?(Query)
+      raise NotEnoughHitsError if hits.length < n
+      raise unless prediction.is_a?(Query) && hits[0].is_a?(Query)
 
       start = Time.new
       # get the first n hits
-      less_hits    = @hits[0..[n - 1, @hits.length].min]
-      useless_hits = []
-
+      n_hits = [n - 1, @hits.length].min
+      less_hits = @hits[0..n_hits]
       # get raw sequences for less_hits
-      less_hits.map do |hit|
-        next unless hit.raw_sequence.nil?
-        hit.raw_sequence = FetchRawSequences.run(hit.identifier,
-                                                 hit.accession_no)
-        useless_hits.push(hit) if hit.raw_sequence.nil?
+      less_hits.delete_if do |hit|
+        if hit.raw_sequence.nil?
+          hit.raw_sequence = FetchRawSequences.run(hit.identifier,
+                                                   hit.accession_no)
+        end
+        hit.raw_sequence.nil? ? true : false
       end
 
-      useless_hits.each { |hit| less_hits.delete(hit) }
-
-      fail NoInternetError if less_hits.length == 0
+      raise NoInternetError if less_hits.length.zero?
       # in case of nucleotide prediction sequence translate into protein
       # translate with the reading frame of all hits considered for alignment
       reading_frames = less_hits.map(&:reading_frame).uniq
-      fail ReadingFrameError if reading_frames.length != 1
+      raise ReadingFrameError if reading_frames.length != 1
 
       if @type == :nucleotide
         s = Bio::Sequence::NA.new(prediction.raw_sequence)
@@ -157,7 +160,7 @@ module GeneValidator
 
       # multiple align sequences from less_hits with the prediction
       # the prediction is the last sequence in the vector
-      multiple_align_mafft(prediction, less_hits)
+      @multiple_alignment = multiple_align_mafft(prediction, less_hits)
 
       out = get_sm_pssm(@multiple_alignment[0..@multiple_alignment.length - 2])
       sm = out[0]
@@ -182,7 +185,6 @@ module GeneValidator
       @validation_report.plot_files.push(plot1)
       @validation_report.run_time = Time.now - start
       @validation_report
-
     rescue NotEnoughHitsError
       @validation_report = ValidationReport.new('Not enough evidence',
                                                 :warning, @short_header,
@@ -202,7 +204,7 @@ module GeneValidator
                                                 :error, @short_header,
                                                 @header, @description)
       @validation_report.errors.push 'Multiple reading frames Error'
-    rescue
+    rescue StandardError
       @validation_report = ValidationReport.new('Unexpected error', :error,
                                                 @short_header, @header,
                                                 @description)
@@ -221,25 +223,25 @@ module GeneValidator
     # Output:
     # Array of +String+s, corresponding to the multiple aligned sequences
     # the prediction is the last sequence in the vector
-    def multiple_align_mafft(prediction = @prediction, hits = @hits)
-      fail unless prediction.is_a?(Query) && hits[0].is_a?(Query)
-
-      options = ['--maxiterate', '1000', '--localpair', '--anysymbol',
-                 '--quiet', '--thread', "#{@num_threads}"]
-      mafft = Bio::MAFFT.new('mafft', options)
-      sequences = hits.map(&:raw_sequence)
+    def multiple_align_mafft(prediction, hits)
+      raise unless prediction.is_a?(Query) && hits[0].is_a?(Query)
+
+      opt = ['--maxiterate', '1000', '--localpair', '--anysymbol', '--quiet',
+             '--thread', @num_threads.to_s]
+      mafft = Bio::MAFFT.new('mafft', opt)
+      sequences = hits.map do |h|
+        # remove the seq id - as MAFFT sometimes has an issue with this
+        f = Bio::FastaFormat.new(h.raw_sequence)
+        # check if fasta sequence otherwise returne original entry
+        f.seq.empty? ? h.raw_sequence : f.seq
+      end
       sequences.push(prediction.protein_translation)
 
       report = mafft.query_align(sequences)
-      # Accesses the actual alignment.
-      align = report.alignment
-
-      align.each_with_index do |s, _i|
-        @multiple_alignment.push(s.to_s)
-      end
-
-      @multiple_alignment
-    rescue
+      alignment = report.alignment.map(&:to_s)
+      raise NoMafftInstallationError if alignment.empty?
+      alignment
+    rescue StandardError
       raise NoMafftInstallationError
     end
 
@@ -252,7 +254,7 @@ module GeneValidator
     # +ma+: array of +String+s, corresponding to the multiple aligned sequences
     # Output:
     # +String+ with the consensus regions
-    def get_consensus(ma = @multiple_alignment)
+    def get_consensus(ma)
       align = Bio::Alignment.new(ma)
       align.consensus
     end
@@ -308,7 +310,7 @@ module GeneValidator
       # no of conserved residues among the hits
       no_conserved_residues = consensus.length - consensus.scan(/[\?-]/).length
 
-      return 1 if no_conserved_residues == 0
+      return 1 if no_conserved_residues.zero?
 
       # no of conserved residues from the hita that appear in the prediction
       no_conserved_pred = consensus.split(//).each_index.count { |j| consensus[j] != '-' && consensus[j] != '?' && consensus[j] == prediction_raw[j] }
@@ -327,7 +329,7 @@ module GeneValidator
     # +String+ representing the statistical model
     # +Array+ with the maximum frequeny of the majoritary residue for each
     # position
-    def get_sm_pssm(ma = @multiple_alignment, threshold = 0.7)
+    def get_sm_pssm(ma, threshold = 0.7)
       sm = ''
       freq = []
       (0..ma[0].length - 1).each do |i|
@@ -335,19 +337,10 @@ module GeneValidator
         ma.map { |seq| seq[i] }.each { |res| freqs[res] += 1 }
         # get the residue with the highest frequency
         max_freq = freqs.map { |_res, n| n }.max
-        residue = (freqs.map { |res, n| n == max_freq ? res : [] }.flatten)[0]
-
-        if residue == '-'
-          freq.push(0)
-        else
-          freq.push(max_freq / (ma.length + 0.0))
-        end
+        residue = freqs.map { |res, n| n == max_freq ? res : [] }.flatten[0]
 
-        if max_freq / (ma.length + 0.0) >= threshold
-          sm << residue
-        else
-          sm << '?'
-        end
+        freq << residue == '-' ? 0 : (max_freq / ma.length.to_f)
+        sm += (max_freq / ma.length.to_f) >= threshold ? residue : '?'
       end
       [sm, freq]
     end
@@ -364,16 +357,12 @@ module GeneValidator
       gap_starts = seq.to_enum(:scan, /(-\w{1,#{len}}-)/i).map { |_m| $`.size + 1 }
       # remove isolated residues
       gap_starts.each do |i|
-        (i..i + len - 1).each do |j|
-          seq[j] = '-' if isalpha(seq[j])
-        end
+        (i..i + len - 1).each { |j| seq[j] = '-' if isalpha(seq[j]) }
       end
       # remove isolated gaps
       res_starts = seq.to_enum(:scan, /([?\w]-{1,2}[?\w])/i).map { |_m| $`.size + 1 }
       res_starts.each do |i|
-        (i..i + len - 1).each do |j|
-          seq[j] = '?' if seq[j] == '-'
-        end
+        (i..i + len - 1).each { |j| seq[j] = '?' if seq[j] == '-' }
       end
       seq
     end
@@ -390,10 +379,11 @@ module GeneValidator
     def array_to_ranges(ar)
       prev = ar[0]
 
-      ranges = ar.slice_before { |e|
-        prev, prev2 = e, prev
+      ranges = ar.slice_before do |e|
+        prev2 = prev
+        prev = e
         prev2 + 1 != e
-      }.map { |a| a[0]..a[-1] }
+      end.map { |a| a[0]..a[-1] }
 
       ranges
     end
@@ -406,17 +396,16 @@ module GeneValidator
     # +ma+: +String+ array with the multiple alignmened hits and prediction
     def plot_alignment(freq, ma = @multiple_alignment)
       # get indeces of consensus in the multiple alignment
-      consensus = get_consensus(@multiple_alignment[0..@multiple_alignment.length - 2])
+      consensus = get_consensus(ma[0..ma.length - 2])
       consensus_idxs = consensus.split(//).each_index.select { |j| isalpha(consensus[j]) }
       consensus_ranges = array_to_ranges(consensus_idxs)
 
-      consensus_all = get_consensus(@multiple_alignment)
+      consensus_all = get_consensus(ma)
       consensus_all_idxs = consensus_all.split(//).each_index.select { |j| isalpha(consensus_all[j]) }
       consensus_all_ranges = array_to_ranges(consensus_all_idxs)
 
       match_alignment = ma[0..ma.length - 2].each_with_index.map { |seq, _j| seq.split(//).each_index.select { |j| isalpha(seq[j]) } }
-      match_alignment_ranges = []
-      match_alignment.each { |arr| match_alignment_ranges << array_to_ranges(arr) }
+      match_alignment_ranges = match_alignment.map { |e| array_to_ranges(e) }
 
       query_alignment = ma[ma.length - 1].split(//).each_index.select { |j| isalpha(ma[ma.length - 1][j]) }
       query_alignment_ranges = array_to_ranges(query_alignment)
@@ -425,15 +414,15 @@ module GeneValidator
 
       # plot statistical model
       data = freq.each_with_index.map { |h, j| { 'y' => ma.length, 'start' => j, 'stop' => j + 1, 'color' => 'orange', 'height' => h } } +
-      # hits
-      match_alignment_ranges.each_with_index.map { |ranges, j| ranges.map { |range| { 'y' => ma.length - j - 1, 'start' => range.first, 'stop' => range.last, 'color' => 'red', 'height' => -1 } } }.flatten +
-      ma[0..ma.length - 2].each_with_index.map { |_seq, j| consensus_ranges.map { |range| { 'y' => j + 1, 'start' => range.first, 'stop' => range.last, 'color' => 'yellow', 'height' => -1 } } }.flatten +
-      # plot prediction
-      [{ 'y' => 0, 'start' => 0, 'stop' => len, 'color' => 'gray', 'height' => -1 }] +
-      query_alignment_ranges.map { |range| { 'y' => 0, 'start' => range.first, 'stop' => range.last, 'color' => 'red', 'height' => -1 } }.flatten +
-
-      # plot consensus
-      consensus_all_ranges.map { |range| { 'y' => 0, 'start' => range.first, 'stop' => range.last, 'color' => 'yellow', 'height' => -1 } }.flatten
+             # hits
+             match_alignment_ranges.each_with_index.map { |ranges, j| ranges.map { |range| { 'y' => ma.length - j - 1, 'start' => range.first, 'stop' => range.last, 'color' => 'red', 'height' => -1 } } }.flatten +
+             ma[0..ma.length - 2].each_with_index.map { |_seq, j| consensus_ranges.map { |range| { 'y' => j + 1, 'start' => range.first, 'stop' => range.last, 'color' => 'yellow', 'height' => -1 } } }.flatten +
+             # plot prediction
+             [{ 'y' => 0, 'start' => 0, 'stop' => len, 'color' => 'gray', 'height' => -1 }] +
+             query_alignment_ranges.map { |range| { 'y' => 0, 'start' => range.first, 'stop' => range.last, 'color' => 'red', 'height' => -1 } }.flatten +
+
+             # plot consensus
+             consensus_all_ranges.map { |range| { 'y' => 0, 'start' => range.first, 'stop' => range.last, 'color' => 'yellow', 'height' => -1 } }.flatten
 
       y_axis_values = 'Prediction'
       (1..ma.length - 1).each { |i| y_axis_values << ", hit #{i}" }