cheripic 1.0.0 → 1.1.0

data/lib/cheripic/implementer.rb

@@ -2,14 +2,24 @@
 
 module Cheripic
 
+  # Custom error handling for Implementer class
   class ImplementerError < CheripicError; end
 
+  # An Implementer object for running pipeline from Cmd object options
+  #
+  # @!attribute [r] options
+  #   @return [Hash] a hash of required input files names as keys and
+  #   user provided file paths as values taken from Cmd object
+  # @!attribute [r] variants
+  #   @return [<Cheripic::Variants>] a Variants object initialized using options from Cmd object
   class Implementer
 
     require 'ostruct'
     require 'fileutils'
-    attr_accessor :options, :variants
+    attr_reader :options, :variants, :has_run
 
+    # Initializes an Implementer object using inputs from cmd object
+    # @param inputs [Hash] a hash of trollop option names as keys and user or default setting as values from Cmd object
     def initialize(inputs)
       set1 = %i{assembly
                 input_format
@@ -38,13 +48,20 @@ module Cheripic
       settings = inputs.select { |k| set2.include?(k) }
       Options.update(settings)
       FileUtils.mkdir_p @options.output
+      @vars_extracted = false
+      @has_run = false
     end
 
+    # Initializes a Variants object using using input options (files).
+    # Each pileup file is processed and bulks are compared
     def extract_vars
       @variants = Variants.new(@options)
       @variants.compare_pileups
+      @vars_extracted = true
     end
 
+    # Extracted variants from bulk comparison are re-analysed
+    # and selected variants are written to a file
     def process_variants
       @variants.verify_bg_bulk_pileup
       # print selected variants that could be potential markers or mutation
@@ -63,16 +80,20 @@ module Cheripic
       out_file.close
     end
 
+    # Wrapper to extract and isolate selected variants
+    # implements extract_vars and process_variants and
+    # if data is from polyploids extracts contigs with high bfr
     def run
-      unless defined?(@variants.has_run)
+      unless @vars_extracted
         self.extract_vars
       end
-      if Options.params.polyploidy
+      if Options.polyploidy
         self.process_variants
         @variants.bfr_frags
       else
         self.process_variants
       end
+      @has_run = true
     end
 
   end

data/lib/cheripic/options.rb

@@ -2,12 +2,12 @@
 
 module Cheripic
 
+  # A class to get default settings and update user settings for parameters
+  # and facilitate retrieval of settings any where in the module
   class Options
 
-    require 'ostruct'
-    # class << self; attr_accessor :params end
-
-    @defaults = {
+    # Default parameter settings
+    @def_settings = {
         :hmes_adjust => 0.5,
         :htlow => 0.2,
         :hthigh => 0.9,
@@ -25,16 +25,116 @@ module Cheripic
         :bfr_adjust => 0.05,
         :sel_seq_len => 50
     }
-    # @params = OpenStruct.new(@defaults)
 
+    # set defaults as user settings
+    @user_settings = @def_settings
+
+    # A value to adjust calculation of Homozygosity Enrichment Score (HMES)
+    # @return [Float]
+    def self.hmes_adjust
+      @user_settings[:hmes_adjust]
+    end
+
+    # Lower cut off of Allele fraction for categorization of an variant to heterozygous
+    # @return [Float]
+    def self.htlow
+      @user_settings[:htlow]
+    end
+
+    # Higher cut off of Allele fraction for categorization of an variant to heterozygous
+    # @return [Float]
+    def self.hthigh
+      @user_settings[:hthigh]
+    end
+
+    # Minimum read coverage at the variant position to be considered for analysis
+    # @return [Integer]
+    def self.mindepth
+      @user_settings[:mindepth]
+    end
+
+    # Minimum non reference count at the variant position to be considered for analysis
+    # @return [Integer]
+    def self.min_non_ref_count
+      @user_settings[:min_non_ref_count]
+    end
+
+    # Minimum reads supporting an indel at the variant position to be considered for analysis as indel
+    # @return [Integer]
+    def self.min_indel_count_support
+      @user_settings[:min_indel_count_support]
+    end
+
+    # Option to whether to ignore or consider the reference positions which are ambiguous
+    # @return [Boolean]
+    def self.ignore_reference_n
+      @user_settings[:ignore_reference_n]
+    end
+
+    # Minimum alignment mapping quality of the read to be used for bam files
+    # @return [Integer]
+    def self.mapping_quality
+      @user_settings[:mapping_quality]
+    end
+
+    # Minimum aligned base quality at the variant position to be considered for analysis
+    # @return [Integer]
+    def self.base_quality
+      @user_settings[:base_quality]
+    end
+
+    # Threshold for fraction of read bases at variant position below which are ignored as noise
+    # @return [Float]
+    def self.noise
+      @user_settings[:noise]
+    end
+
+    # Option for cross type used for generating bulk population
+    # @note options are either 'back' or 'out'
+    # @return [String]
+    def self.cross_type
+      @user_settings[:cross_type]
+    end
+
+    # Option to whether to ignore or consider the contigs with out any variants
+    # @return [Boolean]
+    def self.only_frag_with_vars
+      @user_settings[:only_frag_with_vars]
+    end
+
+    # Option to whether to ignore or consider the contigs with low HME score
+    # @return [Boolean]
+    def self.filter_out_low_hmes
+      @user_settings[:filter_out_low_hmes]
+    end
+
+    # Option to whether to set the input data is from polyploid or not
+    # @return [Boolean]
+    def self.polyploidy
+      @user_settings[:polyploidy]
+    end
+
+    # A value to adjust calculation of bulk frequency ratio (bfr)
+    # @return [Float]
+    def self.bfr_adjust
+      @user_settings[:bfr_adjust]
+    end
+
+    # Number of nucleotides of sequence to select from each side of the selected variant
+    # @return [Integer]
+    def self.sel_seq_len
+      @user_settings[:sel_seq_len]
+    end
+
+    # Updates the values of options using a hash generated from user inputs
+    # @param newset [Hash] a hash of option names as keys user settings as values
     def self.update(newset)
-      @defaults.merge!(newset)
-      self.params
-      # @params = OpenStruct.new(@defaults)
+      @user_settings = @def_settings.merge(newset)
     end
 
-    def self.params
-      OpenStruct.new(@defaults)
+    # Resets the values of options to defaults
+    def self.defaults
+      @user_settings = @def_settings
     end
 
   end

data/lib/cheripic/pileup.rb

@@ -1,186 +1,177 @@
 # encoding: utf-8
-require 'bio'
-require 'bio-samtools'
-require 'bio/db/pileup'
+module Cheripic
 
-class Pileup < Bio::DB::Pileup
+  # Custom error handling for Pileup class
+  class PileupError < CheripicError; end
 
-  attr_accessor :defaults
+  require 'bio-samtools'
+  require 'bio/db/pileup'
 
-  def initialize(string, opts={})
-    super(string)
-    set_defaults(opts)
-    adj_read_bases
-    @indelbases = 'acgtryswkmbdhvnACGTRYSWKMBDHVN'
-  end
-
-  def set_defaults(opts)
-    @defaults = {
-      noise: 0.1,                  # noise level for read depth
-      ht_low: 0.2,                 # min allele freq for heterozygosity
-      ht_high: 0.9,                # max allele freq for heterozygosity
-      min_depth: 6,                # minimum coverage for variant
-      min_non_ref_count: 3,
-      ignore_reference_n: true,
-      min_indel_count_support: 3,
-    }
-    @defaults.merge(opts)
-  end
-
-  # removes mapping quality information
-  def adj_read_bases
-    # mapping quality after '^' symbol is substituted
-    # to avoid splitting at non indel + or - characters
-    # read ends marking by '$' symbol is substituted
-    # insertion and deletion marking by '*' symbol is substituted
-    self.read_bases.gsub!(/\^./, '')
-    self.read_bases.delete! '$'
-    self.read_bases.delete! '*'
-    # warn about reads with ambiguous codes
-    # if self.read_bases.match(/[^atgcATGC,\.\+\-0-9]/)
-    #   warn "Ambiguous nucleotide\t#{self.read_bases}"
-    # end
-  end
+  # An extension of Bio::DB::Pileup object to process pileup information at a given position
+  class Pileup < Bio::DB::Pileup
 
-  # count bases matching reference and non-reference
-  # from snp variant and make a hash of bases with counts
-  # for indels return the read bases information instead
-  def bases_hash
-    if self.read_bases =~ /\+/
-      bases_hash = indels_to_hash('+')
-    elsif self.read_bases =~ /\-/
-      bases_hash = indels_to_hash('-')
-    else
-      bases_hash = snp_base_hash(self.read_bases)
+    # creates a Pileup object using a pileup information as string
+    # @param string [String] pileup information line for a given position
+    def initialize(string)
+      super(string)
+      adj_read_bases
+      @indelbases = 'acgtryswkmbdhvnACGTRYSWKMBDHVN'
     end
-    # some indels will have ref base in the read and using
-    # sum of hash values is going to give wrong additional coverage
-    # from indels so including actual coverage from pileup
-    # bases_hash keys are :A, :C, :G, :T, :N, :ref, :indel and :cov
-    bases_hash[:cov] = self.coverage
-    bases_hash
-  end
 
-  # count bases from indels
-  # array of pileup bases is split at + / -
-  # and number after each + / - is counted
-  def count_indel_bases(delimiter)
-    array = self.read_bases.split(delimiter)
-    number = 0
-    array.shift
-    array.each do |element|
-      # deletions in reference could contain ambiguous codes,
-      number += /^(\d+)[#{@indelbases}]/.match(element)[1].to_i
+    # removes mapping quality information
+    def adj_read_bases
+      # mapping quality after '^' symbol is substituted
+      # to avoid splitting at non indel + or - characters
+      # read ends marking by '$' symbol is substituted
+      # insertion and deletion marking by '*' symbol is substituted
+      self.read_bases.gsub!(/\^./, '')
+      self.read_bases.delete! '$'
+      self.read_bases.delete! '*'
+      # warn about reads with ambiguous codes
+      # if self.read_bases.match(/[^atgcATGC,\.\+\-0-9]/)
+      #   warn "Ambiguous nucleotide\t#{self.read_bases}"
+      # end
     end
-    number
-  end
 
-  # count bases matching reference and non-reference
-  # and calculate ratio of non_ref allele to total bases
-  def non_ref_count
-    read_bases = self.read_bases
-    if read_bases =~ /\+/
-      non_ref_count = indel_non_ref_count('+')
-    elsif read_bases =~ /\-/
-      non_ref_count = indel_non_ref_count('-')
-    else
-      non_ref_count = read_bases.count('atgcATGC')
+    # count bases matching reference and non-reference
+    # from snp variant and make a hash of bases with counts
+    # for indels return the read bases information instead
+    def bases_hash
+      if self.read_bases =~ /\+/
+        bases_hash = indels_to_hash('+')
+      elsif self.read_bases =~ /-/
+        bases_hash = indels_to_hash('-')
+      else
+        bases_hash = snp_base_hash(self.read_bases)
+      end
+      # some indels will have ref base in the read and using
+      # sum of hash values is going to give wrong additional coverage
+      # from indels so including actual coverage from pileup
+      # bases_hash keys are :A, :C, :G, :T, :N, :ref and :indel
+      bases_hash
     end
-    non_ref_count
-  end
 
-  # check if the pileup has the parameters we are looking for
-  def is_var
-    ignore_reference_n = @defaults[:ignore_reference_n]
-    min_depth  = @defaults[:min_depth]
-    min_non_ref_count = @defaults[:min_non_ref_count]
+    # count bases from indels
+    # array of pileup bases is split at + / -
+    # and number after each + / - is counted
+    def count_indel_bases(delimiter)
+      array = self.read_bases.split(delimiter)
+      number = 0
+      array.shift
+      array.each do |element|
+        # deletions in reference could contain ambiguous codes,
+        number += /^(\d+)[#{@indelbases}]/.match(element)[1].to_i
+      end
+      number
+    end
 
-    return false if self.ref_base == '*'
-    return false if ignore_reference_n and self.ref_base =~ /^[nN]$/
-    return true if self.coverage >= min_depth and self.non_ref_count >= min_non_ref_count
-    false
-  end
+    # count bases matching reference and non-reference
+    # and calculate ratio of non_ref allele to total bases
+    def non_ref_count
+      read_bases = self.read_bases
+      if read_bases =~ /\+/
+        non_ref_count = indel_non_ref_count('+')
+      elsif read_bases =~ /-/
+        non_ref_count = indel_non_ref_count('-')
+      else
+        non_ref_count = read_bases.count('atgcATGC')
+      end
+      non_ref_count
+    end
 
-  # count bases matching reference and non-reference
-  # and calculate ratio of non_ref allele to total bases
-  def non_ref_ratio
-    self.non_ref_count.to_f / self.coverage.to_f
-  end
+    # check if the pileup has the parameters we are looking for
+    def is_var
+      ignore_reference_n = Options.ignore_reference_n
+      min_depth  = Options.mindepth
+      min_non_ref_count = Options.min_non_ref_count
 
-  # calculate var zygosity for non-polyploid variants
-  # increased range is used for heterozygosity for RNA-seq data
-  def var_mode
-    ht_low = @defaults[:ht_low]
-    ht_high = @defaults[:ht_high]
-    mode = ''
-    if self.non_ref_ratio.between?(ht_low, ht_high)
-      mode = :het
-    elsif self.non_ref_ratio > ht_high
-      mode = :hom
+      return false if self.ref_base == '*'
+      return false if ignore_reference_n and self.ref_base =~ /^[nN]$/
+      return true if self.coverage >= min_depth and self.non_ref_count >= min_non_ref_count
+      false
     end
-    mode
-  end
 
-  # form hash of base information, [ATGC] counts for snp
-  # a hash of base proportion is calculated
-  # base proportion hash below a selected depth is empty
-  # base proportion below or equal to a noise factor are discarded
-  def var_base_frac
-    hash = self.bases_hash
-    snp_hash = {}
-    coverage = hash[:cov]
-    return snp_hash if coverage < @defaults[:min_depth]
-    # calculate proportion of each base in coverage
-    hash.each_key do | base |
-      next if base == :cov
-      freq = hash[base].to_f/coverage.to_f
-      next if freq <= @defaults[:noise]
-      snp_hash[base] = freq
+    # count bases matching reference and non-reference
+    # and calculate ratio of non_ref allele to total bases
+    def non_ref_ratio
+      self.non_ref_count.to_f / self.coverage.to_f
     end
-    snp_hash
-  end
 
+    # calculate var zygosity for non-polyploid variants
+    # increased range is used for heterozygosity for RNA-seq data
+    # def var_mode
+    #   ht_low = @defaults[:ht_low]
+    #   ht_high = @defaults[:ht_high]
+    #   mode = ''
+    #   if self.non_ref_ratio.between?(ht_low, ht_high)
+    #     mode = :het
+    #   elsif self.non_ref_ratio > ht_high
+    #     mode = :hom
+    #   end
+    #   mode
+    # end
 
-  private
+    # form hash of base information, [ATGC] counts for snp
+    # a hash of base proportion is calculated
+    # base proportion hash below a selected depth is empty
+    # base proportion below or equal to a noise factor are discarded
+    def var_base_frac
+      hash = self.bases_hash
+      snp_hash = {}
+      coverage = self.coverage
+      return snp_hash if coverage < Options.mindepth
+      # calculate proportion of each base in coverage
+      hash.each_key do | base |
+        freq = hash[base].to_f/coverage.to_f
+        next if freq <= Options.noise
+        snp_hash[base] = freq
+      end
+      snp_hash
+    end
 
-  # count number of indels and number non-indel base
-  # and return a hash with bases and indel counts
-  def indels_to_hash(delimiter)
-    non_indel_bases = String.new
-    array = self.read_bases.split(delimiter)
-    non_indel_bases << array.shift
-    array.each do |element|
-      # get number of nucleotides inserted or deleted
-      number = /^(\d+)[#{@indelbases}]/.match(element)[1].to_i
-      # capture remaining nucleotides
-      non_indel_bases << element.gsub(/^#{number}\w{#{number}}/, '')
+
+    private
+
+    # count number of indels and number non-indel base
+    # and return a hash with bases and indel counts
+    def indels_to_hash(delimiter)
+      non_indel_bases = String.new
+      array = self.read_bases.split(delimiter)
+      non_indel_bases << array.shift
+      array.each do |element|
+        # get number of nucleotides inserted or deleted
+        number = /^(\d+)[#{@indelbases}]/.match(element)[1].to_i
+        # capture remaining nucleotides
+        non_indel_bases << element.gsub(/^#{number}\w{#{number}}/, '')
+      end
+      bases_hash = snp_base_hash(non_indel_bases)
+      # check at least three reads are supporting indel
+      indel_count = self.read_bases.count(delimiter)
+      if indel_count >= Options.min_indel_count_support
+        bases_hash[:indel] = indel_count
+      end
+      bases_hash
     end
-    bases_hash = snp_base_hash(non_indel_bases)
-    # check at least three reads are supporting indel
-    indel_count = self.read_bases.count(delimiter)
-    if indel_count >= @defaults[:min_indel_count_support]
-      bases_hash[:indel] = indel_count
+
+    def snp_base_hash(readbases)
+      non_indel_base_hash = {}
+      non_indel_base_hash[:ref] = readbases.count('.,')
+      non_indel_base_hash[:A] = readbases.count('aA')
+      non_indel_base_hash[:C] = readbases.count('cC')
+      non_indel_base_hash[:G] = readbases.count('gG')
+      non_indel_base_hash[:T] = readbases.count('tT')
+      # non_indel_base_hash[:N] = read_bases.count('nN')
+      non_indel_base_hash
     end
-    bases_hash
-  end
 
-  def snp_base_hash(readbases)
-    non_indel_base_hash = {}
-    non_indel_base_hash[:ref] = readbases.count('.,')
-    non_indel_base_hash[:A] = readbases.count('aA')
-    non_indel_base_hash[:C] = readbases.count('cC')
-    non_indel_base_hash[:G] = readbases.count('gG')
-    non_indel_base_hash[:T] = readbases.count('tT')
-    # non_indel_base_hash[:N] = read_bases.count('nN')
-    non_indel_base_hash
-  end
+    def indel_non_ref_count(delimitter)
+      read_bases = self.read_bases
+      non_ref_count = read_bases.count(@indelbases)
+      indelcounts = read_bases.count(delimitter)
+      indel_bases = count_indel_bases(delimitter)
+      non_ref_count + indelcounts - indel_bases
+    end
 
-  def indel_non_ref_count(delimitter)
-    read_bases = self.read_bases
-    non_ref_count = read_bases.count(@indelbases)
-    indelcounts = read_bases.count(delimitter)
-    indel_bases = count_indel_bases(delimitter)
-    non_ref_count + indelcounts - indel_bases
   end
 
 end