mspire 0.2.4 → 0.3.0

data/lib/spec_id/precision/prob/cmdline.rb

@@ -0,0 +1,139 @@
+
+require 'validator/cmdline'
+require 'spec_id'
+
+module SpecID
+  module Precision
+    class Prob
+      class CmdlineParser
+
+       DEFAULTS = SpecID::Precision::Prob::PN_DEFAULTS.merge( { :output => [[:csv, nil]], } )
+
+       
+        COMMAND_LINE = {
+          :sort_by_init => ['--sort_by_init', "sort the proteins based on init probability"],
+          :prob => ['--prob [TYPE]', "use prophet probabilites to calculate precision",
+                                     "TYPE = *nsp|init"],
+          # OUTPUT
+          :proteins => ["--proteins", "includes proteins (and validation)"],
+          :output => ["-o", "--output format[:FILENAME]", "format to output filtering results.",
+                                                       "can be used multiple times", 
+                                                       ":FILENAME is the filename to use (defaults to STDOUT)",
+                                                       "valid formats are:",
+                                                       "    csv  (default)",
+                                                       "    to_plot",
+                                                       "    calc_bkg_to_plot",
+                                                       "    yaml",
+                                                       #"    protein_summary (need to implement)",
+                                                       #"    html_table      (need to implement)"
+                                               ],
+
+          # VALIDATION MODIFIERS:
+          :hits_separate => ["--hits_separate", "target/decoy hits are normally together when choosing",
+                                                "the top hit per peptide (in prefilter and postfilter)",
+                                                "in BOTH catenated and separate searches.  This flag",
+                                                "separates them when finding the top hit per scan.",
+                                                "[This option modifies behavior of --decoy options]"],
+
+        }.merge( Validator::Cmdline::COMMAND_LINE )
+
+
+        # returns (spec_id_obj, options, option_parser_obj)
+        def parse(args)
+          opts = {}
+          opts[:output] = []
+          @out_used = false
+          opts[:sequest] = {}
+          opts[:validators] = []
+          # defaults
+
+          option_parser = OptionParser.new do |op|
+            def op.opt(arg, &block)
+              on(*COMMAND_LINE[arg], &block)
+            end
+
+            def op.val_opt(arg, opts)
+              on(*COMMAND_LINE[arg]) {|ar| Validator::Cmdline::PrepArgs[arg].call(ar, opts) }
+            end
+
+            def op.exact_opt(opts, arg)
+              on(*COMMAND_LINE[arg]) {|v| opts[arg] = v}
+            end
+
+            op.banner = "USAGE: #{File.basename($0)} [OPTS] <file>-prot.xml"
+            op.separator ""
+            op.separator "    RETURNS: precision across the number of hits (based on probability)"
+            op.separator "             (optional) other validation of the results."
+            op.separator ""
+
+            op.separator "OUTPUT OPTIONS: "
+            op.opt(:proteins) {|v| opts[:proteins] = true }
+            op.opt(:output) do |output|
+              # copied from rspec:
+              # This funky regexp checks whether we have a FILE_NAME or not
+              where = nil
+              if (output =~ /([a-zA-Z_]+(?:::[a-zA-Z_]+)*):?(.*)/) && ($2 != '')
+                output = $1
+                where = $2
+              else
+                raise "When using several --output options only one of them can be without a file" if @out_used
+                @out_used = true
+              end
+              opts[:output] << [output, where]
+            end
+
+            op.separator "GENERAL OPTIONS:"
+            op.separator ""
+            op.opt(:sort_by_init) {|v| opts[:sort_by_init] = true }
+            op.separator "VALIDATION OPTIONS: "
+            op.separator "   each option will calculate the precision"
+            op.separator ""
+
+            op.val_opt(:prob, opts)
+            op.val_opt(:decoy, opts)
+            op.val_opt(:digestion, opts)
+            op.val_opt(:bias, opts)
+            op.val_opt(:bad_aa, opts)
+
+            op.val_opt(:tmm, opts)
+            op.val_opt(:tps, opts)
+
+            op.separator ""
+            op.separator "VALIDATION MODIFIERS: "
+            op.val_opt(:false_on_tie, opts)  # sets opts[:ties] = false
+
+          end
+          option_parser.parse!(args)
+
+          # prepare validators
+
+          if args.size > 0
+            spec_id_obj = 
+              if args[0] =~ /\.srf$/i
+                ::SpecID.new(args)
+              else
+                ::SpecID.new(args[0])
+              end
+            if opts[:ties] == nil   # will be nil or false
+              opts[:ties] = Validator::Cmdline::DEFAULTS[:ties]
+            end
+            opts[:validators] = Validator::Cmdline.prepare_validators(opts, !opts[:ties], opts[:interactive], spec_id_obj)
+
+            if opts[:output].size == 0
+              opts[:output] = DEFAULTS[:output]
+            end
+          else
+            spec_id_obj = nil
+          end
+
+          [spec_id_obj, opts, option_parser]
+        end # parse
+      end # CmdlineParser
+    end # Prob
+  end # Precision
+end # SpecID
+
+
+
+
+

