mspire 0.2.4 → 0.3.0

data/lib/ms/parser.rb

@@ -0,0 +1,108 @@
+require 'xml_style_parser'
+
+module MS; end
+
+module MS::Parser
+  # inherits attr_accessor :method, :default_parser, and parse (which should
+  # be overridden)
+  include XMLStyleParser 
+
+  Mzxml_regexp = /http:\/\/sashimi.sourceforge.net\/schema(_revision)?\/([\w\d_\.]+)/o
+  # 'http://sashimi.sourceforge.net/schema/MsXML.xsd' # version 1
+  # 'http://sashimi.sourceforge.net/schema_revision/mzXML_X.X' # others
+  Mzdata_regexp = /<mzData.*version="([\d\.]+)"/m
+
+  attr_accessor :version
+
+  ############################################
+  # POINTERS (to create META MAGIC)
+  ############################################
+  
+  @@filetypes_to_upcase = {
+    :mzxml => 'MzXML',
+    :mzdata => 'MzData',
+    :mzml => 'MzML',
+    :raw => 'Raw',
+  }
+
+  @@filetypes_to_require = {}
+  @@filetypes_to_constant = {}
+
+  abbrevs = Dir.chdir(File.dirname(__FILE__) + "/parser") do
+    Dir["*.rb"].map {|f| f.sub(/\.rb$/,'') }
+  end
+  abbrevs.each do |abbr|
+    abb = abbr.to_sym
+    req = ['ms', 'parser', abbr].join("/")
+    @@filetypes_to_require[abb] = req
+    @@filetypes_to_constant[abb] = ['MS', 'Parser', @@filetypes_to_upcase[abb]].join("::")
+  end
+
+  ############################################
+  # END POINTERS
+  ############################################
+
+  # finds the filetype of a file (expects to be at the beginning) and rewinds
+  # the filehandle to the beginning returns [filetype, version].  nil if
+  # filetype and version could not be determined
+  def self.filetype_and_version(fh_or_filename)
+    if fh_or_filename.is_a? IO
+      fh = fh_or_filename
+      found = nil
+      # Test for RAW file:
+      header = fh.read(18).unpack('@2axaxaxaxaxaxaxa').join
+      if header == 'Finnigan'
+        return [:raw, nil]
+      end
+      fh.rewind
+      while (line = fh.gets)
+        found = 
+          case line
+          when Mzxml_regexp
+            mtch = $2.dup
+            case mtch
+            when /mzXML_([\d\.]+)/
+              [:mzxml, $1.dup]
+            when /MsXML/
+              [:mzxml, '1.0']
+            else
+              abort "Cannot determine mzXML version!"
+            end
+          when Mzdata_regexp
+            [:mzdata, $1.dup]
+          end
+        if found
+          break
+        end
+      end
+      fh.rewind
+      found
+    else
+      File.open(fh_or_filename) do |fh|
+        filetype_and_version(fh)
+      end
+    end
+  end
+
+  # filetype_version is an example file to parse, or it is an array: [type, version].
+  # parse_type is the information to be gleaned (as symbol).
+  def self.new(filetype_version, parse_type)
+    unless filetype_version.is_a? Array
+      filetype_version = filetype_and_version(filetype_version)
+    end
+    require_and_create_parser(filetype_version, parse_type)
+  end
+
+  private 
+
+  # returns a working parser.
+  def self.require_and_create_parser(filetype_version, parse_type)
+    (filetype, version) = filetype_version
+    #puts "FT: #{filetype} VERSION: #{version}"
+    reply = require @@filetypes_to_require[filetype]
+    @@filetypes_to_require[filetype]
+    parser_class = MS::Parser.const_get(@@filetypes_to_upcase[filetype])
+    parser_class.new(parse_type, version)
+  end
+
+end

data/lib/ms/precursor.rb

@@ -0,0 +1,10 @@
+require 'array_class'
+
+module MS; end 
+
+# parent == spectrumRef references a scan
+#                                   0  1     2      3        4 
+MS::Precursor = ArrayClass.new(%w(mz intensity parent ms_level charge_states)) 
+
+class MS::Precursor
+end

