mspire 0.2.4 → 0.3.0

data/lib/validator.rb

@@ -0,0 +1,214 @@
+
+class Validator
+
+  Validator_to_string = {
+    'Validator::AA' => 'badAA',
+    'Validator::Decoy' => 'decoy',
+    'Validator::Transmem::Protein' => 'tmm',
+    'Validator::TruePos' => 'tps',
+    'Validator::Bias' => 'bias',
+    'Validator::Probability' => 'prob',
+    :bad_aa => 'badAA',
+    :decoy => 'decoy',
+    :tmm => 'tmm',
+    :tps => 'tps',
+    :bias => 'bias',
+    :prob => 'prob',
+  }
+
+  def initialize_increment
+    @increment_tps = 0
+    @increment_fps = 0
+    @increment_total_submitted = 0
+    @increment_initialized = true
+  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
+    initialize_increment unless @increment_initialized
+    $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)
+    @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
+
+
+  # returns an adjusted false positive rate (a float not to drop below 0.0)
+  # based on a background of 'false'-false positive hits to total hits.  Also
+  # sets the @calculated_background attribute.  Accepts floats or ints
+  def adjust_fps_for_background(num_tps, num_fps, background)
+    num_fps = num_fps.to_f
+    total_peps = num_tps + num_fps
+    @calculated_background = num_fps / total_peps
+    num_fps -= (total_peps.to_f * background)
+    num_fps = 0.0 if num_fps < 0.0
+    num_fps
+  end
+
+  # copied from libjtp: vec
+  # returns the mean and std_dev
+  def sample_stats(array)
+    _len = array.size
+    _sum = 0.0
+    _sum_sq = 0.0
+    array.each do |val|
+      _sum += val
+      _sum_sq += val * val
+    end
+    std_dev = _sum_sq - ((_sum * _sum)/_len)
+    std_dev /= ( (_len > 1) ? (_len-1) : 1 )
+    # on occasion, a very small negative number occurs
+    if std_dev < 0.0    
+      std_dev = 0.0 
+    else
+      std_dev = Math.sqrt(std_dev)
+    end
+    mean = _sum.to_f/_len
+    [mean, std_dev]
+  end
+
+  # takes an array of validators and returns a fresh array where each has been
+  # turned into a sensible hash (with symbols as the keys!)
+  def self.sensible_validator_hashes(validators)
+    validators.map do |val|
+      hash = {}
+      case val
+      when Validator::TruePos
+        hash.merge( {:correct_wins => val.correct_wins, :file => val.fasta.filename } )
+      when Validator::AA
+        %w(frequency false_to_total_ratio background calculated_background false_to_total_ratio).each do |cat|
+          hash[cat.to_sym] = val.send(cat.to_sym)
+        end
+      when Validator::Decoy
+        %w(correct_wins decoy_on_match).each do |cat|
+          hash[cat.to_sym] = val.send(cat.to_sym)
+        end
+        hash[:constraint] = val.constraint.inspect if val.constraint
+      when Validator::Bias
+        %w(correct_wins proteins_expected background calculated_background false_to_total_ratio).each do |cat|
+          hash[cat.to_sym] = val.send(cat.to_sym)
+        end
+        hash[:file] = val.fasta.filename
+      when Validator::Transmem::Protein
+        %w(false_to_total_ratio min_num_tms soluble_fraction correct_wins no_include_tm_peps background calculated_background transmem_file).each do |cat|
+          hash[cat.to_sym] = val.send(cat.to_sym)
+        end
+      when Validator::Probability
+        %w(prob_method).each do |cat|
+          hash[cat.to_sym] = val.send(cat.to_sym)
+        end
+      else ; raise ArgumentError, "Don't know the validator class #{val}"
+      end
+      klass_as_s = val.class.to_s
+      hash[:type] = Validator_to_string[klass_as_s]
+      hash[:class] = klass_as_s
+      hash
+    end
+  end
+
+=begin
+  ## THIS IS WITH STRINGS AS KEYS!
+  # takes an array of validators and returns a fresh array where each has been
+  # turned into a sensible hash (with symbols as the keys!)
+  def self.sensible_validator_hashes(validators)
+    validators.map do |val|
+      hash = {}
+      case val
+      when Validator::TruePos
+        hash.merge( {'correct_wins' => val.correct_wins, 'file' => val.fasta.filename } )
+      when Validator::AA
+        %w(frequency false_to_total_ratio background calculated_background false_to_total_ratio).each do |cat|
+          hash[cat] = val.send(cat.to_sym)
+        end
+      when Validator::Decoy
+        %w(correct_wins decoy_on_match).each do |cat|
+          hash[cat] = val.send(cat.to_sym)
+        end
+        hash['constraint'] = val.constraint.inspect if val.constraint
+      when Validator::Bias
+        %w(correct_wins proteins_expected background calculated_background false_to_total_ratio).each do |cat|
+          hash[cat] = val.send(cat.to_sym)
+        end
+        hash['file'] = val.fasta.filename
+      when Validator::Transmem::Protein
+        %w(false_to_total_ratio min_num_tms soluble_fraction correct_wins no_include_tm_peps background calculated_background transmem_file).each do |cat|
+          hash[cat] = val.send(cat.to_sym)
+        end
+      when Validator::Probability
+      else ; raise ArgumentError, "Don't know the validator class #{val}"
+      end
+      klass_as_s = val.class.to_s
+      hash['type'] = Validator_to_string[klass_as_s]
+      hash['class'] = klass_as_s
+      hash
+    end
+  end
+=end
+
+end
+
+module Precision::Calculator
+  # calculates precision by the assumption that the first group are all true
+  # hits and the second are all false hits
+  # (0,0) is returned as 1.0
+  def calc_precision(num_true_hits, num_false_hits)
+    if ((num_true_hits.to_f == 0.0) && (num_false_hits.to_f == 0.0))
+      1.0
+    else
+      num_true_hits.to_f / (num_true_hits.to_f + num_false_hits.to_f)
+    end
+  end
+end
+
+# will calculate precision for groups of proteins where the first group are
+# normal hits (which may be true or false) and the second are decoy hits.
+# edge case:  if num_normal.to_f == 0.0 then if num_decoy.to_f > 0 ; 0, else 1
+module Precision::Calculator::Decoy
+  def calc_precision(num_normal, num_decoy)
+    # will calculate as floats in case fractional amounts passed in for
+    # whatever reason
+    num_normal_f = num_normal.to_f
+    num_true_pos = num_normal.to_f - num_decoy
+    precision =
+      if num_normal_f == 0.0
+        if num_decoy.to_f > 0.0
+          0.0
+        else
+          1.0
+        end
+      else
+        num_true_pos/num_normal_f
+      end
+  end
+end
+
+require 'validator/true_pos'
+require 'validator/aa'
+require 'validator/bias'
+require 'validator/decoy'
+require 'validator/transmem'
+require 'validator/probability'
+require 'validator/prot_from_pep'
+

