mspire 0.4.9 → 0.5.0

data/lib/transmem.rb

@@ -1,157 +0,0 @@
-
-# A transmemIndex is a hash that takes a fasta reference as key and returns
-# a structured hash containing the transmembrane information.
-module TransmemIndex
-  
-  # returns :toppred or :phobius
-  def self.filetype(file)
-    tp = nil
-    File.open(file) do |fh|
-      while (line = fh.gets)
-        case line
-        when /SEQENCE/
-          tp = :phobius 
-          break
-        when /    0  0 i/
-          tp = :phobius  # if they don't have the headers, 
-                         # this will pick it up if they have a 
-                         # single prot without tm or signal peptide.
-          break
-        when /Algorithm specific parameters/
-          tp = :toppred  # New text
-          break
-        when /<parameters>/
-          tp = :toppred  # XML
-          break
-        end
-      end
-    end
-    tp
-  end
-
-  def reference_to_key(reference)
-    # needs to be subclassed or written
-  end
-  
-  # right now accepts toppred.out files
-  # Phobius objects can use the fasta object to update their hash for methods
-  # like avg_overlap
-  def self.new(file, fasta=nil)
-    case x = filetype(file)
-    when :toppred
-      require 'transmem/toppred'
-      TopPred::Index.new(file)
-    when :phobius
-      require 'transmem/phobius'
-      # warn "WARNING: You have NO fasta object with Phobius based TransmemIndex! (which needs one to do proper indexing!)" unless fasta
-      Phobius::Index.new(file, fasta)
-    else 
-      raise ArgumentError, "#{x} filetype for #{file} not recognized!"
-    end
-  end
-
-  # returns a hash of key -> num certain transmembrane segments
-  def num_certain_index
-    hash = {}
-    self.each do |k,v|
-      hash[k] = v[:num_certain_transmembrane_segments] || 0
-    end
-    hash
-  end
-
-  # tp = :number or :fraction which is the fraction of the sequence size
-  # returns the average number of overlapping amino acids with transmembrane
-  # segments
-  # returns nil if there is no protein by that key
-  def avg_overlap(key, sequence, tp=:number)
-    if self.key? key
-      numbers = num_transmem_aa(self[key], sequence)
-      if numbers.size > 0
-        sum = 0
-        numbers.each {|num| sum += num}
-        avg_num = sum.to_f / numbers.size
-        # the one line way to do it
-        #avg_num = numbers.inject(0) {|memo,num| num + memo }.to_f / numbers.size
-        if tp == :fraction
-          avg_num / sequence.size
-          # this is the same as doing this:
-          #numbers.inject(0.0) {|memo,num| (num.to_f/seq_size + memo) } / numbers.size
-        else
-          avg_num
-        end
-      else
-        0.0
-      end
-    else  # what to do if the protein isn't there?? which happens on occasion
-      nil
-    end
-  end
-
-  # returns an array (usually length of 1) of the number of amino acids
-  # contained inside transmembrane spanning segments.
-  # assumes that tmhash has the key 'transmembrane_segments'
-  # if there are no transmembrane segments, returns empty array.
-  def num_transmem_aa(tmhash, sequence)
-    if tmhash.key? :transmembrane_segments
-      ranges = tmhash[:transmembrane_segments].map do |tmseg|
-        Range.new( tmseg[:start]-1, tmseg[:stop]-1 )
-      end
-      num_overlapping_chars(tmhash[:aaseq], ranges, sequence)
-    else
-      []
-    end
-  end
-
-  # returns an array of the number of overlapping sequences in substring with
-  # the substrings defined in start_stop_doublets within full_sequence
-  # start_stop_doublets should be 0 indexed!!!
-  # the span includes the 'stop' position i.e., full_sequence[start..stop]
-  def num_overlapping_chars(full_sequence, ranges, substring)
-    #start_positions = aaseq.enum_for(:scan, substring).map { $~.offset(0)[0]}
-    if ranges.size == 0
-      []
-      #full_sequence.enum_for(:scan, substring).map { 0 }
-    else
-      substring_ranges = []
-      pos = 0
-      slen = substring.size
-      while i=full_sequence.index(substring,pos)
-        substring_ranges << Range.new(i, i+slen-1)
-        pos = i + slen
-      end
-      # brute force way
-      last_tm_range = ranges.last.last
-      to_return = substring_ranges.map do |sb|
-        overlap = 0
-        # there's got to be a much simpler way to do this, but this does work...
-        ranges.each do |tm|
-          (frst, lst) = 
-            if tm.include?( sb.first )
-              [tm, sb]
-            elsif tm.include?( sb.last )
-              [sb, tm]
-            else
-              nil
-            end
-          if frst
-            if lst.last <= frst.last
-              overlap += (frst.last+1 - frst.first) - (lst.first - frst.first) - (frst.last - lst.last)
-            else 
-              overlap += (frst.last+1 - frst.first) - (lst.first - frst.first)
-            end
-          end
-        end
-        overlap
-      end
-    end
-  end
-
-
-end
-
-
-#substring_ranges = full_sequence.enum_for(:scan, substring).map do 
-#        (ofirst, olast) = $~.offset(0) 
-#        Range.new(ofirst, olast - 1)
-#      end
-

