mspire 0.3.1 → 0.3.9

data/lib/spec_id/sqt.rb

@@ -0,0 +1,349 @@
+require 'spec_id'
+require 'array_class'
+require 'set'
+
+class SQTGroup
+  include SpecID   # inherits prots and peps accessors
+
+  attr_accessor :sqts, :filenames
+
+  # if filenames is a String, then it should be a filename to a file ending in
+  # '.sqg' (meta text file with list of .sqt files) else it should be an array
+  # of sqt filenames
+  def initialize(filenames=nil)
+    @filenames = filenames
+    @prots = []
+    @peps = []
+    @sqts = []
+
+    global_ref_hash = {}
+    ## This is duplicated in SRFGroup (should refactor eventually)
+    if filenames
+      if filenames.is_a?(String) && filenames =~ /\.sqg$/
+        srg_filename = filenames.dup
+        @filename = srg_filename
+        @filenames = IO.readlines(filenames).grep(/\w/).map {|v| v.chomp } 
+        @filenames.each do |file|
+          if !File.exist? file
+            puts "File: #{file} in #{srg_filename} does not exist!"
+            puts "Please modify #{srg_filename} to point to existing files."
+            abort
+          end
+        end
+      end
+      @filenames.each do |file|
+        @sqts << SQT.new(file, @peps, global_ref_hash)
+      end
+
+      @prots = global_ref_hash.values
+    end
+  end
+
+  # NOTE THAT this is copy/paste from srf.rb, should be refactored...
+  # returns the filename used
+  # if the file exists, the name will be expanded to full path, otherwise just
+  # what is given
+  def to_sqg(sqg_filename='bioworks.sqg')
+    File.open(sqg_filename, 'w') do |v|
+      @filenames.each do |sqt_file|
+        if File.exist? sqt_file
+          v.puts File.expand_path(sqt_file)
+        else
+          v.puts sqt_file
+        end
+      end
+    end
+    sqg_filename
+  end
+
+end
+
+class SQT
+  PercolatorHeaderMatch = /^Percolator v/
+  Delimiter = "\t"
+  attr_accessor :header
+  attr_accessor :spectra
+  attr_accessor :base_name
+  # boolean
+  attr_accessor :percolator_results
+
+  def initialize(filename=nil, peps=[], global_ref_hash={})
+    if filename
+      from_file(filename, peps, global_ref_hash)
+    end
+  end
+
+  # if the file contains the header key '/$Percolator v/' then the results
+  # will be interpreted as percolator results
+  def from_file(filename, peps=[], global_ref_hash={}, percolator_results=false)
+    @percolator_results = percolator_results
+    @base_name = File.basename( filename.gsub('\\','/') ).sub(/\.\w+$/, '')
+    File.open(filename) do |fh| 
+      @header = SQT::Header.new.from_handle(fh)
+      if @header.keys.any? {|v| v =~ PercolatorHeaderMatch }
+        @percolator_results = true
+      end
+      @spectra = SQT::Spectrum.spectra_from_handle(fh, @base_name, peps, global_ref_hash, @percolator_results)
+    end
+  end
+
+end
+
+# Inherits from hash, so all header stuff can be accessed by key.  Multiline
+# values will be pushed into an array.
+# All header values are stored as (newline-removed) strings!
+class SQT::Header < Hash
+  Leader = 'H'
+
+  # These will be in arrays no matter what: StaticMod, DynamicMod, Comment
+  # Any other keys repeated will be shoved into an array; otherwise a string
+  Arrayed = %w(DyanmicMod StaticMod Comment).to_set
+
+  HeaderKeys = {
+    :sqt_generator => 'SQTGenerator',
+    :sqt_generator_version => 'SQTGeneratorVersion',
+    :database => 'Database',
+    :fragment_masses => 'FragmentMasses',
+    :precursor_masses => 'PrecursorMasses',
+    :start_time => 'StartTime',
+    :db_seq_length => 'DBSeqLength',
+    :db_locus_count => 'DBLocusCount',
+    :db_md5sum => 'DBMD5Sum',
+    :peptide_mass_tolerance => 'Alg-PreMassTol',
+    :fragment_ion_tolerance => 'Alg-FragMassTol',
+    # nonstandard (mine)
+    :peptide_mass_units => 'Alg-PreMassUnits',
+    :ion_series => 'Alg-IonSeries',
+    :enzyme => 'Alg-Enzyme',
+    # nonstandard (mine)
+    :ms_model => 'Alg-MSModel',
+    :static_mods => 'StaticMod',
+    :dynamic_mods => 'DynamicMod',
+    :comments => 'Comment'
+  }
+
+
+  KeysToAtts = HeaderKeys.invert
+
+  HeaderKeys.keys.each do |ky|
+    attr_accessor ky
+  end
+
+  def from_handle(fh)
+    Arrayed.each do |ky|
+      self[ky] = []
+    end
+    pos = fh.pos 
+    lines = []
+    loop do 
+      line = fh.gets
+      if line && (line[0,1] == SQT::Header::Leader )
+        lines << line
+      else # reset the fh.pos and we're done
+        fh.pos = pos
+        break
+      end
+      pos = fh.pos 
+    end
+    from_lines(lines)
+  end
+
+  def from_lines(array_of_header_lines)
+    array_of_header_lines.each do |line|
+      line.chomp!
+      (ky, *rest) = line.split(SQT::Delimiter)[1..-1]
+      # just in case they have any tabs in their field
+      value = rest.join(SQT::Delimiter)
+      if Arrayed.include?(ky)
+        self[ky] << value
+      elsif self.key? ky  # already exists
+        if self[ky].is_a? Array
+          self[ky] << value
+        else
+          self[ky] = [self[ky], value]
+        end
+      else  # normal
+        self[ky] = value
+      end
+    end
+    KeysToAtts.each do |ky,methd|
+      self.send("#{methd}=".to_sym, self[ky])
+    end
+    self
+  end
+
+end
+
+# all are cast as expected (total_intensity is a float)
+# mh = observed mh
+SQT::Spectrum = ArrayClass.new(%w[first_scan last_scan charge time_to_process node mh total_intensity lowest_sp num_matched_peptides matches])
+
+# 0=first_scan 1=last_scan 2=charge 3=time_to_process 4=node 5=mh 6=total_intensity 7=lowest_sp 8=num_matched_peptides 9=matches
+
+class SQT::Spectrum
+  Leader = 'S'
+
+  # assumes the first line starts with an 'S'
+  def self.spectra_from_handle(fh, base_name, peps=[], global_ref_hash={}, percolator_results=false)
+    spectra = []
+    
+    while line = fh.gets
+      case line[0,1]
+      when SQT::Spectrum::Leader
+        spectrum = SQT::Spectrum.new.from_line( line )
+        spectra << spectrum
+        matches = []
+        spectrum.matches = matches
+      when SQT::Match::Leader
+        match_klass = if percolator_results
+                        SQT::Match::Percolator
+                      else
+                        SQT::Match
+                      end
+        match = match_klass.new.from_line( line )
+        match[10,3] = spectrum[0,3]
+        match[15] = base_name
+        matches << match
+        peps << match
+        loci = []
+        match.loci = loci
+        matches << match
+      when SQT::Locus::Leader
+        line.chomp!
+        key = line.split(SQT::Delimiter)[1]
+        locus =
+          if global_ref_hash.key?(key)
+            global_ref_hash[key]
+          else
+            locus = SQT::Locus.new.from_line( line )
+            locus.peps = []
+            global_ref_hash[key] = locus
+          end
+        locus.peps << match
+        loci << locus
+      end
+    end
+    # set the deltacn:
+    set_deltacn(spectra)
+    spectra
+  end
+
+  def self.set_deltacn(spectra)
+    spectra.each do |spec|
+      matches = spec.matches
+      if matches.size > 0
+
+        (0...(matches.size-1)).each do |i|
+          matches[i].deltacn = matches[i+1].deltacn_orig 
+        end
+        matches[-1].deltacn = 1.1
+      end
+    end
+    spectra
+  end
+
+
+  # returns an array -> [the next spectra line (or nil if eof), spectrum]
+  def from_line(line)
+    line.chomp!
+    ar = line.split(SQT::Delimiter)
+    self[0] = ar[1].to_i
+    self[1] = ar[2].to_i
+    self[2] = ar[3].to_i
+    self[3] = ar[4].to_f
+    self[4] = ar[5]
+    self[5] = ar[6].to_f
+    self[6] = ar[7].to_f
+    self[7] = ar[8].to_f
+    self[8] = ar[9].to_i
+    self[9] = []
+    self
+  end
+end
+
+# SQT format uses only indices 0 - 9
+SQT::Match = ArrayClass.new(%w[rxcorr rsp mh deltacn_orig xcorr sp ions_matched ions_total sequence manual_validation_status first_scan last_scan charge deltacn aaseq base_name loci])
+
+# 0=rxcorr 1=rsp 2=mh 3=deltacn_orig 4=xcorr 5=sp 6=ions_matched 7=ions_total 8=sequence 9=manual_validation_status 10=first_scan 11=last_scan 12=charge 13=deltacn 14=aaseq 15=base_name 16=loci
+
+# rxcorr = rank by xcorr
+# rsp = rank by sp
+# NOTE:
+# deltacn_orig
+# deltacn is the adjusted deltacn (like Bioworks - shift all scores up and
+# give the last one 1.1)
+class SQT::Match
+  include SpecID::Pep
+  Leader = 'M'
+
+  # same as 'loci'
+  def prots
+    self[16]
+  end
+
+  def from_line(line)
+    line.chomp!
+    ar = line.split(SQT::Delimiter)
+    self[0] = ar[1].to_i
+    self[1] = ar[2].to_i
+    self[2] = ar[3].to_f
+    self[3] = ar[4].to_f
+    self[4] = ar[5].to_f
+    self[5] = ar[6].to_f
+    self[6] = ar[7].to_i
+    self[7] = ar[8].to_i
+    self[8] = ar[9]
+    self[9] = ar[10]
+    self[14] = SpecID::Pep.sequence_to_aaseq(self[8])
+    self
+  end
+end
+
+
+class SQT::Match::Percolator < SQT::Match
+  # we will keep access to these old terms since we can then access routines
+  # that sort on xcorr...
+  #undef_method :xcorr
+  #undef_method :xcorr=
+  #undef_method :sp
+  #undef_method :sp=
+
+  def percolator_score
+    self[4]
+  end
+  def percolator_score=(score)
+    self[4] = score
+  end
+  def negative_q_value
+    self[5]
+  end
+  def negative_q_value=(arg)
+    self[5] = arg
+  end
+  def q_value
+    -self[5]
+  end
+  # for compatibility with scripts that want this guy
+  def probability
+    -self[5]
+  end
+end
+
+SQT::Locus = ArrayClass.new(%w[locus description peps])
+
+class SQT::Locus
+  include SpecID::Prot
+  Leader = 'L'
+ 
+  def first_entry ; self[0] end
+  def reference ; self[0] end
+
+  def from_line(line)
+    line.chomp!
+    ar = line.split(SQT::Delimiter)
+    self[0] = ar[1]
+    self[1] = ar[2]
+    self
+  end
+
+end