data/lib/spec_id/precision/prob/output.rb

@@ -0,0 +1,88 @@
+
+require 'spec_id/precision/output'
+require 'table'
+require 'matrix'
+
+module SpecID ; end
+module SpecID::Precision ; end
+class SpecID::Precision::Prob ; end
+class SpecID::Precision::Prob::Output 
+  include SpecID::Precision::Output
+
+  # returns array of data arrays and parallel labels
+  def to_cols_and_labels(answer_hash)
+    col_labels = %w(count probability peptide)
+
+    cols = []
+    cols << answer_hash[:count]
+    cols << answer_hash[:probabilities]
+    cols << answer_hash[:aaseqs]
+
+    # if there is a single modified peptide, we'll include the column
+    if answer_hash.key?(:modified_peptides)
+      cols << answer_hash[:modified_peptides]
+      col_labels.push( 'modified_peptide' )
+    end
+
+    col_labels.push( 'charge' )
+    cols << answer_hash[:charges]
+
+    answer_hash[:pephits_precision].each do |ans|
+      col_labels.push( "#{ans[:validator]} (prob)" )
+      cols << ans[:values]
+    end
+
+    [cols, col_labels]
+  end
+
+  def csv(handle, answer_hash)
+    (cols, col_labels) = to_cols_and_labels(answer_hash)
+    table = Table.new(Matrix[*cols].transpose, nil, col_labels)
+    handle.puts(table.to_s("\t"))
+  end
+
+  def to_plot(handle, answer_hash)
+    tp = 'XYData'
+    basename_noext = 
+      if handle.respond_to?(:path)
+        out = File.basename(handle.path).sub(/\.(\w)+$/,'')
+      else
+        'plot'
+      end
+    title = 'precision vs. num (aaseq+charge)'
+    xlabel = 'num hits'
+    ylabel = 'precision'
+    [tp, basename_noext, title, xlabel, ylabel].each {|v| handle.puts v }
+    answer_hash[:pephits_precision].each do |hash|
+      handle.puts hash[:validator]    # label
+      handle.puts answer_hash[:count] # x vals
+      handle.puts hash[:values]       # y vals
+    end
+  end
+
+  def calc_bkg_to_plot(handle, answer_hash)
+    tp = 'XYData'
+    basename_noext = 
+    if handle.respond_to?(:path)
+      out = File.basename(handle.path).sub(/\.(\w)+$/,'')
+    else
+        'calc_bkg_plot'
+    end
+    title = 'background vs. num (aaseq+charge)'
+    xlabel = 'num hits'
+    ylabel = 'background (false/total)'
+    [tp, basename_noext, title, xlabel, ylabel].each {|v| handle.puts v }
+    answer_hash[:params][:validators].each do |hash|
+      handle.puts hash[:name]    # label
+      handle.puts answer_hash[:count] # x vals
+      handle.puts hash[:calculated_backgrounds]       # y vals
+    end
+  end
+
+  def yaml(handle, answer_hash)
+    handle.puts answer_hash.to_yaml
+  end
+
+end
+
+

data/lib/spec_id/precision/prob.rb