data/lib/ms/scan.rb

@@ -0,0 +1,81 @@
+require 'array_class'
+require 'ms/precursor'
+
+module MS ; end
+
+#                               0   1        2    3        4      5          6 
+MS::Scan = ArrayClass.new( %w(num ms_level time start_mz end_mz precursors spectrum) )
+
+# time in seconds
+# everything else in float/int or as array (precursors)
+
+class MS::Scan
+  #@@order = %w(num ms_level time start_mz end_mz prec_mz prec_inten parent spectrum)
+  #attr_accessor :num, :ms_level, :time, :start_mz, :end_mz, :prec_mz, :prec_inten, :parent, :spectrum
+
+  #def initialize(ar=nil)
+  # @@order.zip(ar) do |x,v|
+  #   send((x+'=').to_sym, v)
+  # end
+  #end
+
+  def to_s
+    "<Scan num=#{num} ms_level=#{ms_level} time=#{time}>"
+  end
+
+  undef_method :inspect
+  def inspect
+    atts = %w(num ms_level time start_mz end_mz) 
+    display = atts.map do |att|
+      if val = send(att.to_sym)
+        "@#{att}=#{val}"
+      else
+        nil
+      end
+    end
+    display.compact!
+    spec_display = 
+      if spectrum
+        spectrum.mz.size
+      else
+        nil
+      end
+    "<MS::Scan:#{__id__} " + display.join(", ") + "@precursors=#{precursors.inspect}" + "@spectrum=size:#{spec_display}" + ">"
+  end
+
+  # returns the string (space delimited): "ms_level num time [prec_mz prec_inten]"
+  def to_index_file_string
+    arr = [ms_level, num, time]
+    if precursors then arr << precursors.first.mz end
+    if x = precursors.first.inten then arr << x end
+    arr.join(" ")
+  end
+
+  # adds the attribute parent to each scan with a parent
+  # (level 1 = no parent; level 2 = prev level 1, etc.
+  def self.add_parent_scan(scans)
+    prev_scan = nil
+    parent_stack = [nil]
+    ## we want to set the level to be the first mslevel we come to
+    prev_level = 1
+    scans.each do |scan|
+      if scan then prev_level = scan.ms_level; break; end
+    end
+    scans.each do |scan|
+      next unless scan  ## the first one is nil, (others?)
+      level = scan.ms_level
+      if prev_level < level
+        parent_stack.unshift prev_scan
+      end
+      if prev_level > level
+        (prev_level - level).times do parent_stack.shift end
+      end
+      scan.parent = parent_stack.first
+      prev_level = level
+      prev_scan = scan
+    end
+  end
+
+end
+
+

data/lib/ms/spectrum.rb