data/lib/spec_id/srf.rb

@@ -3,7 +3,6 @@ require 'spec_id/sequest'
 require 'fasta'
 require 'mspire'
 require 'set'
-require 'fasta'
 
 module BinaryReader
   Null_char = "\0"[0]  ## TODO: change for ruby 1.9 or 2.0
@@ -40,6 +39,7 @@ class SRFGroup
     @prots = []
     @srfs = []
 
+    # This is essentially duplicated in SQTGroup (should refactor eventually)
     global_ref_hash = {}
     if filenames
       if filenames.is_a?(String) && filenames =~ /\.srg$/
@@ -102,6 +102,7 @@ class SRFGroup
     end
 
     @srfs.each do |srf|
+      srf.filtered_by_precursor_mass_tolerance = true
       srf.out_files.each do |out_file|
         hits = out_file.hits
         before = hits.size
@@ -129,7 +130,7 @@ class SRFGroup
           do_not_keep
         end
         if hits.size != before
-          SRF::OUT::Pep.set_deltacn_from_xcorr(hits)
+          SRF::OUT::Pep.update_deltacns_from_xcorr(hits)
           out_file.num_hits = hits.size
         end
       end
@@ -157,9 +158,9 @@ end
 
 class SRF
 
-  # a string 3.3 or 3.2
+  # a string 3.5, 3.3 or 3.2
   attr_accessor :version