@@ -0,0 +1,171 @@
+# note that we require  'spec_id/precision/prob/cmdline' below!
+
+require 'spec_id/precision/prob/output'
+
+module SpecID ; end
+module SpecID::Precision ; end
+
+
+# for probability based spec identifications (true probabilities, not the
+# bioworks p-value (which they call probability)).
+class SpecID::Precision::Prob
+
+  PN_DEFAULTS = {
+    :proteins => false,
+    :validators => [],
+    :sort_by_init => false,
+  }
+
+  require 'spec_id/precision/prob/cmdline'
+
+  def precision_vs_num_hits_cmdline(args) 
+    (spec_id_obj, options, option_parser) = CmdlineParser.new.parse(args)
+    if spec_id_obj == nil
+      puts option_parser
+      return
+    end
+    final_answer = SpecID::Precision::Prob.new.precision_vs_num_hits(spec_id_obj, options)
+    options[:output].each do |output|
+      output[1] = $stdout unless output[1]
+      SpecID::Precision::Prob::Output.new(*output).print(final_answer).close
+    end
+  end
+
+  # opts may include:
+  #   :proteins => true|*false
+  #   :validators => array of Validator objects
+  #   NOTE: if you have decoy data, you MUST pass in a decoy validator for the
+  #   decoy pephits to be removed from other validator analyses!
+  #   (precision based on peptide probabilities are adjusted to account for
+  #   the decoy peptides being present: Precision(no_decoy) = (2*Prec)/(Prec+1)
+  #   which is derived from the 50/50 rule for decoy vs. embedded false hits
+  #   
+  # returns a hash of data
+  #   :pephits_precision => [{validator => <name>, values => [<precision>,...]},... ]
+  #   :params => :validators => [array of validators] (includes
+  #   :calculated_backgrounds)
+  #   :aaseqs => array of aaseqs
+  #   :charges => array of charge
+  #   :modified_peptides => array of modified sequence (only included if
+  #   applicable)
+  #
+  #   
+  # TODO: implement tihs guy:
+  #   prothits_precision => {validator => <name>, values => {worst => ,
+  #   normal, normal_stdev } }
+  def precision_vs_num_hits(spec_id, opts={})
+   
+    opt = PN_DEFAULTS.merge(opts)
+
+    out = {}
+    num_pephits = []  # NOTE!: these are aaseq/aaseq_mod + charge (not really a pephit, but BEST)
+    val_hash = Hash.new {|hash,key| hash[key] = [] }
+    val_calc_bkg_hash = Hash.new {|hash,key| hash[key] = [] }
+    pepstrings = []
+    modified_peptides = []
+    pepcharges = []
+    probabilities = []
+    found_modified_peptide = false
+
+
+    # do we need to deal with decoy peptides? (true/false)
+    validators = opt[:validators].map
+    decoy_vals = validators.select {|val| val.class == Validator::Decoy }
+    
+    if decoy_vals.size > 1
+      raise(ArgumentError, "only one decoy validator allowed!") 
+    else
+      decoy_val = decoy_vals.first
+    end
+    validators.delete(decoy_val)
+    other_validators = validators
+
+    (probability_validators, other_validators) = other_validators.partition {|val| val.class == Validator::Probability }
+    if opt[:initial_probability]
+      probability_validators.each do |pv|
+        pv.prob_method = :initial_probability
+      end
+    end
+
+    n_count = 0
+    d_count = 0
+    ordered_peps = 
+      if opt[:sort_by_init]
+        spec_id.peps.sort_by{|v| [v.initial_probability, v.n_instances,  ( v.is_nondegenerate_evidence ? 1 : 0 ), v.n_enzymatic_termini, ( v.is_contributing_evidence ? 1 : 0 ), v.n_sibling_peptides] }.reverse
+      else
+        spec_id.peps.sort_by{|v| [v.nsp_adjusted_probability, v.initial_probability, v.n_instances,  ( v.is_nondegenerate_evidence ? 1 : 0 ), v.n_enzymatic_termini, ( v.is_contributing_evidence ? 1 : 0 ), v.n_sibling_peptides] }.reverse
+      end
+    ordered_peps.each_with_index do |pep,i|
+      # probability validators must work on the entire set of normal and decoy
+
+      last_prob_values = probability_validators.map do |val|
+        val.increment_pephits_precision(pep)
+      end
+
+      it_is_a_normal_pep = 
+        if decoy_val
+          # get the decoy precision
+          decoy_precision = decoy_val.increment_pephits_precision(pep)
+
+          # continue with ONLY normal peptides
+          is_normal = (decoy_val.normal_peps_just_submitted.size > 0)
+        else
+          true
+        end
+
+      if it_is_a_normal_pep
+        n_count += 1
+
+        # UPDATE validators:
+        val_hash[decoy_val] << decoy_precision
+        probability_validators.zip(last_prob_values) do |val,prec| 
+          val_hash[val] << ( (prec * 2.0) / (prec + 1.0) )
+        end
+        other_validators.each do |val|
+          val_hash[val] << val.increment_pephits_precision(pep)
+          if val.is_a? Validator::DigestionBased
+            val_calc_bkg_hash[val] << val.calculated_background
+          end
+        end
+
+        # UPDATE other basic useful information:
+        modified_pep_string =
+          if pep.mod_info
+            found_modified_peptide = true
+            pep.mod_info.modified_peptide
+          else
+            nil
+          end
+        modified_peptides << modified_pep_string
+        pepcharges << pep.charge 
+        pepstrings << pep.aaseq
+        probabilities << pep.probability
+        num_pephits << (i+1)
+      else
+        d_count += 1
+      end
+    end
+    if found_modified_peptide
+      out[:modified_peptides] = modified_peptides
+    end
+    out[:probabilities] = probabilities
+    out[:count] = num_pephits
+    out[:aaseqs] = pepstrings
+    out[:charges] = pepcharges
+    out[:pephits_precision] = opt[:validators].map do |val| 
+      hsh = {}
+      hsh[:validator] = Validator::Validator_to_string[val.class.to_s]
+      hsh[:values] = val_hash[val]
+      hsh
+    end
+    out[:params] = {}
+    out[:params][:validators] = Validator.sensible_validator_hashes(opt[:validators]).zip(opt[:validators]).map do |hash,val|
+      hash.delete(:calculated_background)
+      hash[:calculated_backgrounds] = val_calc_bkg_hash[val]
+      hash
+    end
+    out
+  end
+end
+
+