data/lib/xml.rb

@@ -0,0 +1,38 @@
+
+module XML
+  HourMinuteMatch = /[MH]/o 
+  # returns a float object of seconds
+  # doesn't support year month, etc, yet
+  def self.duration_to_seconds(string)
+    case x = string[0,2]
+    when 'PT'
+      rest = string[2..-1]
+      # usually it will be this 'PT1.223434S':
+      if rest !~ HourMinuteMatch
+        rest[0...-1].to_f
+      else
+        addit = ''
+        total_secs = 0
+        total_secs_as_float = nil
+        rest.split('').each do |let|
+          case let
+          when 'H'
+            total_secs += addit.to_i * 3600
+            addit = ''
+          when 'M'
+            total_secs += addit.to_i * 60
+            addit = ''
+          when 'S'
+            total_secs_as_float = total_secs.to_f
+            total_secs_as_float += addit.to_f
+          else
+            addit << let
+          end
+        end
+        total_secs_as_float
+      end
+    else 
+      abort 'need to include support for other durations'
+    end
+  end
+end

data/lib/xml_style_parser.rb

@@ -0,0 +1,105 @@
+
+module XMLStyleParser
+  @done_once = nil
+  
+  Parser_precedence = %w(AXML LibXML XMLParser Regexp REXML)
+  # currently AXML requires 'xmlparser' to be installed.... (may not always be
+  # the case...)
+  File_required = {'AXML' => /^axml/, 'LibXML' => /^xml\/libxml/, 'XMLParser' => /^xmlparser/}
+
+  # the method that the parser will call on the given file at parse!
+  attr_accessor :method
+
+  # parses the given file by sending to @method
+  def parse(file, opts={})
+    if respond_to? @method
+      send(@method, file, opts)
+    else
+      raise NoMethodError, "Parser of class #{self.class} can't parse #{@method} yet"
+    end
+  end
+
+  # XMLParser and xml/libxml are incompatible, so if xmlparser is available,
+  # libxml will not be loaded (XMLParser#parse is clobbered by
+  # XML::Parser#parse [don't ask me why])
+  def self.require_parsers
+    if !@done_once
+      have_xmlparser = false
+      begin
+        require 'xmlparser'
+        puts "Loaded XMLParser" if $VERBOSE
+        have_xmlparser = true
+      rescue LoadError
+      end
+
+      begin
+        require 'axml'
+        puts "Loaded AXML" if $VERBOSE
+      rescue LoadError
+      end
+
+      begin
+        unless have_xmlparser
+          require 'xml/libxml'
+          puts "Loaded xml/libxml" if $VERBOSE
+          ################################################################
+          # IMPORTANT!
+          # This magic line makes the parser behave like it ought to!!
+          XML::Parser.default_keep_blanks = false
+          ################################################################
+        end
+      rescue LoadError
+      end
+    end
+    @done_once = true
+  end
+
+  # returns an array of strings depending on File_required (in the order of
+  # Parser_precedence)
+  def self.available_xml_parsers
+    require_parsers  
+    parser_precedence = Parser_precedence.dup
+    File_required.map do |k,v|
+      unless $".any? {|req_file| req_file.match(v) }
+        parser_precedence.delete(k) 
+      end
+    end
+    parser_precedence
+  end
+
+  ## appends downcase to each parser type here and tries to require it
+  # returns all those that were required without a load error
+  def self.require_parse_files(base_dir)
+    XMLStyleParser.available_xml_parsers.select do |v| 
+      to_require = base_dir + '/' + v.downcase
+      begin 
+        require to_require
+        true
+      rescue LoadError
+        false
+      end
+    end
+  end
+
+  # seeks a subclass that has the public_method @method
+  def self.choose_parser(const, method)
+    ## First update @@parser_precedence to ensure we should get these guys
+    parser_precedence = available_xml_parsers
+
+    available_constants = parser_precedence.select do |v| 
+      const.const_defined?(v)
+    end
+    available_subclasses = available_constants.map do |v|
+      const.const_get(v)
+    end
+    available = available_subclasses.select do |subclass|
+      subclass.public_method_defined? method
+    end
+    if available.size > 0
+      available.first
+    else
+      raise NoMethodError, "No parser of class #{const} can parse :#{method}\n** Is 'axml' (or another xml parser) installed and working? **"
+    end
+  end
+
+end