- 
+
   attr_accessor :header
   attr_accessor :dta_files
   attr_accessor :out_files
@@ -170,8 +171,8 @@ class SRF
   attr_accessor :base_name
   # this is the global peptides array
   attr_accessor :peps
-  # the global reference hash that allows...
-  attr_accessor :global_ref_hash
+
+  attr_accessor :filtered_by_precursor_mass_tolerance 
 
   def dta_start_byte
     case @version
@@ -321,7 +322,6 @@ class SRF
       #    * Number of sequences matching this precursor ion 
       #########################################
 
-
       manual_validation_status = 'U'
       self.out_files.zip(dta_files) do |out_file, dta_file|
         # don't have the time to process (using 0.0 like bioworks 3.2)
@@ -337,17 +337,17 @@ class SRF
         out.puts ['S', out_file.first_scan, out_file.last_scan, out_file.charge, time_to_process, out_file.computer, dta_file_mh, out_file_total_inten, out_file_lowest_sp, out_file.num_matched_peptides].join("\t")
         out_file.hits.each_with_index do |hit,index|
           hit_mh = hit.mh
-          hit_deltacn_orig = hit.deltacn_orig
+          hit_deltacn_orig_updated = hit.deltacn_orig_updated
           hit_xcorr = hit.xcorr
           hit_sp = hit.sp
           if opt[:round]
             hit_mh = round(hit_mh, mh_dp)