data/lib/validator/aa.rb

@@ -1,48 +0,0 @@
-require 'validator/digestion_based'
-require 'fasta'
-require 'spec_id/aa_freqs'
-
-# Constraints on aaseq attribute of peptides (the bare amino acid sequence)
-# works by calculating amino acid frequencies in the fasta file used.
-class Validator::AA < Validator::DigestionBased
-  include Precision::Calculator
-
-  attr_accessor :constraint
-
-  # it is a false hit if the amino acid is located in the peptide
-  attr_accessor :false_if_found
- 
-  DEFAULTS = Validator::DigestionBased::DEFAULTS.merge( {
-    :false_if_found => true,
-  } )
-
-  # returns tp, fp
-  def partition(peps)
-    (found, not_found) = peps.partition do |pep|
-      pep.aaseq.include?(@constraint)
-    end
-    if @false_if_found
-      [not_found, found] 
-    else
-      [found, not_found]
-    end
-  end
-
-  # right now only accepts single amino acids as constraints (as a string,
-  # e.g. 'C', or symbol, e.g. :C)
-  # options:
-  #  :false_to_total_ratio => if a true digestion was already performed (see
-  #                           Validator::AA.calc_false_to_total_ratio)
-  #  :false_if_found => it is a false positive if the amino acid is found.
-  #  :background => the background level of amino acid Float
-  def initialize(constraint, options={})
-    @constraint = constraint.to_s
-    opts = DEFAULTS.merge(options)
-    (@false_to_total_ratio, @false_if_found, @background) = opts.values_at(:false_to_total_ratio, :false_if_found, :background)
-  end
-
-  def to_param_string
-    "aminoacid(bad_aa)=" + ["{constraint=#{@constraint}", "false_to_total_ratio=#{@false_to_total_ratio}", "bkg=#{(@background ? @background : 0.0) }}"].join(", ")
-  end
-end
-

data/lib/validator/aa_est.rb