data/lib/xmlparser_wrapper.rb

@@ -0,0 +1,19 @@
+
+
+module XMLParserWrapper
+  def parse_and_report(file, const, report_method=:report)
+    parse_and_report_string(IO.read(file), const, report_method)
+  end
+
+  def parse_and_report_string(string, const, report_method=:report)
+    parser = self.class.const_get(const).new
+    parser.parse(string)
+    parser.send(report_method)
+  end
+
+  def parse_and_report_io(io, const, report_method=:report) 
+    parser = self.class.const_get(const).new
+    parser.parse(io)
+    parser.send(report_method)
+  end
+end

data/script/compile_and_plot_smriti_final.rb

@@ -0,0 +1,97 @@
+#!/usr/bin/ruby -w
+
+
+require 'roc'
+require 'optparse'
+require 'generator'
+
+$decoy = false
+$base = "precision_vs_numhits"
+
+opts = OptionParser.new do |op|
+  op.banner = "usage: #{File.basename(__FILE__)} smriti.csv ..."
+  op.separator ""
+  op.separator "smriti.csv = (tab delimited) prob, file:seq:charge, T/F"
+  op.separator ""
+  op.on("--decoy", "'F' indicates this is a decoy") {|v| $decoy = true }
+  op.on("-o", "--outfile <filename>", "base outfile name (#{$base})") {|v| $base = v}
+end
+
+opts.parse!
+
+if ARGV.size <= 0
+  puts opts
+  exit
+end
+
+files = ARGV.to_a
+
+xys = files.map do |file|
+  triplets = IO.readlines(file).reject{|v| v =~ /^#/}.map do |line|
+    line.chomp.split("\t")
+  end
+
+  # check that they're all OK:
+  triplets.each do |trip|
+    if trip.size != 3 ; abort "bad triplet" end
+  end
+
+  # figure out the ordering (and correct if necessary):
+  higher_better = triplets[0][0].to_f > triplets.last[0].to_f
+
+  doublets = triplets.map do |trip|
+    value = trip[0].to_f
+    value *= -1 if higher_better
+    [value, ((trip[2] == 'T') ? true : false)]
+  end
+
+  roc = ROC.new
+
+  (tps, fps) = roc.doublets_to_separate(doublets)
+
+  (x, y) = 
+    if $decoy
+      (numhits, precision) = DecoyROC.new.pred_and_ppv(tps, fps)
+      [numhits, precision]
+    else
+      (numhits, precision) = roc.numhits_and_ppv(doublets)
+      [numhits, precision]
+    end
+  [x,y]
+
+end
+
+
+## PLOT TO to_plot
+File.open( $base + ".to_plot", 'w') do |fh|
+  fh.puts "XYData"
+  fh.puts $base
+  fh.puts "precision vs. num hits"
+  fh.puts "num hits"
+  fh.puts "precision"
+  files.zip(xys) do |file,xy|
+    (x,y) = xy
+    x.unshift(0)
+    y.unshift(1)
+    fh.puts file.sub(/\.[^\.]$/,'')
+    fh.puts x.join(" ")
+    fh.puts y.join(" ")
+  end
+end
+
+File.open( $base + ".csv", 'w') do |fh|
+  columns = []
+  files.zip(xys) do |file,xy|
+    f = file.sub(/\.[^\.]$/,'')
+    (x,y) = xy
+    x.unshift("#Hits: #{f}")
+    y.unshift("Precision: #{f}")
+    columns << x << y
+  end
+  SyncEnumerator.new(*columns).each do |row|
+    fh.puts row.join("\t")
+  end
+end
+
+
+

data/script/extract_gradient_programs.rb

@@ -0,0 +1,56 @@
+#!/usr/bin/ruby
+
+require 'optparse'
+require 'table'
+
+require 'spec/gradient_program'
+
+delimiter = "\t"
+table_format = false
+opts = OptionParser.new do |op|
+  op.banner = "#{File.basename(__FILE__)} [OPTIONS] <file>.meth"
+  op.on("-d", "--delimiter <tab|space|format>", "delimiter (tab default)", "format = space delimited, formatted ascii table") do |v|
+    if v == 'space'
+      delimiter = " "
+    elsif v == 'tab'
+      delimiter = "\t"
+    elsif v == 'format'
+      table_format = true
+    else
+      abort "don't recognize #{v}"
+    end
+  end
+end
+
+opts.parse!
+
+if ARGV.size == 0
+  puts opts
+  exit
+end
+
+
+sets_of_tables = {}
+ARGV.each do |file|
+  File.open(file) do |fh|
+    sets_of_tables[file] = GradientProgram.all_from_handle(fh)
+  end
+end
+
+sets_of_tables.each do |file, tables|
+  puts "FILE: #{file}"
+  tables.each do |gp|
+    puts "PUMP_TYPE: #{gp.pump_type}"
+    col_labels = ["time(min)", "%A", "%B", "%C", "%D", "ul/min"]
+    data = gp.time_points.map do |tp|
+      line = [tp.time, *(tp.percentages)]
+      line << tp.flow_rate
+    end
+    table = Table.new(data, nil, col_labels)
+    if table_format
+      puts table.to_formatted_string
+    else
+      puts table.to_s(delimiter)
+    end
+  end
+end

data/script/get_apex_values_rexml.rb

@@ -0,0 +1,44 @@
+#!/usr/bin/ruby
+
+require 'rexml/document'
+
+if ARGV.size == 0
+  puts "usage: #{File.basename(__FILE__)} <file>-prot.xml ..."
+  puts "outputs a .csv file"
+  exit
+end
+
+class Protein
+  attr_accessor :name, :pi, :ni
+  def initialize(name, pi, ni)
+    @name, @pi, @ni = name, pi, ni
+  end
+end
+
+class Listener
+  attr_accessor :proteins
+
+  def initialize
+    @proteins = []
+  end
+
+  def tag_start(name, attrs)
+    if name == "protein" 
+      protein = Protein.new( attrs['protein_name'], attrs['probability'].to_f, attrs['total_number_peptides'].to_i) 
+      @proteins.push( protein )
+    end
+  end
+
+  def method_missing(*args) ; end
+
+end
+
+ARGV.each do |file|
+  File.open("output.csv", 'w') do |out|
+    listener = Listener.new
+    REXML::Document.parse_stream(File.new(file), listener)
+    listener.proteins.sort_by {|prot| [prot.pi, prot.ni, prot.name] }.reverse.each do |protein|
+      out.puts [protein.name, protein.pi, protein.ni].join("\t")
+    end
+  end
+end

data/script/mzXML2timeIndex.rb

@@ -18,7 +18,7 @@ end
 ARGV.each do |file|
   puts "READING: " + file
   outfile = file + '.timeIndex'
-  obj = Spec::MSRunIndex.new(file)
+  obj = MS::MSRunIndex.new(file)
   puts "WRITING: " + outfile
   obj.to_index_file(outfile)
 end

data/script/smriti_final_analysis.rb

@@ -0,0 +1,103 @@
+#!/usr/bin/ruby -w
+
+require 'spec_id'
+require 'fasta'
+require 'optparse'
+
+$top = false
+opts = OptionParser.new do |op|
+  op.banner = "usage: #{File.basename(__FILE__)} bioworks.xml <file>.fasta|prefix"
+  op.separator "outputs stdout (tab del sorted by probability) probability, file:aaseq:charge T/F"
+  op.separator "hashes on file+aaseq+charge"
+  op.on("-t", "--top", "only top peptide (by prob) per scan+charge") do
+    $top = true
+  end
+end
+
+opts.parse!
+
+if ARGV.size < 2
+  puts opts.to_s  
+  exit
+end
+
+specid_file = ARGV.shift
+file_or_prefix = ARGV.shift
+
+specid = SpecID.new(specid_file)
+
+indicator = 
+  if File.exist? file_or_prefix
+    Fasta.new.read_file(file_or_prefix)
+  else
+    file_or_prefix
+  end
+
+
+# returns an array containing the min prob peptides (in case of a tie)
+def lowest_peps(ar)
+  min_prob = ar.min {|a,b| a.probability.to_f <=> b.probability.to_f }.probability.to_f
+  ar.select {|v| v.probability.to_f == min_prob }
+end
+
+peps = specid.peps
+if $top
+  top_by_scan = []
+  peps.hash_by(:base_name, :first_scan).each do |k,v|
+    low_peps = lowest_peps(v)
+    top_by_scan.push( *low_peps )
+  end
+end
+
+results = top_by_scan.hash_by(:base_name, :aaseq, :charge).map do |k,v|
+  low_peps = lowest_peps(v)
+  #min_pep = v.min {|a,b| a.probability.to_f <=> b.probability.to_f }
+  all_prots = []
+  low_peps.each do |pep|
+    all_prot_references.push( *(pep.prots.map {|v| v.reference }) )
+  end
+  all_prot_references.uniq!
+  is_true =
+    if indicator.is_a? Fasta
+      all_prot_references.any? do |ref|
+        indicator.included_in_header?(ref)
+      end
+    else
+      !(all_prot_references.all? {|ref| ref.include?( indicator )})
+    end
+  [min_pep.probability.to_f, k, is_true]
+end
+
+results.sort.each do |result|
+  report = [result[0], result[1].join(':'), (result[2] ? 'T' : 'F')]
+  puts report.join("\t")
+end
+
+=begin
+# ORIGINAL CODE
+peps = specid.peps
+if $top
+  peps = peps.hash_by(:base_name, :first_scan).map do |k,v|
+    v.min {|a,b| a.probability.to_f <=> b.probability.to_f } 
+  end
+end
+
+results = peps.hash_by(:base_name, :aaseq, :charge).map do |k,v|
+  min_pep = v.min {|a,b| a.probability.to_f <=> b.probability.to_f }
+  references = min_pep.prots.map {|v| v.reference }.uniq
+  is_true =
+    if indicator.is_a? Fasta
+      references.any? do |ref|
+        indicator.included_in_header?(ref)
+      end
+    else
+      !(references.all? {|ref| ref.include?( indicator )})
+    end
+  [min_pep.probability.to_f, k, is_true]
+end
+
+results.sort.each do |result|
+  report = [result[0], result[1].join(':'), (result[2] ? 'T' : 'F')]
+  puts report.join("\t")
+end
+=end