-            hit_deltacn_orig = round(hit_deltacn_orig, dcn_dp)
+            hit_deltacn_orig_updated = round(hit_deltacn_orig_updated, dcn_dp)
             hit_xcorr = round(hit_xcorr, xcorr_dp)
             hit_sp = round(hit_sp, sp_dp)
           end
           # note that the rank is determined by the order..
-          out.puts ['M', index+1, hit.rsp, hit_mh, hit_deltacn_orig, hit_xcorr, hit_sp, hit.ions_matched, hit.ions_total, hit.sequence, manual_validation_status].join("\t")
+          out.puts ['M', index+1, hit.rsp, hit_mh, hit_deltacn_orig_updated, hit_xcorr, hit_sp, hit.ions_matched, hit.ions_total, hit.sequence, manual_validation_status].join("\t")
           hit.prots.each do |prot|
             out.puts ['L', prot.first_entry].join("\t")
           end
@@ -647,10 +647,17 @@ class SRF::OUT
 end
 
 
-# deltacn is modified to be that of the next best hit (by xcorr).
-# deltacn_orig is the one that sequest originally reports
-# if there is no next best hit, then it will be 1.1 (like bioworks)
-# mh is the theoretical mass + h
+# deltacn_orig - the one that sequest originally reports (top hit gets 0.0)
+# deltacn - modified to be that of the next best hit (by xcorr) and the last
+# hit takes 1.1.  This is what is called deltacn by bioworks and pepprophet
+# (at least for the first few years).  If filtering occurs, it will be
+# updated.  
+# deltacn_orig_updated - the latest updated value of deltacn.
+# Originally, this will be equal to deltacn_orig.  After filtering, this will
+# be recalculated.  To know if this will be different from deltacn_orig, query
+# match.srf.filtered_by_precursor_mass_tolerance.  If this is changed, then
+# deltacn should also be changed to reflect it. 
+# mh - the theoretical mass + h
 # prots are created as SRF prot objects with a reference and linked to their
 # peptides (from global hash by reference)
 # ppm = 10^6 * ∆m_accuracy / mass_measured  [ where ∆m_accuracy = mass_real – mass_measured ]
