mspire-sequest 0.2.5

data/lib/mspire/sequest/pepxml/modifications.rb

@@ -0,0 +1,247 @@
+require 'mspire/ident/pepxml/search_hit/modification_info'
+
+module Mspire ; end
+module Mspire::Sequest ; end
+class Mspire::Sequest::Pepxml ; end
+
+class Mspire::Sequest::Pepxml::Modifications
+  # sequest params object
+  attr_accessor :params
+  # array holding AAModifications 
+  attr_accessor :aa_mods
+  # array holding TerminalModifications
+  attr_accessor :term_mods
+  # a hash of all differential modifications present by aa_one_letter_symbol
+  # and special_symbol. This is NOT the mass difference but the total mass {
+  # 'M*' => 155.5, 'S@' => 190.3 }.  NOTE: Since the termini are dependent on
+  # the amino acid sequence, they are give the *differential* mass.  The
+  # termini are given the special symbol as in sequest e.g. '[' => 12.22, #
+  # cterminus    ']' => 14.55 # nterminus
+  attr_accessor :aa_mod_to_tot_mass
+  # a hash, key is [AA_one_letter_symbol.to_sym, difference.to_f]
+  # values are the special_symbols
+  attr_accessor :mod_symbols_hash
+
+  # returns an array of all modifications (aa_mods, then term_mods)
+  def modifications
+    aa_mods + term_mods
+  end
+
+  # The modification symbols string looks like this:
+  # (M* +15.90000) (M# +29.00000) (S@ +80.00000) (C^ +12.00000) (ct[ +12.33000) (nt] +14.20000)
+  # ct is cterminal peptide (differential)
+  # nt is nterminal peptide (differential)
+  # the C is just cysteine
+  # will set_modifications and aa_mod_to_tot_mass hash
+  def initialize(params=nil, modification_symbols_string='')
+    @params = params
+    if @params
+      set_modifications(params, modification_symbols_string)
+    end
+  end
+
+  # set the aa_mod_to_tot_mass and mod_symbols_hash from 
+  def set_hashes(modification_symbols_string)
+
+    @mod_symbols_hash = {}
+    @aa_mod_to_tot_mass = {}
+    if (modification_symbols_string == nil || modification_symbols_string == '')
+      return nil
+    end
+    table = @params.mass_index(:precursor)
+    modification_symbols_string.split(/\)\s+\(/).each do |mod|
+      if mod =~ /\(?(\w+)(.) (.[\d\.]+)\)?/
+        if $1 == 'ct' || $1 == 'nt' 
+          mass_diff = $3.to_f
+          @aa_mod_to_tot_mass[$2] = mass_diff
+          @mod_symbols_hash[[$1.to_sym, mass_diff]] = $2.dup
+          # changed from below to match tests, is this right?
+          # @mod_symbols_hash[[$1, mass_diff]] = $2.dup
+        else
+          symbol_string = $2.dup 
+          mass_diff = $3.to_f
+          $1.split('').each do |aa|
+            aa_as_sym = aa.to_sym
+            @aa_mod_to_tot_mass[aa+symbol_string] = mass_diff + table[aa_as_sym]
+            @mod_symbols_hash[[aa_as_sym, mass_diff]] = symbol_string
+          end
+        end
+      end
+    end
+  end
+  # returns an array of static mod objects and static terminal mod objects
+  def create_static_mods(params)
+
+    ####################################
+    ## static mods
+    ####################################
+
+    static_mods = [] # [[one_letter_amino_acid.to_sym, add_amount.to_f], ...]
+    static_terminal_mods = [] # e.g. [add_Cterm_peptide, amount.to_f]
+
+    params.mods.each do |k,v|
+      v_to_f = v.to_f
+      if v_to_f != 0.0
+        if k =~ /add_(\w)_/
+          static_mods << [$1.to_sym, v_to_f]
+        else
+          static_terminal_mods << [k, v_to_f]
+        end
+      end
+    end
+    aa_hash = params.mass_index(:precursor)
+
+    ## Create the static_mods objects
+    static_mods.map! do |mod|
+      hash = {
+        :aminoacid => mod[0].to_s,
+        :massdiff => mod[1],
+        :mass => aa_hash[mod[0]] + mod[1],
+        :variable => 'N',
+        :binary => 'Y',
+      } 
+      Mspire::Ident::Pepxml::AminoacidModification.new(hash)
+    end
+
+    ## Create the static_terminal_mods objects
+    static_terminal_mods.map! do |mod|
+      terminus = if mod[0] =~ /Cterm/ ; 'c'
+                 else                 ; 'n' # only two possible termini
+                 end
+      protein_terminus = case mod[0] 
+                         when /Nterm_protein/ ; 'n'
+                         when /Cterm_protein/ ; 'c'
+                         else nil
+                         end
+
+      # create the hash                            
+      hash = {
+        :terminus => terminus,
+        :massdiff => mod[1],
+        :variable => 'N',
+        :description => mod[0],
+      }
+      hash[:protein_terminus] = protein_terminus if protein_terminus
+      Mspire::Ident::Pepxml::TerminalModification.new(hash)
+    end
+    [static_mods, static_terminal_mods]
+  end
+
+  # 1. sets aa_mods and term_mods from a sequest params object
+  # 2. sets @params
+  # 3. sets @aa_mod_to_tot_mass
+  def set_modifications(params, modification_symbols_string)
+    @params = params
+
+    set_hashes(modification_symbols_string)
+    (static_mods, static_terminal_mods) = create_static_mods(params)
+
+    aa_hash = params.mass_index(:precursor)
+    #################################
+    # Variable Mods:
+    #################################
+    arr = params.diff_search_options.rstrip.split(/\s+/)
+    # [aa.to_sym, diff.to_f]
+    variable_mods = []
+    (0...arr.size).step(2) do |i|
+      if arr[i].to_f != 0.0
+        variable_mods << [arr[i+1], arr[i].to_f]
+      end
+    end
+    mod_objects = []
+    variable_mods.each do |mod|
+      mod[0].split('').each do |aa|
+        hash = {
+
+          :aminoacid => aa,
+          :massdiff => mod[1],
+          :mass => aa_hash[aa.to_sym] + mod[1],
+          :variable => 'Y',
+          :binary => 'N',
+          :symbol => @mod_symbols_hash[[aa.to_sym, mod[1]]],
+        }
+        mod_objects << Mspire::Ident::Pepxml::AminoacidModification.new(hash)
+      end
+    end
+
+    variable_mods = mod_objects
+    #################################
+    # TERMINAL Variable Mods:
+    #################################
+    # These are always peptide, not protein termini (for sequest)
+    (nterm_diff, cterm_diff) = params.term_diff_search_options.rstrip.split(/\s+/).map{|v| v.to_f }
+
+    to_add = []
+    if nterm_diff != 0.0
+      to_add << ['n',nterm_diff.to_plus_minus_string, @mod_symbols_hash[:nt, nterm_diff]]
+    end
+    if cterm_diff != 0.0
+      to_add << ['c', cterm_diff.to_plus_minus_string, @mod_symbols_hash[:ct, cterm_diff]]
+    end
+
+    variable_terminal_mods = to_add.map do |term, mssdiff, symb|
+      hash = {
+        :terminus => term,
+        :massdiff => mssdiff,
+        :variable => 'Y',
+        :symbol => symb,
+      }
+      Mspire::Ident::Pepxml::TerminalModification.new(hash)
+    end
+
+    #########################
+    # COLLECT THEM
+    #########################
+    @aa_mods = static_mods + variable_mods
+    @term_mods = static_terminal_mods + variable_terminal_mods
+  end
+
+  # takes a peptide sequence with modifications but no preceding or trailing
+  # amino acids.  (e.g. expects "]PEPT*IDE" but not 'K.PEPTIDE.R')
+  # returns a ModificationInfo object 
+  #  if there are no modifications, returns nil
+  def modification_info(mod_peptide)
+    return nil if @aa_mod_to_tot_mass.size == 0 
+    mod_info = Mspire::Ident::Pepxml::SearchHit::ModificationInfo.new( mod_peptide.dup )
+    mass_table = @params.mass_index(:precursor)
+
+    # TERMINI:
+    ## only the termini can match a single char
+    if @aa_mod_to_tot_mass.key? mod_peptide[0,1]
+      # AA + H + differential_mod
+      mod_info.mod_nterm_mass = mass_table[mod_peptide[1,1].to_sym] + mass_table['h+'] + @aa_mod_to_tot_mass[mod_peptide[0,1]]
+      mod_peptide = mod_peptide[1...(mod_peptide.size)]
+    end
+    if @aa_mod_to_tot_mass.key? mod_peptide[(mod_peptide.size-1),1]
+      # AA + OH + differential_mod
+      mod_info.mod_cterm_mass = mass_table[mod_peptide[(mod_peptide.size-2),1].to_sym] + mass_table['oh'] + @aa_mod_to_tot_mass[mod_peptide[-1,1]]
+      mod_peptide = mod_peptide[0...(mod_peptide.size-1)]
+    end
+
+    # OTHER DIFFERENTIAL MODS:
+    mod_array = []
+    mod_cnt = 1
+    bare_cnt = 1
+    last_normal_aa = mod_peptide[0,1]
+    (1...mod_peptide.size).each do |i|
+      if @aa_mod_to_tot_mass.key?( last_normal_aa + mod_peptide[i,1] )
+        # we don't save the result because most amino acids will not be
+        # modified
+        mod_array << Mspire::Ident::Pepxml::SearchHit::ModificationInfo::ModAminoacidMass.new(bare_cnt, @aa_mod_to_tot_mass[last_normal_aa + mod_peptide[i,1]])
+      else
+        last_normal_aa = mod_peptide[i,1]
+        bare_cnt += 1
+      end
+      mod_cnt += 1
+    end
+    if mod_cnt == bare_cnt
+      nil
+    else
+      mod_info.mod_aminoacid_masses = mod_array if mod_array.size > 0
+      mod_info
+    end
+  end
+
+
+end
+

