viral_seq 1.7.1 → 1.8.0

data/lib/viral_seq/recency_report.rb

@@ -0,0 +1,193 @@
+module ViralSeq
+
+  # class to generate recency report
+
+  class RecencyReport
+
+    # to generate the recency report in .pdf format.
+    # @param log [Hash] Hash from the json summary string of the SDRM report
+    # @param outfile [String] path to the output file
+    # @return [NilClass] .pdf file generated by the method. Return nil.
+
+    def self.generate(log, outfile)
+
+      recency_color = {
+        "recent" => "d42828",
+        "chronic" => "0666bf",
+        "indeterminant"=> "f78914",
+        "insufficient data" => "7d7b79"
+      }
+
+      dual_infection_color = {
+        "Yes" => "ffcc00",
+        "No" => "339900",
+        "insufficient data" => "7d7b79"
+      }
+
+      Prawn::Document.generate(outfile, margin: 75) do
+
+        def text_format(text1, text2)
+          [
+            { text: text1 + "\s" * (30 - text1.size), styles: [:bold], size: 14, font: "Courier"},
+            { text: text2, size: 14, styles: [:underline]}
+          ]
+        end
+
+        def text_format2(text1, text2, text3, text4)
+            text1 = text1.to_s
+            text2 = text2.to_s
+            text3 = text3.to_s
+            text4 = text4.to_s
+
+            [
+              { text: "\s\s\s" + text1 + "\s"*(11-text1.size) +
+            text2 + "\s"*(19-text2.size) +
+            text3 + "\s"*(11-text3.size) + text4,
+              size: 14,
+              font: "Courier"
+              }
+            ]
+        end
+
+        text("Quantitative Recency Report by MPID-NGS",
+        size: 18,
+        align: :center,
+        style: :bold
+        )
+
+        move_down 20
+
+        formatted_text(
+          text_format("Library ID:", log[:sample_id])
+        )
+
+        move_down 10
+
+        formatted_text(
+          text_format("ViralSeq Version:", ViralSeq::VERSION.to_s)
+
+        )
+
+        formatted_text(
+          text_format("TCS Version:", ViralSeq::TCS_VERSION.to_s)
+        )
+
+        formatted_text(
+          text_format("Processed Date", Time.now.strftime("%Y-%b-%d %H:%M"))
+        )
+
+        move_down 30
+
+        text("Summary of parameters",
+        size: 16,
+        style: :bold
+        )
+
+        move_down 20
+
+        formatted_text(
+          [
+            { text: "REGION" + "\s"*5 + "AVG. DIVERSITY" + "\s"*5 + "DIST20" + "\s"*5 + "DEPTH",
+              styles: [:bold],
+              size: 14,
+              font: "Courier"
+            },
+          ]
+        )
+
+        move_down 5
+
+        formatted_text(
+          text_format2("RT", log[:pi_RT], log[:dist20_RT], log[:tcs_RT])
+        )
+
+        formatted_text(
+          text_format2("V1V3", log[:pi_V1V3], log[:dist20_V1V3], log[:tcs_V1V3])
+        )
+
+        formatted_text(
+          text_format2("P17", log[:pi_P17], log[:dist20_P17], log[:tcs_P17])
+        )
+
+        move_down 30
+
+        formatted_text(
+          [
+            { text: "Prediction: ",
+              styles: [:bold],
+              size: 16,
+            },
+
+            { text: log[:recency].capitalize + " Infection",
+              styles: [:bold],
+              size: 16,
+              color: recency_color[log[:recency]]
+            },
+
+            { text: " (9-month cutoff)",
+              size: 14,
+            },
+          ]
+        )
+
+        move_down 20
+
+        formatted_text(
+          [
+            {
+              text: "Estimated Day Post Infection: ",
+              styles: [:bold],
+              size: 16
+            },
+
+            {
+              text: log[:dpi].round(1).to_s +
+              " (" + log[:dpi_lwr].round(1).to_s + "-" + log[:dpi_upr].round(1).to_s + ") Days",
+              styles: [:bold],
+              size: 16,
+              color: recency_color[log[:recency]]
+            }
+          ]
+        )
+
+        move_down 20
+
+        formatted_text(
+          [
+            {
+              text: "Possible multivariant Infection: ",
+              styles: [:bold],
+              size: 16,
+            },
+
+            {
+              text: log[:possible_dual_infection],
+              styles: [:bold],
+              size: 16,
+              color: dual_infection_color[log[:possible_dual_infection]]
+            }
+          ]
+        )
+
+        move_down 10
+
+        if log[:possible_dual_infection] == "Yes"
+
+          formatted_text(
+            [
+              {
+                text: "Warning: Days Post Infection prediction not reliable!",
+                styles: [:bold],
+                size: 14,
+                color: "ffcc00"
+              }
+            ]
+          )
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/viral_seq/root.rb