@@ -659,9 +666,9 @@ end
 # the first one listed
 # srf = the srf object this scan came from
 
-SRF::OUT::Pep = ArrayClass.new(%w( mh deltacn_orig sp xcorr id num_other_loci rsp ions_matched ions_total sequence prots deltamass ppm aaseq base_name first_scan last_scan charge srf deltacn) )
+SRF::OUT::Pep = ArrayClass.new(%w( mh deltacn_orig sp xcorr id num_other_loci rsp ions_matched ions_total sequence prots deltamass ppm aaseq base_name first_scan last_scan charge srf deltacn deltacn_orig_updated) )
 
-# 0=mh 1=deltacn 2=sp 3=xcorr 4=id 5=num_other_loci 6=rsp 7=ions_matched 8=ions_total 9=sequence 10=prots 11=deltamass 12=ppm 13=aaseq 14=base_name 15=first_scan 16=last_scan 17=charge 18=srf 19=deltacn
+# 0=mh 1=deltacn_orig 2=sp 3=xcorr 4=id 5=num_other_loci 6=rsp 7=ions_matched 8=ions_total 9=sequence 10=prots 11=deltamass 12=ppm 13=aaseq 14=base_name 15=first_scan 16=last_scan 17=charge 18=srf 19=deltacn 20=deltacn_orig_updated
 
 class SRF::OUT::Pep
   include SpecID::Pep
@@ -674,16 +681,18 @@ class SRF::OUT::Pep
     ar[-1].deltacn = 1.1
   end
 
-  # same as set_deltacn_from_deltacn_orig except calculates with xcorr.
-  # assumes sorted
-  def self.set_deltacn_from_xcorr(ar)
+  # (assumes sorted)
+  # recalculates deltacn from xcorrs and sets deltacn_orig_updated and deltacn
+  def self.update_deltacns_from_xcorr(ar)
     if ar.size > 0
       top_score = ar.first[3]
       other_scores = (1...(ar.size)).to_a.map do |i|
-        (top_score - ar[i][3])/top_score
+        1.0 - (ar[i][3]/top_score)
       end
+      ar.first[20] = 0.0
       (0...(ar.size-1)).each do |i|
-        ar[i][19] = other_scores[i]
+        ar[i][19] = other_scores[i]    # deltacn
+        ar[i+1][20] = other_scores[i]  # deltacn_orig_updated
       end
       ar.last[19] = 1.1
     end
@@ -753,6 +762,9 @@ class SRF::OUT::Pep
 
     self[0,10] = st.unpack(unpack)
 
+    # set deltacn_orig_updated 
+    self[20] = self[1]
+
     # we are slicing the reference to 38 chars to be the same length as
     # duplicate references
     self[10] = [new_protein(self[10][0,38], self, global_ref_hash)]
@@ -764,8 +776,6 @@ class SRF::OUT::Pep
     self
   end
 
-
-
   def new_protein(reference, peptide, global_ref_hash)
     if global_ref_hash.key? reference
       global_ref_hash[reference].peps << peptide