mspire 0.4.9 → 0.5.0

data/lib/validator.rb

@@ -1,197 +0,0 @@
-
-class Validator
-
-  # in the absence of digestion, does the spec_id type requires pephits for
-  # validation?
-  def self.requires_pephits?(spec_id_obj)
-    case spec_id_obj
-    when Proph::ProtSummary : true
-    when Proph::PepSummary : true
-    when SQTGroup : true
-    else ; false
-    end
-  end
-
-  Validator_to_string = {
-    'Validator::AA' => 'badAA',
-    'Validator::AAEst' => 'badAAEst',
-    'Validator::Decoy' => 'decoy',
-    'Validator::Transmem::Protein' => 'tmm',
-    'Validator::TruePos' => 'tps',
-    'Validator::Bias' => 'bias',
-    'Validator::Probability' => 'prob',
-    'Validator::QValue' => 'qval',
-    :bad_aa => 'badAA',
-    :bad_aa_est => 'badAAEst',
-    :decoy => 'decoy',
-    :tmm => 'tmm',
-    :tps => 'tps',
-    :bias => 'bias',
-    :prob => 'prob',
-    :qval => 'qval',
-  }
-
-  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::AAEst
-        %w(frequency background calculated_background).each do |cat|
-          hash[cat.to_sym] = val.send(cat.to_sym)
-        end
-      when Validator::AA
-        %w(false_to_total_ratio background calculated_background).each do |cat|
-          hash[cat.to_sym] = val.send(cat.to_sym)
-        end
-      when Validator::Decoy
-        %w(pi_zero 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
-      when Validator::QValue
-        # no params to add
-      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
-
-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, frit=1.0)
-    # 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_f - (num_decoy.to_f * frit)
-    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/aa_est'
-#require 'validator/bias'
-#require 'validator/decoy'
-#require 'validator/transmem'
-#require 'validator/probability'
-#require 'validator/q_value'
-#require 'validator/prot_from_pep'
-

data/lib/xml.rb

@@ -1,38 +0,0 @@
-
-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

@@ -1,119 +0,0 @@
-
-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, special_subclass=nil)
-    ## 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 special_subclass
-      available_special_subclasses = []
-      available.each do |subclass|
-        if subclass.const_defined?(special_subclass)
-          available_special_subclasses << subclass.const_get(special_subclass)
-        end
-      end
-      available = available_special_subclasses
-    end
-    if available.size > 0
-      available.first
-    else
-      warning = ""
-      if special_subclass
-        warning << "** while looking for special subclass: #{special_subclass} **\n"
-      end
-      warning << "No parser of class #{const} can parse :#{method}\n** Is 'axml' (or another xml parser) installed and working? **"
-      raise NoMethodError, warning
-    end
-  end
-
-end

data/lib/xmlparser_wrapper.rb

@@ -1,19 +0,0 @@
-
-
-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/release_notes.txt

@@ -1,2 +0,0 @@
-
-

data/script/compile_and_plot_smriti_final.rb

@@ -1,97 +0,0 @@
-#!/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/create_little_pepxml.rb

@@ -1,61 +0,0 @@
-#!/usr/bin/ruby -w
-
-
-if ARGV.size < 2
-  puts "usage: #{File.basename(__FILE__)} protxml pepxml"
-  puts "Based on some kind of truncated prot xml file, takes a pepxml file"
-  puts "and deletes all search hits/peptides that aren't in the prot xml file!"
-  exit
-end
-
-protxml = ARGV[0]
-pepxml = ARGV[1]
-
-hash = {}
-File.open(protxml) do |fh|
-  while line = fh.gets
-    if line =~ /peptide_sequence="(.*?)" charge="(\d)" /
-      hash[[$1.dup,$2.dup]] = 1
-    end
-  end
-end
-
-p hash
-
-out = File.open(pepxml + ".small", "w")
-
-in_hit = false
-cur_charge = nil
-stored_lines = ""
-print_it = false
-File.open(pepxml) do |fh|
-  while line = fh.gets
-    if line =~ /<search_result .*? assumed_charge="(\d)".*?>/
-      cur_charge = $1.dup
-      in_hit = true
-    end
-    if line =~ /<search_hit .*? peptide="(.*?)"/
-      if hash.key?([$1.dup,cur_charge])
-        print_it = true
-      else
-        print_it = false
-      end
-    end
-    if line =~ /<\/search_result>/
-      if print_it == true
-        stored_lines << line
-        out.print stored_lines
-      end
-      stored_lines = ""
-      in_hit == false
-    elsif !in_hit
-      out.print line
-    else
-      stored_lines << line
-    end
-  end
-
-
-end
-
-out.close

data/script/degenerate_peptides.rb

@@ -1,47 +0,0 @@
-#!/usr/bin/ruby -w
-
-require 'fasta'
-require 'sample_enzyme'
-
-if ARGV.size < 3
-  puts "usage: #{File.basename(__FILE__)} min_peptide_length missed_cleavages <file>.fasta ..."
-  puts "       returns <file>.min_pep_length_<#>.missed_cleavages_<#>.degenerate_peptides.csv"
-  abort
-end
-
-
-
-min_peptide_length = ARGV.shift.to_i
-missed_cleavages = ARGV.shift.to_i
-
-ARGV.each do |file|
-  hash = {}
-
-  if file !~ /\.fasta/
-    abort "must be a fasta file with extension fasta"
-  end
-  new_filename = file.sub(/\.fasta$/, '')
-  new_filename << ".min_pep_length_#{min_peptide_length}.missed_cleavages_#{missed_cleavages}.degenerate_peptides.csv"
-  peptides = []
-  Fasta.new.read_file(file).prots.each do |prot|
-
-
-    SampleEnzyme.tryptic(prot.aaseq, missed_cleavages).each do |aaseq|
-      if aaseq.size >= min_peptide_length
-        hash[aaseq] ||= []
-        hash[aaseq].push( prot.header.sub(/^>/,'') )
-      end
-    end
-    #fh.puts( prot.header.split(/\s+/).first.sub(/^>/,'') + "\t" + SampleEnzyme.tryptic(prot.aaseq, missed_cleavages).join(" ") )
-  end
-
-  File.open(new_filename, "w") do |fh|
-    hash.keys.sort_by {|pep| hash[pep].size }.reverse.each do |pep|
-      fh.puts( [pep, *(hash[pep])].join("\t") )
-    end     
-  end
-end
-
-
-
-