@@ -0,0 +1,7 @@
+module ViralSeq
+  # define the path to the root of the gem files.
+  # @return [String] string for the root path to the gem files.
+  def self.root
+    File.dirname __dir__
+  end
+end

data/lib/viral_seq/seq_hash.rb

@@ -495,7 +495,7 @@ module ViralSeq
       # total G->A mutations at apobec3g/f positions.
       total = 0
 
-      unless ref 
+      unless ref
         # make consensus sequence for the input sequence hash
         ref = self.consensus
       end
@@ -571,7 +571,7 @@ module ViralSeq
       hm_hash.each do |k,_v|
         hm_seq_hash.dna_hash[k] = self.dna_hash[k]
       end
-    
+
       hm_seq_hash.title = self.title + "_hypermut"
       hm_seq_hash.file = self.file
       filtered_seq_hash = self.sub(self.dna_hash.keys - hm_hash.keys)
@@ -713,7 +713,7 @@ module ViralSeq
 
 
     # align the @dna_hash sequences, return a new ViralSeq::SeqHash object with aligned @dna_hash using MUSCLE
-    # @param algorithm [Symbol], algorithm for MUSCLE5 only. Choose from :PPP or :Super5. 
+    # @param algorithm [Symbol], algorithm for MUSCLE5 only. Choose from :PPP or :Super5.
     # @param path_to_muscle [String], path to MUSCLE excutable. if not provided (as default), it will use RubyGem::MuscleBio
     # @return [SeqHash] new SeqHash object of the aligned @dna_hash, the title has "_aligned"
 
@@ -729,7 +729,7 @@ module ViralSeq
       temp_aln = File.join(temp_dir, "_temp_muscle_aln")
       File.open(temp_file, 'w'){|f| seq_hash.each {|k,v| f.puts k; f.puts v}}
       if path_to_muscle
-        unless ViralSeq.check_muscle?(path_to_muscle)
+        unless ViralSeq::Muscle.check_muscle?(path_to_muscle)
           File.unlink(temp_file)
           return nil
         end

data/lib/viral_seq/seq_hash_pair.rb

@@ -87,7 +87,8 @@ module ViralSeq
     end
 
     # Pair-end join function for KNOWN overlap size.
-    # @param overlap [Integer] how many bases are overlapped. `0` means no overlap, R1 and R2 will be simply put together.
+    # @param overlap [Integer] simple overlap value indicating how many bases are overlapped. `0` means no overlap, R1 and R2 will be simply put together.
+    # overlap can also be an explicit [Hash] object for :overlap_size, :r1_overlap, :r2_overlap, :before_overlap, :after_overlap
     # @param diff [Integer, Float] the maximum mismatch rate allowed for the overlapping region. default at 0.0, i.e. no mis-match allowed.
     # @return [ViralSeq::SeqHash] a SeqHash object of joined sequences.
     # @example join paired-end sequences with different :diff cut-offs, overlap provided.
@@ -106,24 +107,64 @@ module ViralSeq
     #   => [">pair1", ">pair2", ">pair3"]
 
     def join1(overlap = 0, diff = 0.0)
-      seq_pair_hash = self.dna_hash
-      raise ArgumentError.new(":overlap has to be Integer, input #{overlap} invalid.") unless overlap.is_a? Integer
       raise ArgumentError.new(":diff has to be float or integer, input #{diff} invalid.") unless (diff.is_a? Integer or diff.is_a? Float)