@@ -1,112 +0,0 @@
-require 'validator/aa'
-
-
-class Validator ; end
-class Validator::AA ; end
-
-# A class that uses the peps given to it and a background frequency to
-# calculate the false_to_total_ratio at each turn.
-class Validator::AAEst < Validator::AA
-  attr_accessor :constraint
-  attr_accessor :false_if_found
-
-  # the frequency of the amino acid is used to estimate the false to
-  # total ratio based on the pephits given for pephit_precision.
-  # see Validator::AA.calc_frequency to calculate a frequency
-  # or use set_frequency to set from pep hits.
-  attr_accessor :frequency
-
-  DEFAULTS = {
-    :false_if_found => true
-  }.merge(Validator::DigestionBased::DEFAULTS)  # background 0.0
-
-  # only takes a string right now for constraint
-  def initialize(constraint, options={})
-    @constraint = constraint.to_s
-    opts = DEFAULTS.merge(options)
-    (@frequency, @false_if_found, @background) = opts.values_at(:frequency, :false_if_found, :background)
-  end
-
-  def pephit_precision(peps)
-    set_false_to_total_ratio(peps)
-    super(peps)
-  end
-
-  def set_false_to_total_ratio(peps)
-    if peps.size > 0
-      expected = 0.0
-      peps.each do |pep|
-        expected += (1.0 - ((1.0 - @frequency)**pep.aaseq.size))
-      end
-      @false_to_total_ratio = expected / peps.size
-    else
-      @false_to_total_ratio = 1.0
-    end
-  end
-
-  def set_ongoing_false_to_total_ratio(peps)
-    if peps.size > 0
-      peps.each do |pep|
-        @expected += (1.0 - ((1.0-@frequency)**pep.aaseq.size))
-      end
-      # @increment_total_submitted should == @increment_tps and @increment_fps
-      # since these are either/or
-      @false_to_total_ratio = @expected / @increment_total_submitted
-    else
-      @false_to_total_ratio = 1.0
-    end
-  end
-
-
-  def to_param_string
-    "aminoacid(bad_aa)=" + ["{constraint=#{@constraint}", "frequency=#{@frequency}", "bkg=#{(@background ? @background : 0.0) }}"].join(", ")
-  end
-
-  # takes objects responding to aaseq and sets the frequency based on
-  # constraint.  constraint is one acceptable to initialize!  returns self
-  def set_frequency(objs)
-    table = SpecID::AAFreqs.new.calculate_frequencies(objs)
-    @frequency = table[@constraint.to_sym]
-    self
-  end
-
-   # if adding pephits in groups at a time, the entire group does not need to be
-  # queried, just the individual hit.  Use this OR pephits_precision (NOT
-  # both).  The initial query to this method will begin a running tally that
-  # is saved by the validator.
-  # takes either an array or a single pephit (determined by if it is a
-  # SpecID::Pep)
-  def increment_pephits_precision(peps)
-    tmp = $VERBOSE; $VERBOSE = nil
-    unless @increment_initialized
-      initialize_increment
-      @expected = 0.0
-    end
-    $VERBOSE = tmp
-
-    to_submit = 
-      if peps.is_a? SpecID::Pep
-        [peps]
-      else
-        peps
-      end
-    @increment_total_submitted += to_submit.size
-    (tps, fps) = partition(to_submit)
-    #### THIS IS THE MAGIC FOR THIS VALIDATOR:
-    set_ongoing_false_to_total_ratio(to_submit)
-    
-    @increment_tps += tps.size
-    @increment_fps += fps.size
-    (num_tps, num_fps) = 
-      if self.respond_to?(:calc_precision_prep)  # for digestion based validators
-        (num_tps, num_fps) = calc_precision_prep(@increment_tps, @increment_fps)
-        [num_tps, num_fps]
-      else
-        [@increment_tps, @increment_fps]
-      end
-    calc_precision(num_tps, num_fps)
-  end
-
-
-
-end

data/lib/validator/background.rb

@@ -1,77 +0,0 @@
-require 'validator'
-require 'vec'
-require 'enumerator'
-
-class Validator ; end
-class Validator::Background
-
-  attr_accessor :data
-
-  def initialize(data=nil)
-    @data = data
-  end
-
-  def delete_nan!(vec)
-    vec.each_with_index do |v,i|
-      if v.nan?
-        vec[i] = 0
-      end
-    end
-  end
-
-  def stdev_plus_spread(stdev_factor=2.0, stdev_points=15, min_window_pre=5, min_window_post=5)
-    data_vec = VecD[*@data]
-    delete_nan!(data_vec)
-    stdev_transform = data_vec.transform(9) {|vec| (stdev_factor * vec.sample_stats[1]) + vec.spread  } 
-    smoothed_stdev = stdev_transform.transform(9) {|vec| vec.avg }
-    smoothed_stdev_derivs = smoothed_stdev.chim
-    last_0_index = index_of_last_0(smoothed_stdev_derivs)
-    min_in_window(data_vec, last_0_index, min_window_pre, min_window_post)
-  end
-
-  def plot(vec)
-    `graph #{vec.join(" ")} -a -T X`
-  end
-
-  # not really working right currently
-  def derivs(avg_points=15, min_window_pre=5, min_window_post=5)
-    data_vec = VecD[*@data]
-    delete_nan!(data_vec)
-    drvs = data_vec.chim
-    # absolute value
-    drvs.each_with_index {|x,i| drvs[i] = x.abs }
-    mv_avg = drvs.transform(avg_points) {|v| v.avg }
-    last_0_index = index_of_last_0(mv_avg.chim)
-    min_in_window(data_vec, last_0_index, min_window_pre, min_window_post)
-  end
-
-  def index_of_last_0(vec)
-    last_0_index = nil
-    vec.each_with_index do |v,i|
-      if v == 0
-        last_0_index = i
-      end
-    end
-    last_0_index
-  end
-
-  # returns the minimum value in the window centered on index
-  def min_in_window(vec, index, pre, post)
-    last_index = vec.size - 1
-    start = index - pre
-    stop = index + post
-    start = 0 if start < 0
-    stop = last_index if stop > last_index
-    vec[start..stop].min
-  end
-
-  # very simple, should work
-  def min_mesa(start, stop, points=3)
-    data_vec = VecD[*@data]
-    delete_nan!(data_vec)
-    smoothed = data_vec.transform(3) {|v| v.avg }
-    smoothed[start..stop].min
-  end
-  
-end
-

