mspire 0.4.9 → 0.5.0

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

@@ -1,160 +0,0 @@
-
-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"],
-          :perc_qval => ['--perc_qval', "use percolator q-values to calculate precision"],
-          :to_qvalues => ['--to_qvalues', "transform probabilities into q-values",
-                                       "(includes pi_0 correction)",
-                                       "uses PROB [TYPE] if given and supercedes",
-                                       "the prob validation type",
-                                       "*NOTE: include all PeptideProphet results",
-                                       "(don't use any low prob cutoff) for",
-                                       "accurate results!"],
-          :prob => ['--prob [TYPE]', "use prophet probabilites to calculate precision",
-                                     "TYPE = nsp [default] prophet nsp",
-                                     "     (nsp also should be used for PeptideProphet results)",
-                                     "     = init (for ProteinProphet results) use initial",
-                                     "probability instead of nsp probability",
-        ],
-          # 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:
-          :pephits => ["--pephits <file>.srg", "an srg file pointing to the srf files for",
-                                               "the given -prot.xml run",
-                                               "[this or --digestion must be used for applicable]",
-                                               "validators (validators depending on a",
-                                               "false/total ratio)]"],
-        }.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 | <file>.sqg"
-            op.separator ""
-            op.separator "    RETURNS: precision across the number of hits"
-            op.separator "             (based on probability or q-value)"
-            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(:perc_qval, opts)
-            op.val_opt(:to_qvalues, opts)
-            op.val_opt(:decoy, opts)
-            op.val_opt(:pephits, opts)       # sets opts[:ties] = false
-            op.val_opt(:digestion, opts)
-            op.val_opt(:bias, opts)
-            op.val_opt(:bad_aa, opts)
-            op.val_opt(:bad_aa_est, opts)
-
-            op.val_opt(:tmm, opts)
-            op.val_opt(:fasta, 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 = ::SpecID.new(args[0])
-            if opts[:ties] == nil   # will be nil or false
-              opts[:ties] = Validator::Cmdline::DEFAULTS[:ties]
-            end
-            postfilter = 
-              if spec_id_obj.class == SQTGroup or spec_id_obj.class == Proph::PepSummary
-                #puts 'making background estimates with: top_per_scan'
-                :top_per_scan
-              else
-                #puts 'making background estimates with: top_per_aaseq_charge'
-                :top_per_aaseq_charge
-              end
-
-            opts[:validators] = Validator::Cmdline.prepare_validators(opts, !opts[:ties], opts[:interactive], postfilter, 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

@@ -1,94 +0,0 @@
-require 'yaml'
-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)
-    col_labels[1] = 'q_values' if answer_hash.key?(:q_values)
-
-    cols = []
-    cols << answer_hash[:count]
-    if answer_hash.key?(:q_values)
-      cols << answer_hash[:q_values]
-    else
-      cols << answer_hash[:probabilities]
-    end
-    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

@@ -1,249 +0,0 @@
-# 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
-
-  # this is the way I was doing it:
-  #       ajdusted = (1+R)*prec / (R*precision +1) 
-  #       # where R is the decoy_to_target ratio
-
-  # opts may include:
-  #   :proteins => true|*false
-  #   :validators => array of Validator objects
-  #
-  #   This method will adjust the precision in the *probability* validators
-  #   used in the decoy validator (both terms with pi_0 in the denominator go
-  #   to zero if there is no decoy validator and the precision is not
-  #   adjusted)
-  #
-  #       ajdusted = (1+(1/pi_0))*prec / ((precision/pi_0) +1) 
-  #       # where pi_0 is the ratio incorrect target hits to total decoy hits
-  #
-  #   NOTE: if you have decoy data, you MUST pass in a decoy validator for the
-  #   decoy pephits to be removed from other validator analyses!  
-  #   
-  # 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)
-  #
-  # NOTE: For protein prophet, the results are given on a peptide+charge
-  # basis.  
-  #   
-  # 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 for Prophet 
-    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
-
-    check_precisions = []
-    check_precisions_decoy = []
-
-    # 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
-      if decoy_val
-        pi_zero = decoy_val.pi_zero
-      end
-    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
-
-
-    # this is a peptide prophet
-    is_peptide_prophet = 
-      if spec_id.peps.first.respond_to?(:fval) ; true
-      else ;false
-      end
-
-    use_q_value = other_validators.any? {|v| v.class == Validator::QValue }
-
-    ## ORDER THE PEPTIDE HITS:
-    ordered_peps = 
-      if use_q_value
-        spec_id.peps.sort_by {|v| v.q_value }
-      elsif is_peptide_prophet
-        spec_id.peps.reject {|v| v.probability == -1.0}.sort_by {|v| v.probability }.reverse
-      else
-        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
-      end
-
-    # for probability based precision with decoy database (not using prophet's
-    # -d flag) we do this:
-    # foreach peptide.sorted_by_probability
-    #   1. update the running precision of the validator REGARDLESS of
-    #   decoy/target status of peptide. the internal hit counts are
-    #   incremented.
-    #   2. only increment reported HIT COUNTS on a non-decoy hit and record
-    #   the precision as (1+R)*prec / (R*precision +1) where R is the ratio of
-    #   decoy hits to target hits.  If it is 1:1 (R = 1) then this becomes:
-    #   2*prec / (prec + 1)
-
-    ## WORK THROUGH EACH PEPTIDE:
-    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|
-        reply = val.increment_pephits_precision(pep)
-        check_precisions << reply
-        reply
-      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
-        check_precisions_decoy << false
-      else
-        check_precisions_decoy << true
-      end
-
-      if it_is_a_normal_pep
-        n_count += 1
-
-        # UPDATE validators:
-        val_hash[decoy_val].push(decoy_precision) if decoy_val
-        probability_validators.zip(last_prob_values) do |val,prec| 
-          if decoy_val
-            raise ArgumentError, "pi_zero in decoy validator must not == 0" if pi_zero == 0
-            val_hash[val].push( ((1.0/pi_zero+1.0)*prec) / ((prec/pi_zero) + 1.0) )
-          else
-            val_hash[val] << prec
-          end
-        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:
-        if pep.respond_to?(:mod_info)
-          modified_pep_string =
-            if pep.mod_info
-              found_modified_peptide = true
-              pep.mod_info.modified_peptide
-            else
-              nil
-            end
-          modified_peptides << modified_pep_string
-        else
-          modified_pep_string =
-            if pep.sequence =~ /[^A-Z\-\.]/
-              found_modified_peptide = true
-              pep.sequence
-            else
-              nil
-            end
-          modified_peptides << modified_pep_string
-        end
-        pepcharges << pep.charge 
-        pepstrings << pep.aaseq
-        probabilities << pep.probability  # this is the q_value if percolator
-        num_pephits << (i+1)
-      else
-        d_count += 1
-      end
-    end
-    if found_modified_peptide
-      out[:modified_peptides] = modified_peptides
-    end
-    if use_q_value
-      out[:q_values] = probabilities
-    else
-      out[:probabilities] = probabilities
-    end
-    # out[:pephits] = ordered_peps  # just in case they want to see
-    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

@@ -1,104 +0,0 @@
-
-require 'arrayclass'
-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
-    include SpecID
-
-    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 :msms_run_summaries
-    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)
-      if file
-        @version = get_version(file)
-        spec_id = SpecID::Parser::PepProph.new(:spec_id).parse(file, :spec_id => self)
-      end
-    end
-  end
-
-  # this is a SpecID::Pep (by interface: not including stuff yet)
-  class PepSummary::Pep < Sequest::PepXML::SearchHit
-    # aaseq is defined in SearchHit
-    
-    %w(probability fval ntt nmc massd prots q_value).each do |guy|
-      self.add_member(guy)
-    end
-
-    # returns self
-    def from_pepxml_node(node)
-      super(node)
-
-      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
-
-  ::Proph::PepSummary::Prot = Arrayclass.new(%w(name protein_descr peps))
-
-  class PepSummary::Prot
-    def first_entry ; self[0] end ## name
-    def reference ; self[0] + ' ' + self[1] end
-  end
-
-end
-
-
-
-