+
+      if overlap.is_a? Integer and overlap.zero?
+        overlap = {
+          overlap_size: 0,
+          r1_overlapped: 0...0,
+          r2_overlapped: 0...0,
+          before_overlap: {
+            region: :r1,
+            range: 0..-1,
+          } ,
+          after_overlap: {
+            region: :r2,
+            range: 0..-1
+          }
+        }
+      elsif overlap.is_a? Integer
+        overlap = {
+          overlap_size: overlap,
+          r1_overlapped: -overlap..-1,
+          r2_overlapped: 0..(overlap - 1),
+          before_overlap: {
+            region: :r1,
+            range: 0..(-overlap - 1),
+          } ,
+          after_overlap: {
+            region: :r2,
+            range: overlap..-1
+          }
+        }
+      end
+
+      seq_pair_hash = self.dna_hash
       joined_seq = {}
       seq_pair_hash.each do |seq_name,seq_pair|
         r1_seq = seq_pair[0]
         r2_seq = seq_pair[1]
-        if overlap.zero?
-          joined_sequence = r1_seq + r2_seq
-        elsif diff.zero?
-          if r1_seq[-overlap..-1] == r2_seq[0,overlap]
-            joined_sequence= r1_seq + r2_seq[overlap..-1]
+
+        r1_overlap = r1_seq[overlap[:r1_overlapped]]
+        r2_overlap = r2_seq[overlap[:r2_overlapped]]
+
+        overlap_size = overlap[:overlap_size]
+
+        if (diff.zero? and r1_overlap == r2_overlap) or (!diff.zero? and r1_overlap.compare_with(r2_overlap) <= (overlap_size.abs * diff))
+          if overlap[:before_overlap][:region] == :r1
+            before_overlap_seq = r1_seq[overlap[:before_overlap][:range]]
+          elsif overlap[:before_overlap][:region] == :r2
+            before_overlap_seq = r2_seq[overlap[:before_overlap][:range]]
           end
-        elsif r1_seq[-overlap..-1].compare_with(r2_seq[0,overlap]) <= (overlap * diff)
-          joined_sequence= r1_seq + r2_seq[overlap..-1]
-        else
-          next
+
+          if overlap[:after_overlap][:region] == :r1
+            after_overlap_seq = r1_seq[overlap[:after_overlap][:range]]
+          elsif overlap[:after_overlap][:region] == :r2
+            after_overlap_seq = r2_seq[overlap[:after_overlap][:range]]
+          end
+          joined_sequence = before_overlap_seq + r1_overlap + after_overlap_seq
         end
+
         joined_seq[seq_name] = joined_sequence if joined_sequence
       end
 
@@ -164,18 +205,35 @@ module ViralSeq
         elsif model == :indiv
           joined_seq = {}
           seq_pair_hash.each do |seq_name, seq_pair|
+            r1_seq = seq_pair[0]
+            r2_seq = seq_pair[1]
             overlap_list = []
-            overlap_matrix(seq_pair[0], seq_pair[1]).each do |overlap1, diff_nt|
-              cut_off_base = overlap1 * diff
+
+            overlap_matrix(r1_seq, r2_seq).each do |overlap1, diff_nt|
+              cut_off_base = overlap1[:overlap_size] * diff
               overlap_list << overlap1 if diff_nt <= cut_off_base
             end
+
             if overlap_list.empty?
-              joined_seq[seq_name] = seq_pair[0] + seq_pair[1]
+              joined_seq[seq_name]  = seq_pair[0] + seq_pair[1]
             else
-              overlap = overlap_list.max
-              joined_seq[seq_name] = seq_pair[0] + seq_pair[1][overlap..-1]
+              overlap_to_use = overlap_list.sort_by{|k| k[:overlap_size].abs}.reverse[0]
+
+              if overlap_to_use[:before_overlap][:region] == :r1
+                before_overlap_seq = r1_seq[overlap_to_use[:before_overlap][:range]]
+              elsif overlap_to_use[:before_overlap][:region] == :r2
+                before_overlap_seq = r2_seq[overlap_to_use[:before_overlap][:range]]
+              end
+
+              if overlap_to_use[:after_overlap][:region] == :r1
+                after_overlap_seq = r1_seq[overlap_to_use[:after_overlap][:range]]
+              elsif overlap_to_use[:after_overlap][:region] == :r2
+                after_overlap_seq = r2_seq[overlap_to_use[:after_overlap][:range]]
+              end
+              joined_seq[seq_name] = before_overlap_seq + r1_seq[overlap_to_use[:r1_overlapped]] + after_overlap_seq
             end
           end
+
           joined_seq_hash = ViralSeq::SeqHash.new
           joined_seq_hash.dna_hash = joined_seq
           joined_seq_hash.title = self.title + "_joined"