@@ -0,0 +1,193 @@
+require 'base64'
+require 'bsearch'
+require 'ms'
+
+class MS::Spectrum
+
+  Unpack_network_float = 'g*'
+  Unpack_network_double = 'G*'
+  Unpack_little_endian_float = 'e*'
+  Unpack_little_endian_double = 'E*'
+
+  # m/z's
+  attr_accessor :mz  
+  # intensities
+  attr_accessor :intensity
+
+  def initialize(mz=[], intensity=[])
+    @mz = mz
+    @intensity = intensity
+  end
+
+
+  def has_mz_data?
+    (@mz.size > 0) && (@mz.first.is_a?(Numeric))
+  end
+
+  def has_intensity_data?
+    (@intensity.size > 0) && (@intensity.first.is_a?(Numeric))
+  end
+
+  # takes a base64 string and returns an array
+  def self.base64_to_array(string, precision=32, network_order=true)
+    b64d = Base64.decode64(string) 
+    unpack_code = 
+      if network_order
+        if precision == 32
+          Unpack_network_float
+        elsif precision == 64
+          Unpack_network_double
+        end
+      else ## little endian
+        if precision == 32
+          Unpack_little_endian_float
+        elsif precision == 64
+          Unpack_little_endian_double
+        end
+      end
+    b64d.unpack(unpack_code)
+  end
+
+  def self.from_base64_pair(mz_string, mz_precision, mz_network_order, inten_string, inten_precision, inten_network_order)
+    mz = base64_to_array(mz_string, mz_precision, mz_network_order)
+    inten = base64_to_array(inten_string, inten_precision, inten_network_order)
+    self.new(mz, inten)
+  end
+
+  # takes a base64 peaks string and sets spectrum
+  # returns self for chaining
+  def self.from_base64_peaks(string, precision=32, network_order=true)
+    data = base64_to_array(string, precision, network_order)
+    sz = data.size/2
+    mz = Array.new(sz)
+    intensity = Array.new(sz)
+    ndata = []
+    my_ind = 0
+    data.each_with_index do |dat,ind|
+      if (ind % 2) == 0  # even
+        mz[my_ind] = dat
+      else
+        intensity[my_ind] = dat 
+        my_ind += 1
+      end
+    end
+    self.new(mz, intensity)
+  end
+
+
+
+
+  ######
+  # NOT REALLY USING RIGHT NOW:
+  ######
+
+  # takes a base64 peaks string and returns an array of [m/z,intens] doublets
+  # mzXML as network ordered
+  def base64_peaks_to_pairs(string, precision=32)
+    data = base64_peaks_to_array(string, precision)
+    ndata = []
+    data.each_with_index do |dat,ind|
+      if (ind % 2) == 0  # even
+        arr = Array.new(2)
+        arr[0] = dat
+        ndata.push( arr )
+      else
+        ndata.last[1] = dat 
+      end
+    end
+    ndata
+  end
+
+  # returns the index of the first value matching that m/z.  the argument m/z
+  # may be less precise than the actual m/z (rounding to the same precision
+  # given) but must be at least integer precision (after rounding)
+  # implemented as binary search (bsearch from the web)
+  def index(mz)
+    return_val = nil
+    ind = @mz.bsearch_lower_boundary{|x| x <=> mz }
+    if @mz[ind] == mz
+      return_val = ind
+    else 
+      # do a rounding game to see which one is it, or nil
+      # find all the values rounding to the same integer in the locale
+      # test each one fully in turn
+      mz = mz.to_f
+      mz_size = @mz.size
+      if ((ind < mz_size) and equal_after_rounding?(@mz[ind], mz))
+        return_val = ind
+      else # run the loop
+        up = ind
+        loop do
+          up += 1
+          if up >= mz_size
+            break
+          end
+          mz_up = @mz[up]
+          if (mz_up.ceil  - mz.ceil >= 2)
+            break
+          else
+            if equal_after_rounding?(mz_up, mz)
+              return_val = up
+              return return_val
+            end
+          end
+        end
+        dn= ind
+        loop do
+          dn -= 1
+          if dn < 0
+            break
+          end
+          mz_dn = @mz[dn]
+          if (mz.floor - mz_dn.floor >= 2)
+            break
+          else
+            if equal_after_rounding?(mz_dn, mz)
+              return_val = dn
+              return return_val
+            end
+          end
+        end
+      end
+    end
+    return_val
+  end
+  
+  # uses index function and returns the intensity at that value
+  def intensity_at_mz(mz)
+    if x = index(mz)
+      @intensity[x]
+    else
+      nil
+    end
+  end
+
+  # less_precise should be a float
+  # precise should be a float
+  def equal_after_rounding?(precise, less_precise)
+    # determine the precision of less_precise
+    exp10 = precision_as_neg_int(less_precise)
+    #puts "EXP10: #{exp10}"
+    answ = ((precise*exp10).round == (less_precise*exp10).round)
+    #puts "TESTING FOR EQUAL: #{precise} #{less_precise}"
+    #puts answ
+    (precise*exp10).round == (less_precise*exp10).round
+  end
+
+  # returns 1 for ones place, 10 for tenths, 100 for hundredths
+  # to a precision exceeding 1e-6
+  def precision_as_neg_int(float)
+    neg_exp10 = 1
+    loop do
+      over = float * neg_exp10
+      rounded = over.round
+      if (over - rounded).abs <= 1e-6
+        break
+      end
+      neg_exp10 *= 10
+    end
+    neg_exp10
+  end
+
+end
+