data/lib/spec_id/proph/pep_summary.rb

@@ -0,0 +1,92 @@
+
+require 'array_class'
+puts "REQUIRING"
+puts( require 'spec_id/sequest/pepxml' )
+require 'spec_id/parser/proph'
+
+module Sequest ; end
+class Sequest::PepXML ; end
+class Sequest::PepXML::MSMSRunSummary ; end
+class Sequest::PepXML::SearchHit ; end
+
+module SpecID ; end
+module SpecID::Prot ; end
+module SpecID::Pep ; end
+
+module Proph
+
+  class PepSummary < Sequest::PepXML::MSMSRunSummary
+    # MSMSRunSummary is a SpecID object!
+
+    Filetype_and_version_re_new = /version="PeptideProphet v([\d\.]+) /
+
+    # inherits prots and peps
+
+    # the protein groups
+    # currently these are just xml nodes returned!
+    attr_accessor :peptideprophet_summary
+    attr_accessor :spectrum_queries
+    attr_accessor :version
+
+    def hi_prob_best ; true end
+
+    def get_version(file)
+      answer = nil
+      File.open(file) do |fh|
+        8.times do
+          line = fh.gets
+          answer = 
+            if line =~ Filetype_and_version_re_new
+              $1.dup
+            end
+          break if answer
+        end
+      end
+      raise(ArgumentError, "couldn't detect version in #{file}") unless answer
+      answer
+    end
+
+    def search_hit_class
+      PepSummary::Pep
+    end
+
+    def initialize(file=nil)
+      @prots = nil
+      if file
+        @version = get_version(file)
+        #@prot_groups = ProtSummary::Parser.new.parse_file(file)
+        SpecID::Parser::PepProph.new(:spec_id).parse(file, :spec_id => self)
+      end
+    end
+  end
+
+  class PepSummary::Pep < Sequest::PepXML::SearchHit
+    %w(probability fval ntt nmc massd).each do |guy|
+      self.add_member(guy) 
+    end
+
+    # returns self
+    def from_pepxml_node(node, spec_query)
+      super(node, spec_query)
+      #pp_n = node.find_first('descendant::peptideprophet_result')
+      an_res = node.find_first('child::analysis_result')
+      pp_n = an_res.find_first('child::peptideprophet_result')
+      self.probability = pp_n['probability'].to_f
+      pp_n.find('descendant::parameter').each do |par_n|
+        case par_n['name']
+        when 'fval'
+          self.fval = par_n['value'].to_f
+        when 'ntt'
+          self.ntt = par_n['value'].to_i
+        when 'nmc'
+          self.nmc = par_n['value'].to_i
+        when 'massd'
+          self.massd = par_n['value'].to_f
+        end
+      end
+      self
+    end
+  end
+end
+
+