@@ -197,35 +255,104 @@ module ViralSeq
       seq_pair_hash.each do |_seq_name, seq_pair|
         overlap_list = []
         matrix = overlap_matrix(seq_pair[0], seq_pair[1])
-        matrix.each do |overlap, diff_nt|
+        matrix.each do |overlap_positions, diff_nt|
+          overlap = overlap_positions[:overlap_size].abs
           cut_off_base = overlap * diff
-          overlap_list << overlap if diff_nt <= cut_off_base
+          overlap_list << overlap_positions if diff_nt <= cut_off_base
         end
+
         if overlap_list.empty?
-          overlaps << 0
+          overlaps <<    {
+            overlap_size: 0,
+            r1_overlapped: 0...0,
+            r2_overlapped: 0...0,
+            before_overlap: {
+              region: :r1,
+              range: 0..-1,
+            } ,
+            after_overlap: {
+              region: :r2,
+              range: 0..-1
+            }
+          }
         else
-          overlaps << overlap_list.max
+          overlaps << overlap_list.sort_by{|k| k[:overlap_size].abs}.reverse[0]
         end
+
       end
       count_overlaps = overlaps.count_freq
       max_value = count_overlaps.values.max
       max_overlap_list = []
       count_overlaps.each {|overlap, counts| max_overlap_list << overlap if counts == max_value}
-      max_overlap_list.max
+      max_overlap_list.sort_by{|k| k[:overlap_size].abs}.reverse[0]
     end # end pf determine_overlap_pid_pair
 
     # input a pair of sequences as String, return a Hash object of overlapping Hash object
     # {:overlap_size => number_of_differnt_positions, ...}
     # {minimal overlap set to 4. }
     def overlap_matrix(sequence1, sequence2)
-      min_overlap = 4
-      max_overlap = [sequence1.size, sequence2.size].min
+      list = overlap_list(sequence1.size, sequence2.size)
       matrix_hash = {}
+      list.each do |l|
+        range1 = l[:r1_overlapped]
+        range2 = l[:r2_overlapped]
+        matrix_hash[l] = sequence1[range1].compare_with(sequence2[range2])
+      end
+      matrix_hash
+    end
+
+    # given two [Integer], return all possible overlaping ranges in an [Array]
+    def overlap_list(l1, l2)
+      return_list = []
+      min_overlap = 4
+      max_overlap = [l1, l2].min
+      diff = (l1 - l2).abs
+      max_reverse = l1/2
+
       (min_overlap..max_overlap).each do |overlap|
-        matrix_hash[overlap] = sequence1[-overlap..-1].compare_with(sequence2[0, overlap])
+        return_list<< {
+          overlap_size: overlap,
+          r1_overlapped: (l1-overlap)..(l1-1),
+          r2_overlapped: 0..(overlap -1),
+          before_overlap: {region: :r1, range: 0..(l1 - overlap - 1)},
+          after_overlap: {region: :r2, range: overlap..(l2-1)}
+        }
+      end
+
+      if l1 >= l2
+        (1..diff).each do |overlap|
+          return_list << {
+            overlap_size: max_overlap,
+            r1_overlapped: (diff - overlap)..(l1-1-overlap),
+            r2_overlapped: 0..(l2-1),
+            before_overlap: {region: :r1, range: 0...(diff - overlap)},
+            after_overlap: {region: :r1, range: (l1-overlap)...l1},
+        }
+        end
+      else
+        (1..diff).each do |overlap|
+          return_list << {
+            overlap_size: max_overlap,
+            r1_overlapped: 0..(l1-1),
+            r2_overlapped: overlap..(max_overlap + overlap - 1),
+            before_overlap: {region: :r2, range: 0...overlap},
+            after_overlap: {region: :r2, range: (max_overlap + overlap)...l2},
+        }
+        end
+      end
+
+      (max_reverse..(max_overlap-1)).reverse_each do |overlap|
+        return_list << {
+          overlap_size: overlap,
+          r1_overlapped: 0..(overlap -1),
+          r2_overlapped: (l2-overlap)..(l2-1),
+          before_overlap: {region: :r2, range: 0..(l2-overlap-1)},
+          after_overlap: {region: :r1, range: overlap..(l1-1)},
+        }
       end
-      return matrix_hash
-    end # end of overlap_matrix
+
+      return_list
+    end # end of overlap_list
 
   end # end of SeqHashPair
 end # end of ViralSeq