data/lib/ms.rb

@@ -0,0 +1,10 @@
+
+
+module MS
+  attr_accessor :spectra
+
+  # should
+  def new(file=nil)
+  end
+
+end

data/lib/mspire.rb

@@ -0,0 +1,4 @@
+
+module Mspire
+  Version = '0.3.0'
+end

data/lib/roc.rb

@@ -42,10 +42,19 @@ class ROC
     area
   end
 
+  # takes two lists of values and makes doublets [[val, boolean],...]
+  def separate_to_doublets(tps, fps)
+    true_doublets = tps.map {|v| [v, 0] }
+    false_doublets = fps.map {|v| [v, 1] }
+    all_doublets = true_doublets + false_doublets
+    all_doublets.sort!
+    all_doublets.map {|v| ((v[1] == 0) ? [v[0], true] : [v[0], false]) }
+  end
+
   # given an array of doublets where each doublet is a value and a boolean,
   # sorts the list and divides it into two arrays (tps, fps) of the values.
   # The output can then be fed into many of the other routines.
-  def prep_list(list)
+  def doublets_to_separate(list)
     tp = []; fp = []
     list.each do |dbl|
       if dbl[1]
@@ -85,6 +94,27 @@ class ROC
     end
     return x, y
   end
+
+  # takes previously sorted doublets [value, boolean] 
+  def numhits_and_ppv(doublets)
+    x = []
+    y = []
+    tps = 0
+    fps = 0
+    doublets.each_with_index do |d,i|
+      if d[1] ; tps += 1
+      else ; fps += 1 end
+
+      if (i+1 == doublets.size) || (d[0] != doublets[i+1][0])
+        num_hits = tps + fps
+        x << num_hits
+        y <<  tps.to_f/num_hits
+      end
+    end
+    [x, y]
+  end
+
+
 end
 
 # For calculating precision given lists of hits and decoy hits.  The hits are
@@ -124,4 +154,34 @@ class DecoyROC < ROC
     [num_hits_ar, num_tps_ar, ppv_ar]
   end
 
+  # returns [num_hits, precision] as a function of num hits.  decoy hits are
+  # seen merely as indicators of the number of false hits in the dataset.
+  # This is the same algorithm as pred_and_tps_and_ppv, just eliminates
+  # uneeded calcs
+  def pred_and_ppv(hits, decoy_hits)
+    hits_i = 0
+    decoy_i = 0
+
+    num_hits_ar = []
+    ppv_ar = []
+
+    while hits_i < hits.size
+      while decoy_i < decoy_hits.size && hits[hits_i] >= decoy_hits[decoy_i]
+        decoy_i += 1
+      end
+      unless hits[hits_i] == hits[hits_i+1]
+        ## determine the number of false positives
+        tot_num_hits = hits_i+1
+        num_tps = tot_num_hits - decoy_i
+
+        num_hits_ar << tot_num_hits
+        ppv_ar << ( num_tps.to_f/tot_num_hits )
+
+      end
+      hits_i += 1 
+    end
+    [num_hits_ar, ppv_ar]
+
+  end
+
 end

data/lib/sample_enzyme.rb

@@ -1,9 +1,12 @@
 
 module SpecIDXML; end
 
-require 'spec_id_xml'
 require 'strscan'
 
+require 'spec_id_xml'
+require 'spec_id'
+
+
 class SampleEnzyme
   include SpecIDXML
 
@@ -18,6 +21,7 @@ class SampleEnzyme
   # Currently, recognize: 
   #   trypsin
   # For other enzymes, you must set :cut, :no_cut, :name, and :sense
+  # will yield the object if you want to set the values that way
   def initialize(name=nil)
     @sense = nil
     @cut = nil
@@ -25,11 +29,14 @@ class SampleEnzyme
     @name = name
     if @name
       # set the values if we recognize this name
