ms-sequest 0.0.2

data/History

@@ -0,0 +1,8 @@
+== 0.0.1 / 2009-05-11
+
+* pulled out of mspire core
+
+== 0.0.2 / 2009-05-14
+
+* Basic SRF to SQT translation working
+* SQT reading working

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2006 University of Texas at Austin, Regents of the University of
+Colorado, and Howard Hughes Medical Institute.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README

@@ -0,0 +1,23 @@
+= {Ms-Sequest}[http://mspire.rubyforge.org/projects/ms-sequest]
+
+An {Mspire}[http://mspire.rubyforge.org] library supporting SEQUEST, Bioworks, SQT and associated formats.
+
+== Description
+
+* Lighthouse[http://bahuvrihi.lighthouseapp.com/projects/16692-mspire/tickets]
+* Github[http://github.com/jtprince/ms-sequest/tree/master]
+* {Google Group}[http://groups.google.com/group/mspire-forum]
+
+== Installation
+
+Ms-Sequest is available as a gem on RubyForge[http://rubyforge.org/projects/mspire].  Use:
+
+  % gem install ms-sequest
+
+== Info 
+
+Copyright (c) 2006 University of Texas at Austin
+Copyright (c) Regents of the University of Colorado and Howard Hughes Medical Institute.
+Developer:: {John Prince}, {Edward Marcotte Lab}[http://polaris.icmb.utexas.edu/home.html], {Natalie Ahn Lab}[http://www.colorado.edu/chem/people/ahnn.html], {Howard Hughes Medical Institute}[http://www.hhmi.org/], {BYU Dept. of Chemistry and Biochemistry}[http://www.chem.byu.edu/]
+Support:: 
+Licence:: {MIT-Style}[link:files/MIT-LICENSE.html]

data/lib/ms/sequest.rb

@@ -0,0 +1,6 @@
+
+module Ms
+  module Sequest
+    VERSION = '0.0.2'
+  end
+end

data/lib/ms/sequest/params.rb

@@ -0,0 +1,343 @@
+require 'ms/mass/aa'
+
+# In the future, this guy should accept any version of bioworks params file
+# and spit out any param queried.
+
+module Ms ; end
+module Ms::Sequest ; end
+
+# 1) provides a reader and simple parameter lookup for SEQUEST params files
+# supporting Bioworks 3.1-3.3.1.  
+#     params = Ms::Sequest::Params.new("sequest.params") # filename by default
+#     params = Ms::Sequest::Params.new.parse_io(some_io_object)
+#
+#     params.some_parameter  # => any parameter defined has a method
+#     params.nonexistent_parameter # => nil 
+#
+# Provides consistent behavior between different versions important info:
+#    
+#     # some basic methods shared by all versions:
+#     params.version              # => '3.1' | '3.2' | '3.3'
+#     params.enzyme               # => enzyme name with no parentheses
+#     params.min_number_termini 
+#     params.database             # => first_database_name 
+#     params.enzyme_specificity   # => [offset, cleave_at, expect_if_after]
+#     params.precursor_mass_type  # => "average" | "monoisotopic"
+#     params.fragment_mass_type   # => "average" | "monoisotopic"
+#
+#     # some backwards/forwards compatibility methods:
+#     params.max_num_internal_cleavages  # == max_num_internal_cleavage_sites
+#     params.fragment_ion_tol     # => fragment_ion_tolerance
+#     
+class Ms::Sequest::Params
+
+  Bioworks31_Enzyme_Info_Array = [
+    ['No_Enzyme', 0, '-', '-'],   # 0
+    ['Trypsin', 1, 'KR', '-'],  # 1
+    ['Trypsin(KRLNH)', 1, 'KRLNH', '-'],  # 2
+    ['Chymotrypsin', 1, 'FWYL', '-'],  # 3
+    ['Chymotrypsin(FWY)', 1, 'FWY', 'P'],  # 4
+    ['Clostripain', 1, 'R', '-'],  # 5
+    ['Cyanogen_Bromide', 1, 'M', '-'],  # 6
+    ['IodosoBenzoate', 1, 'W', '-'],  # 7
+    ['Proline_Endopept', 1, 'P', '-'],  # 8
+    ['Staph_Protease', 1, 'E', '-'],  # 9
+    ['Trypsin_K', 1, 'K', 'P'],  # 10
+    ['Trypsin_R', 1, 'R', 'P'],  # 11
+    ['GluC', 1, 'ED', '-'],  # 12
+    ['LysC', 1, 'K', '-'],  # 13
+    ['AspN', 0, 'D', '-'],  # 14
+    ['Elastase', 1, 'ALIV', 'P'],  # 15
+    ['Elastase/Tryp/Chymo', 1, 'ALIVKRWFY', 'P'],  # 16
+  ]
+
+  # current attributes supported are:
+  # bioworks 3.2:
+  @@param_re = / = ?/o
+  @@param_two_split = ';'
+  @@sequest_line = /\[SEQUEST\]/o
+
+  # the general options
+  attr_accessor :opts
+  # the static weights added to amino acids
+  attr_accessor :mods
+
+  # all keys and values stored as strings!
+  # will accept a sequest.params file or .srf file
+  def initialize(file=nil)
+    if file
+      parse_file(file)
+    end
+  end
+
+  # returns hash of params up until add_U_user_amino_acid
+  def grab_params(fh)
+    hash = {}
+    in_add_amino_acid_section = false
+    add_section_re = /^\s*add_/
+    prev_pos = nil
+    while line = fh.gets
+      if line =~ add_section_re
+        in_add_amino_acid_section = true
+      end
+      if (in_add_amino_acid_section and !(line =~ add_section_re))
+        fh.pos = prev_pos
+        break
+      end
+      prev_pos = fh.pos
+      if line =~ /\w+/
+        one,two = line.split @@param_re
+        two,comment = two.split @@param_two_split
+        hash[one] = two.rstrip
+      end
+    end
+    hash
+  end
+
+  # returns self
+  def parse_io(fh)
+    # seek to the SEQUEST file
+    loop do
+      if fh.gets =~ @@sequest_line
+        # double check that we are in a sequest params file:
+        pos = fh.pos
+        if fh.gets =~ /^first_database_name/
+          fh.pos = pos
+          break
+        end
+      end
+    end
+    @opts = grab_params(fh)
+    @opts["search_engine"] = "SEQUEST"
+    # extract out the mods
+    @mods = {}
+    @opts.each do |k,v|
+      if k =~ /^add_/
+        @mods[k] = @opts.delete(k)
+      end
+    end
+
+    ## this gets rid of the .hdr postfix on indexed databases
+    @opts["first_database_name"] = @opts["first_database_name"].sub(/\.hdr$/, '')
+    self
+  end
+
+  ## parses file
+  ## and drops the .hdr behind indexed fasta files
+  ## returns self
+  ## can read sequest.params file or .srf file handle
+  def parse_file(file)
+    File.open(file) do |fh|
+      parse_io(fh)
+    end
+    self
+  end
+
+  # returns( offset, cleave_at, except_if_after )
+  # offset is an Integer specifying how far after an amino acid to cut
+  # cleave_at is a string of all amino acids that should be cut at
+  # except_if_after for not cutting after those
+  # normal tryptic behavior would be: [1, 'KR', 'P']
+  # NOTE: a '-' in a params file is returned as an '' (empty string)
+  # AspN is [0,'D','']
+  def enzyme_specificity
+    enzyme_ar = 
+      if version == '3.1'
+        Bioworks31_Enzyme_Info_Array[@opts['enzyme_number'].to_i][1,3]
+      elsif version >= '3.2'
+        arr = enzyme_info.split(/\s+/)[2,3]
+        arr[0] = arr[0].to_i
+        arr
+      else
+        raise ArgumentError, "don't recognize anything but Bioworks 3.1--3.3"
+      end
+    enzyme_ar.map! do |str|
+      if str == '-' ; ''
+      else ; str
+      end
+    end
+    enzyme_ar
+  end
+
+  # Returns the version of the sequest.params file
+  # Returns String "3.3" if contains "fragment_ion_units"
+  # Returns String "3.2" if contains "enyzme_info"
+  # Returns String "3.1" if contains "enzyme_number"
+  def version
+    if @opts['fragment_ion_units'] ; return '3.3'
+    elsif @opts['enzyme_info'] ; return '3.2'
+    elsif @opts['enzyme_number'] ; return '3.1'
+    end
+  end
+
+  ####################################################
+  # TO PEPXML
+  ####################################################
+  # In some ways, this is merely translating to the older Bioworks
+  # sequest.params files
+
+  # I'm not sure if this is the right mapping for sequence_search_constraint?
+  def sequence
+    pseq = @opts['partial_sequence'] 
+    if !pseq || pseq == "" ; pseq = "0" end
+    pseq
+  end
+
+  def precursor_mass_type
+    case @opts['mass_type_parent']
+    when '0' ; "average" 
+    when '1' ; "monoisotopic"
+    else ; abort "error in mass_type_parent in sequest!"
+    end
+  end
+
+  def fragment_mass_type
+    fmtype = 
+      case @opts['mass_type_fragment']
+      when '0' ; "average"
+      when '1' ; "monoisotopic"
+      else ; abort "error in mass_type_fragment in sequest!"
+      end
+  end
+
+  def method_missing(name, *args)
+    string = name.to_s
+    if @opts.key?(string)    ; return @opts[string]
+    elsif @mods.key?(string) ; return @mods[string]
+    else                     ; return nil
+    end
+  end
+
+  ## We only need to define values if they are different than sequest.params
+  ## The method_missing will look them up in the hash!
+
+  # Returns a system independent basename
+  # Splits on "\" or "/"
+  def _sys_ind_basename(file)
+    return file.split(/[\\\/]/)[-1]
+  end
+
+  # changes the path of the database
+  def database_path=(newpath)
+    db = @opts["first_database_name"]
+    newpath = File.join(newpath, _sys_ind_basename(db))
+    @opts["first_database_name"] = newpath
+  end
+
+  def database
+    @opts["first_database_name"]
+  end
+
+  # returns the appropriate aminoacid mass lookup table from Ms::Mass::AA
+  # based_on may be :precursor or :fragment
+  def mass_index(based_on=:precursor)
+    reply = case based_on
+            when :precursor : precursor_mass_type
+            when :fragment : fragment_mass_type
+            end
+   case reply
+   when 'average'
+     Ms::Mass::AA::AVG
+   when 'monoisotopic'
+     Ms::Mass::AA::MONO
+   end
+  end
+
+  # at least in Bioworks 3.2, the First number after the enzyme
+  # is the indication of the enzymatic end stringency (required):
+  #   1 = Fully enzymatic
+  #   2 = Either end
+  #   3 = N terminal only
+  #   4 = C terminal only
+  # So, to get min_number_termini we map like this:
+  #   1 => 2
+  #   2 => 1
+  def min_number_termini
+    if e_info = @opts["enzyme_info"]
+      case e_info.split(" ")[1]
+      when "1": return "2"
+      when "2": return "1"
+      end
+    end
+    warn "No Enzyme termini info, using min_number_termini = '1'"
+    return "1"
+  end
+
+  ## returns a SampleEnzyme object
+  #def sample_enzyme
+  #  (offset, cleave_at, except_if_after) = enzyme_specificity.map do |v|
+  #    if v == '' ; nil ; else v end
+  #  end
+  #  SampleEnzyme.new do |se|
+  #    se.name = self.enzyme
+  #    se.cut = cleave_at
+  #    se.no_cut = except_if_after
+  #    se.sense =
+  #      if se.name == "No_Enzyme"
+  #        nil
+  #      elsif offset == 1
+  #        'C'
+  #      elsif offset == 0
+  #        'N'
+  #      end
+  #  end
+  #end
+
+  # returns the enzyme name (but no parentheses connected with the name).
+  # this will likely be capitalized.
+  def enzyme
+    v = self.version
+    basic_name = 
+      if v == '3.1'
+        Bioworks31_Enzyme_Info_Array[ @opts['enzyme_number'].to_i ][0]
+      elsif v >= '3.2'
+        @opts["enzyme_info"]
+      end
+    basic_name.split('(')[0]
+  end
+
+  def max_num_internal_cleavages
+    @opts["max_num_internal_cleavage_sites"]
+  end
+
+  # my take on peptide_mass_units:
+  # (see http://www.ionsource.com/tutorial/isotopes/slide2.htm)
+  # amu = atomic mass units = (mass_real - mass_measured).abs (??abs??)
+  # mmu = milli mass units (amu / 1000)
+  # ppm = parts per million = 10^6 * ∆m_accuracy / mass_measured  [ where ∆m_accuracy = mass_real – mass_measured ]
+
+  def peptide_mass_tol
+    if @opts["peptide_mass_units"] != "0"
+      puts "WARNING: peptide_mass_tol units need to be adjusted!"
+    end
+    @opts["peptide_mass_tolerance"]
+  end
+
+  def fragment_ion_tol
+    @opts["fragment_ion_tolerance"]
+  end
+
+  def max_num_differential_AA_per_mod
+    @opts["max_num_differential_AA_per_mod"] || @opts["max_num_differential_per_peptide"]
+  end
+
+  # returns a hash by add_<whatever> of any static mods != 0
+  # the values are still as strings
+  def static_mods
+    hash = {}
+    @mods.each do |k,v|
+      if v.to_f != 0.0
+        hash[k] = v
+      end
+    end
+    hash
+  end
+
+  ## @TODO: We could add some of the parameters not currently being asked for to be more complete
+  ## @TODO: We could always add the Bioworks 3.2 specific params as params
+
+  ####################################################
+  ####################################################
+
+end
+

data/lib/ms/sequest/sqt.rb

@@ -0,0 +1,363 @@
+
+require 'ms/fasta'
+require 'arrayclass'
+require 'set'
+
+require 'ms/id/peptide'
+require 'ms/id/search'
+
+module Ms
+  module Sequest
+    class SqtGroup
+      include Ms::Id::SearchGroup
+
+      #attr_accessor :sqts, :filenames
+
+      def search_class
+        Ms::Sequest::Sqt
+      end
+
+      def extension() 'sqg' end
+
+      def initialize(arg, opts={}, &block)
+        orig_opts = opts.dup
+        indiv_opts = { :link_protein_hits => false }
+        super(arg, opts.merge(indiv_opts)) do
+          unless orig_opts[:link_protein_hits] == false
+            puts "MERGING GROUP!"
+            (@peps, @prots) = merge!(@searches.map {|v| v.peps }, &Ms::Sequest::Sqt::NEW_PROT)
+          end
+        end
+        block.call(self) if block_given?
+      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 # SqtGroup
+
+
+    class Sqt
+      include Ms::Id::Search
+      PercolatorHeaderMatch = /^Percolator v/
+        Delimiter = "\t"
+      attr_accessor :header
+      attr_accessor :spectra
+      attr_accessor :base_name
+      # boolean
+      attr_accessor :percolator_results
+
+      # assumes the file exists and is readable
+      # returns [DBSeqLength, DBLocusCount, DBMD5Sum] or nil if no file
+      def self.get_db_info(dbfile)
+        Ms::Fasta.open(dbfile) do |fasta|
+          [fasta.total_sequence_length, fasta.size, fasta.md5_sum]
+        end
+      end
+
+      def protein_class
+        Ms::Sequest::Sqt::Locus
+      end
+
+      # opts = 
+      #     :percolator_results => false | true (default false)
+      #     :link_protein_hits => true | false (default true)
+      def initialize(filename=nil, opts={})
+        @peps = []
+        @prots = []
+        if filename
+          from_file(filename, opts)
+        end
+      end
+
+      NEW_PROT = lambda do |_prot, _peps| 
+        Ms::Sequest::Sqt::Locus.new([_prot.locus, _prot.description, _peps])
+      end
+
+      # if the file contains the header key '/$Percolator v/' then the results
+      # will be interpreted as percolator results regardless of the value
+      # passed in.
+      def from_file(filename, opts={})
+        opts = {:percolator_results=>false, :link_protein_hits => true}.merge(opts)
+        @percolator_results = opts[:percolator_results]
+        @base_name = File.basename( filename.gsub('\\','/') ).sub(/\.\w+$/, '')
+        File.open(filename) do |fh| 
+          @header = Ms::Sequest::Sqt::Header.new.from_handle(fh)
+          if @header.keys.any? {|v| v =~ PercolatorHeaderMatch }
+            @percolator_results = true
+          end
+          (@spectra, @peps) = Ms::Sequest::Sqt::Spectrum.spectra_from_handle(fh, @base_name, @percolator_results)
+        end
+        if opts[:link_protein_hits]
+          (@peps, @prots) = merge!([@peps], &NEW_PROT)
+        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 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] == Ms::Sequest::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(Ms::Sequest::Sqt::Delimiter)[1..-1]
+            # just in case they have any tabs in their field
+            value = rest.join(Ms::Sequest::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
+    end
+  end
+end
+
+# all are cast as expected (total_intensity is a float)
+# mh = observed mh
+Ms::Sequest::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 Ms::Sequest::Sqt::Spectrum
+  Leader = 'S'
+
+  # assumes the first line starts with an 'S'
+  def self.spectra_from_handle(fh, base_name, percolator_results=false)
+    peps = []
+    spectra = []
+    
+    while line = fh.gets
+      case line[0,1]
+      when Ms::Sequest::Sqt::Spectrum::Leader
+        spectrum = Ms::Sequest::Sqt::Spectrum.new.from_line( line )
+        spectra << spectrum
+        matches = []
+        spectrum.matches = matches
+      when Ms::Sequest::Sqt::Match::Leader
+        match_klass = if percolator_results
+                        Ms::Sequest::Sqt::Match::Percolator
+                      else
+                        Ms::Sequest::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 Ms::Sequest::Sqt::Locus::Leader
+        line.chomp!
+        key = line.split(Ms::Sequest::Sqt::Delimiter)[1]
+        locus = Ms::Sequest::Sqt::Locus.new.from_line( line )
+        loci << locus
+      end
+    end
+    # set the deltacn:
+    set_deltacn(spectra)
+    [spectra, peps]
+  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(Ms::Sequest::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
+Ms::Sequest::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 Ms::Sequest::Sqt::Match
+  Leader = 'M'
+
+  # same as 'loci'
+  def prots
+    self[16]
+  end
+
+  def from_line(line)
+    line.chomp!
+    ar = line.split(Ms::Sequest::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] = Ms::Id::Peptide.sequence_to_aaseq(self[8])
+    self
+  end
+end
+
+
+class Ms::Sequest::Sqt::Match::Percolator < Ms::Sequest::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
+
+Ms::Sequest::Sqt::Locus = Arrayclass.new(%w[locus description peps])
+
+class Ms::Sequest::Sqt::Locus
+  Leader = 'L'
+
+  def first_entry ; self[0] end
+  def reference ; self[0] end
+
+  def from_line(line)
+    line.chomp!
+    ar = line.split(Ms::Sequest::Sqt::Delimiter)
+    self[0] = ar[1]
+    self[1] = ar[2]
+    self
+  end
+
+end