data/lib/validator/bias.rb

@@ -1,95 +0,0 @@
-require 'validator'
-require 'validator/digestion_based'
-
-# class for any generic kind of bias.  For instance, a list of high abundance
-# proteins we would expect to see, or a list of low abundance proteins we
-# would not expect to see, or proteins that have been filtered out in some
-# way, etc.
-class Validator::Bias < Validator::DigestionBased
-  include Precision::Calculator
-
-  # a fasta object (by default containing proteins expected to be in the
-  # sample [see proteins_expected to modify that behavior])
-  attr_reader :fasta
-
-  # correct_wins means that only a single protein from a pep.aaseq must match
-  # the fasta object for the pep hit to be considered valid.  Otherwise, all
-  # must be a match (logic negated by proteins_expected)
-  attr_accessor :correct_wins
-
-  # proteins_expected==true means we expect to see the proteins in the sample
-  # proteins_expected==false means we do not expect to see these proteins in
-  # the sample
-  attr_accessor :proteins_expected
-
-  # a hash made by taking each fasta reference in fasta_object, (everything
-  # until a space) and setting the value to true.  It can be queried with the
-  # start of an fasta sequence
-  attr_accessor :short_reference_hash
-
-  DEFAULTS = Validator::DigestionBased::DEFAULTS.merge( {
-    :proteins_expected => true, 
-    :correct_wins => true,
-  } )
-
-  # options: 
-  #   (t = true, f = false, '*'= default)
-  #   :proteins_expected => *t/f  we expect to see the fasta proteins in our hit list
-  #   :correct_wins => *t/f  a single peptide hit from one of these proteins
-  #                    constitutes a true positive 
-  #   :background => Float  (*0.0-1.0)
-  #   :false_to_total_ratio => Float (*nil by default)
-  def initialize(fasta_object, options={})
-    opts = DEFAULTS.merge(options)
-    (@proteins_expected, @correct_wins, @background, @false_to_total_ratio) = opts.values_at(:proteins_expected, :correct_wins, :background, :false_to_total_ratio)
-    @fasta = fasta_object
-    @header_split_hash = @fasta.prots.map {|prot| prot.reference }
-    @short_reference_hash = self.class.make_short_reference_hash(fasta_object)
-  end
-
-  def self.make_short_reference_hash(fasta_object)
-    hash = {}
-    fasta_object.each do |prot|
-      hash[prot.first_entry] = true
-    end
-    hash
-  end
-
-  def partition(peps)
-    klass = self.class
-    cw = 
-      if !@proteins_expected
-        !@correct_wins
-      else
-        @correct_wins
-      end
-
-    (tp, fp) = 
-      if cw
-        peps.partition do |pep|
-          pep.prots.any? do |pepprot| 
-            @short_reference_hash.key?( pepprot.first_entry )
-          end
-        end
-      else
-        peps.partition do |pep|
-          pep.prots.any? do |pepprot| 
-            !@short_reference_hash.key?( pepprot.first_entry )
-          end
-        end
-      end
-
-    if !@correct_wins
-      tp, fp = fp, tp
-    end
-
-    [tp, fp]
-  end
-
-  # pephit_precision is done through inheritance
-
-  def to_param_string
-    "abundance=" +  ["{fasta=#{@fasta.filename}", "proteins_expected=#{@proteins_expected}", "correct_wins=#{@correct_wins}", "background=#{@background}}"].join(", ")
-  end
-
-end