-      send(@name.to_sym)
+      send("set_#{@name}".to_sym)
+    end
+    if block_given?
+      yield(self)
     end
   end
 
-  def trypsin
+  def set_trypsin
     @sense = 'C'
     @cut = 'KR'
     @no_cut = 'P'
@@ -41,10 +48,26 @@ class SampleEnzyme
     end
   end
 
+  # returns self
+  def from_pepxml_node(node)
+    self.name = node['name']
+    ch = node.child
+    self.cut = ch['cut']
+    self.no_cut= ch['no_cut']
+    self.sense = ch['sense']
+    self
+  end
+
+  def self.from_pepxml_node(node)
+    self.new.from_pepxml_node(node)
+  end
+
   # returns all peptides of missed cleavages <= 'missed_cleavages'
   # so 2 missed cleavages will return all no missed cleavage peptides
   # all 1 missed cleavages and all 2 missed cleavages.
-  def digest(string, missed_cleavages=0)
+  # options:
+  def digest(string, missed_cleavages=0, options={})
+    raise NotImplementedError if @sense == 'N'
     s = StringScanner.new(string)
     no_cut_regex = Regexp.new("[#{@no_cut}]")
     regex = Regexp.new("[#{@cut}]")
@@ -75,7 +98,7 @@ class SampleEnzyme
     end
     ## LOOP through and grab each set of missed cleavages from num down to 0
     all_sets_of_peps = []
-    (0..missed_cleavages).to_a.reverse.map do |num_mc|
+    (0..missed_cleavages).to_a.reverse.each do |num_mc|
       all_sets_of_peps.push( *(get_missed_cleavages(peps, num_mc)) )
     end
     all_sets_of_peps 
@@ -85,9 +108,9 @@ class SampleEnzyme
   # cleavages
   # DOES NOT contain peptides that contain < num of missed cleavages
   # (i.e., will not return missed cleaveages of 1 or 2 if num == 3
-  def get_missed_cleavages(tryptic_peps, num)
-    (0...(tryptic_peps.size - num)).to_a.map do |i|
-      tryptic_peps[i,num+1].join
+  def get_missed_cleavages(ar_of_peptide_seqs, num)
+    (0...(ar_of_peptide_seqs.size - num)).to_a.map do |i|
+      ar_of_peptide_seqs[i,num+1].join
     end
   end
 

data/lib/scan_i.rb

@@ -0,0 +1,21 @@
+
+# http://groups.google.com/group/comp.lang.ruby/browse_thread/thread/7370f94e852c0fae/4068c8c1c1c158ee
+class String
+  def scan_i seq
+    pos=0
+    ndx=[]
+    slen = seq.length
+    while i=index(seq,pos)
+      ndx << i
+      pos = i + slen
+    end
+    ndx
+  end
+
+  #def scan_enum seq
+  #  self.enum_for(:scan, seq).map do 
+  #    $~.offset(0)[0]
+  #  end
+  #end
+end
+

data/lib/spec_id/aa_freqs.rb

@@ -9,9 +9,10 @@ class SpecID::AAFreqs
   # seeing that amino acid.  Frequencies should add to 1.
   attr_accessor :aafreqs
 
-  def initialize(fasta_file=nil)
-    if fasta_file
-      @fasta = Fasta.new.read_file(fasta_file)      
+  # fasta is fasta object!
+  def initialize(fasta=nil)
+    @fasta = fasta
+    if @fasta
       @aafreqs = calculate_frequencies(@fasta)
     end
   end
@@ -64,6 +65,9 @@ class SpecID::AAFreqs
   # returns two numbers in array [actual, expected]
   # expected is a Float!!!
   def actual_and_expected_number(peptide_aaseqs, amino_acid=:C, at_least=1)
+    if at_least > 1
+      raise NotImplementedError, "can only do at_least=1 right now!"
+    end
     one_minus_freq = 1.0 - @aafreqs[amino_acid.to_sym]
     amino_acid_as_st = amino_acid.to_s
     probs = []