data/lib/mspire/sequest/pepxml/params.rb

@@ -0,0 +1,32 @@
+
+module Mspire ; end
+module Mspire::Sequest ; end
+
+class Mspire::Sequest::Params
+
+  # returns a Mspire::Ident::Pepxml::SampleEnzyme object
+  def sample_enzyme
+    Mspire::Ident::Pepxml::SampleEnzyme.new(sample_enzyme_hash)
+  end
+
+  # returns a hash suitable for setting a Mspire::Ident::Pepxml::SampleEnzyme object
+  def sample_enzyme_hash
+    (offset, cleave_at, except_if_after) = enzyme_specificity.map do |v|
+      if v == '' ; nil ; else v end
+    end
+    hash = {}
+    hash[:name] = self.enzyme
+    hash[:cut] = cleave_at
+    hash[:no_cut] = except_if_after
+    hash[:sense] =
+      if hash[:name] == "No_Enzyme"
+        nil
+      elsif offset == 1
+        'C'
+      elsif offset == 0
+        'N'
+      end
+    hash
+  end
+
+end

data/lib/mspire/sequest/sqt.rb

@@ -0,0 +1,393 @@
+require 'set'
+
+require 'mspire/fasta'
+require 'digest/md5'
+
+require 'mspire/ident/peptide'
+require 'mspire/ident/search'
+
+module Mspire
+  module Sequest
+    class SqtGroup
+      include Mspire::Ident::SearchGroup
+
+      #attr_accessor :sqts, :filenames
+
+      def search_class
+        Mspire::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!"
+            (@peptides, @proteins) = merge!(@searches.map {|v| v.peptides }, &Mspire::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 Mspire::Ident::SearchLike
+      PercolatorHeaderMatch = /^Percolator v/
+        Delimiter = "\t"
+      attr_accessor :header
+      attr_accessor :spectra
+      attr_accessor :base_name
+      # boolean
+      attr_accessor :percolator_results
+
+      # returns [sequence_length, locus_count] of the fasta file
+      def self.db_seq_length_and_locus_count(dbfile)
+        total_sequence_length = 0
+        fastasize = 0
+        Mspire::Fasta.open(dbfile) do |fasta|
+          fasta.each do |entry| 
+            total_sequence_length += entry.sequence.size 
+            fastasize += 1
+          end
+        end
+        [total_sequence_length, fastasize]
+      end
+
+      #--
+      # this is implemented separate from sequence length because seq length
+      # uses Archive which doesn't preserve carriage returns and newlines.
+      #++
+      def self.db_md5sum(dbfile)
+        chunksize = 61440
+        digest = Digest::MD5.new
+        File.open(dbfile) do |io|
+          while chunk = io.read(chunksize)
+            digest << chunk 
+          end
+        end
+        digest.hexdigest
+      end
+
+      # assumes the file exists and is readable
+      # returns [DBSeqLength, DBLocusCount, DBMD5Sum]
+      def self.db_info(dbfile)
+        # returns the 3 member array
+        self.db_seq_length_and_locus_count(dbfile) << self.db_md5sum(dbfile)
+      end
+
+      def protein_class
+        Mspire::Sequest::Sqt::Locus
+      end
+
+      # opts = 
+      #     :percolator_results => false | true (default false)
+      #     :link_protein_hits => true | false (default true)
+      def initialize(filename=nil, opts={})
+        peptide_hits = []
+        if filename
+          from_file(filename, opts)
+        end
+      end
+
+      NEW_PROT = lambda do |_prot, _peptides|
+        Mspire::Sequest::Sqt::Locus.new(_prot.locus, _prot.description, _peptides)
+      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 = Mspire::Sequest::Sqt::Header.new.from_handle(fh)
+          if @header.keys.any? {|v| v =~ PercolatorHeaderMatch }
+            @percolator_results = true
+          end
+          (@spectra, @peptides) = Mspire::Sequest::Sqt::Spectrum.spectra_from_handle(fh, @base_name, @percolator_results)
+        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] == Mspire::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(Mspire::Sequest::Sqt::Delimiter)[1..-1]
+            # just in case they have any tabs in their field
+            value = rest.join(Mspire::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
+Mspire::Sequest::Sqt::Spectrum = Struct.new(* %w(first_scan last_scan charge time_to_process node mh total_intensity lowest_sp num_matched_peptides matches).map(&:to_sym) )
+
+# 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 Mspire::Sequest::Sqt::Spectrum
+  Leader = 'S'
+
+  # assumes the first line starts with an 'S'
+  def self.spectra_from_handle(fh, base_name, percolator_results=false)
+    peptides = []
+    spectra = []
+    
+    while line = fh.gets
+      case line[0,1]
+      when Mspire::Sequest::Sqt::Spectrum::Leader
+        spectrum = Mspire::Sequest::Sqt::Spectrum.new.from_line( line )
+        spectra << spectrum
+        matches = []
+        spectrum.matches = matches
+      when Mspire::Sequest::Sqt::Match::Leader
+        match_klass = if percolator_results
+                        Mspire::Sequest::Sqt::Match::Percolator
+                      else
+                        Mspire::Sequest::Sqt::Match
+                      end
+        match = match_klass.new.from_line( line )
+        #match[10,3] = spectrum[0,3]
+        # structs cannot set multiple values at a time :(
+        match[10] = spectrum[0]
+        match[11] = spectrum[1]
+        match[12] = spectrum[2]
+        match[15] = base_name
+        matches << match
+        peptides << match
+        loci = []
+        match.loci = loci
+        matches << match
+      when Mspire::Sequest::Sqt::Locus::Leader
+        line.chomp!
+        key = line.split(Mspire::Sequest::Sqt::Delimiter)[1]
+        locus = Mspire::Sequest::Sqt::Locus.from_line( line )
+        loci << locus
+      end
+    end
+    # set the deltacn:
+    set_deltacn(spectra)
+    [spectra, peptides]
+  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(Mspire::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
+Mspire::Sequest::Sqt::Match = Struct.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].map(&:to_sym) )
+
+# 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 Mspire::Sequest::Sqt::Match
+  Leader = 'M'
+
+  # same as 'loci'
+  def proteins
+    self[16]
+  end
+
+  def from_line(line)
+    line.chomp!
+    ar = line.split(Mspire::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] = Mspire::Ident::Peptide.sequence_to_aaseq(self[8])
+    self
+  end
+end
+
+
+class Mspire::Sequest::Sqt::Match::Percolator < Mspire::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
+
+Mspire::Sequest::Sqt::Locus = Struct.new( :locus, :description )
+
+class Mspire::Sequest::Sqt::Locus
+  Leader = 'L'
+
+  def first_entry ; self[0] end
+  def reference ; self[0] end
+  def id ; self[0] end
+
+  def initialize(locus=nil, description=nil, peptides=[])
+    super(locus, description)
+  end
+
+  # returns a new Locus object
+  def self.from_line(line)
+    line.chomp!
+    self.new( *line.split(Mspire::Sequest::Sqt::Delimiter) )  # fills in the first two values 
+  end
+
+end

data/lib/mspire/sequest/srf/pepxml/sequest.rb

@@ -0,0 +1,21 @@
+module Mspire ; end
+module Mspire::Ident ; end
+
+class Mspire::Ident::Pepxml 
+  class SearchHit
+    Sequest = Struct.new(:xcorr, :deltacn, :deltacnstar, :spscore, :sprank) do
+
+      # Takes ions in the form XX/YY and returns [XX.to_i, YY.to_i]
+      def self.split_ions(ions)
+        ions.split("/").map {|ion| ion.to_i }
+      end
+
+      def to_xml(builder)
+        members.zip(self.to_a) do |sym, val|
+          builder.search_score(:name => sym, :value => val)
+        end
+      end
+    end
+  end
+end
+