ms-sequest 0.0.17 → 0.0.18

data/.autotest

@@ -1,14 +1,30 @@
 # -*- ruby -*-
 
-Autotest.add_hook :initialize do |at|
- at.clear_mappings
-end
+require 'rubygems'
+require 'spec/more'
+require 'autotest/bacon'
+#require 'redgreen/autotest'
 
-Autotest.add_hook :initialize do |at|
-at.add_mapping(%r%^lib/(.*)\.rb$%) { |_, m|
-    #["spec/#{m[1]}_spec.rb"]
-    #["test/#{m[1]}_test.rb"]
-    ## for both specs and tests:
-    ["spec/#{m[1]}_spec.rb","test/#{m[1]}_test.rb"]
-}
+class Autotest::Bacon < Autotest
+    undef make_test_cmd
+    def make_test_cmd(files_to_test)
+        args = files_to_test.keys.flatten.join(' ')
+        args = '-a' if args.empty?
+        # TODO : make regex to pass to -n using values
+        "#{ruby} -S bacon -I#{libs} -o TestUnit #{args}"
+    end
 end
+
+
+#Autotest.add_hook :initialize do |at|
+# at.clear_mappings
+#end
+
+#Autotest.add_hook :initialize do |at|
+#at.add_mapping(%r%^lib/(.*)\.rb$%) { |_, m|
+#    #["spec/#{m[1]}_spec.rb"]
+#    #["test/#{m[1]}_test.rb"]
+#    ## for both specs and tests:
+#    ["spec/#{m[1]}_spec.rb"]
+#}
+#end

data/Gemfile

@@ -2,8 +2,11 @@ source "http://rubygems.org"
 # Add dependencies required to use your gem here.
 # Example:
 #   gem "activesupport", ">= 2.3.5"
-gem "ms-core", ">= 0.0.11"
+gem "ms-ident", ">= 0.0.17"
+gem "ms-core", ">= 0.0.14"
 gem "arrayclass", ">= 0.1.0"
+gem "ms-msrun", ">= 0.3.3"
+gem "trollop", "~> 1.16"
 
 # Add dependencies to develop your gem here.
 # Include everything needed to run rake, tests, features, etc.

data/Gemfile.lock

@@ -1,6 +1,7 @@
 GEM
   remote: http://rubygems.org/
   specs:
+    andand (1.3.1)
     arrayclass (0.1.1)
     bacon (1.1.0)
     bio (1.4.1)
@@ -9,13 +10,24 @@ GEM
       bundler (~> 1.0.0)
       git (>= 1.2.5)
       rake
-    ms-core (0.0.11)
+    ms-core (0.0.14)
       bio (>= 1.4.1)
+    ms-ident (0.0.17)
+      andand
+      ms-core (>= 0.0.12)
+      nokogiri
+    ms-msrun (0.3.3)
+      ms-core (>= 0.0.3)
+      narray
+      nokogiri
     ms-testdata (0.1.1)
+    narray (0.5.9.9)
+    nokogiri (1.4.4)
     rake (0.8.7)
     rcov (0.9.9)
     spec-more (0.0.4)
       bacon
+    trollop (1.16.2)
 
 PLATFORMS
   ruby
@@ -24,7 +36,10 @@ DEPENDENCIES
   arrayclass (>= 0.1.0)
   bundler (~> 1.0.0)
   jeweler (~> 1.5.2)
-  ms-core (>= 0.0.11)
+  ms-core (>= 0.0.14)
+  ms-ident (>= 0.0.17)
+  ms-msrun (>= 0.3.3)
   ms-testdata (>= 0.1.1)
   rcov
   spec-more
+  trollop (~> 1.16)

data/VERSION

@@ -1 +1 @@
-0.0.17
+0.0.18

data/bin/srf_to_pepxml.rb

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'ms/sequest/srf/pepxml'
+
+Ms::Sequest::Srf::Pepxml.commandline(ARGV, File.basename(__FILE__))
+

data/bin/srf_to_search.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/ruby
+#!/usr/bin/env ruby
 
 require 'rubygems'
 require 'ms/sequest/srf/search'

data/lib/ms/sequest/bioworks.rb

@@ -27,7 +27,7 @@ class Bioworks
   @@origfilepath_re = /<origfilepath>(.*)<\/origfilepath>/o
 
 
-  attr_accessor :peps, :prots, :version, :global_filename, :origfilename, :origfilepath
+  attr_accessor :peps, :proteins, :version, :global_filename, :origfilename, :origfilepath
   # a string of modifications e.g., "(M* +15.99491) (S@ +14.9322) "
   attr_accessor :modifications
 
@@ -42,7 +42,7 @@ class Bioworks
 
   # returns the number of prots.  Raises an Exception if open and closing xml
   # tags don't agree
-  def num_prots(file)
+  def num_proteins(file)
     re = /(<protein>)|(<\/protein>)/mo
     begin_tags = 0
     end_tags = 0

data/lib/ms/sequest/params.rb

@@ -269,26 +269,6 @@ class Ms::Sequest::Params
     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

data/lib/ms/sequest/pepxml.rb

@@ -1,3 +1,8 @@
+require 'ms/sequest/pepxml/params'
+require 'ms/sequest/pepxml/modifications'
+
+
+=begin
 
 require 'sample_enzyme'
 require 'ms/parser/mzxml'
@@ -861,251 +866,6 @@ class Sequest::PepXML::Parameters
   end
 end
 
-class Sequest::PepXML::Modifications
-  include SpecIDXML
-
-  # 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 :masses_by_diff_mod_hash
-  # a hash, key is [AA_one_letter_symbol.to_sym, difference.to_f]
-  # values are the special_symbols
-  attr_accessor :mod_symbols_hash
-
-  # 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 masses_by_diff_mod hash
-  def initialize(params=nil, modification_symbols_string='')
-    @params = params
-    if @params
-      set_modifications(params, modification_symbols_string)
-    end
-  end
-
-  # set the masses_by_diff_mod and mod_symbols_hash from 
-  def set_hashes(modification_symbols_string)
-
-    @mod_symbols_hash = {}
-    @masses_by_diff_mod = {}
-    if (modification_symbols_string == nil || modification_symbols_string == '')
-      return nil
-    end
-    table = @params.mass_table
-    modification_symbols_string.split(/\)\s+\(/).each do |mod|
-      if mod =~ /\(?(\w+)(.) (.[\d\.]+)\)?/
-        if $1 == 'ct' || $1 == 'nt' 
-          mass_diff = $3.to_f
-          @masses_by_diff_mod[$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
-            @masses_by_diff_mod[aa+symbol_string] = mass_diff + table[aa_as_sym]
-            @mod_symbols_hash[[aa_as_sym, mass_diff]] = symbol_string
-          end
-        end
-      end
-    end
-  end
-
-  # given a bare peptide (no end pieces) returns a ModificationInfo object
-  # e.g. given "]PEPT*IDE", NOT 'K.PEPTIDE.R'
-  # if there are no modifications, returns nil
-  def modification_info(peptide)
-    if @masses_by_diff_mod.size == 0
-      return nil
-    end
-    hash = {}
-    hash[:modified_peptide] = peptide.dup
-    hsh = @masses_by_diff_mod  
-    table = @params.mass_table
-    h = table[:h]  # this? or h_plus ??
-    oh = table[:o] + h
-    ## only the termini can match a single char
-    if hsh.key? peptide[0,1]
-      # AA + H + differential_mod
-      hash[:mod_nterm_mass] = table[peptide[1,1].to_sym] + h + hsh[peptide[0,1]]
-      peptide = peptide[1...(peptide.size)]
-    end
-    if hsh.key? peptide[(peptide.size-1),1]
-      # AA + OH + differential_mod
-      hash[:mod_cterm_mass] = table[peptide[(peptide.size-2),1].to_sym] + oh + hsh[peptide[-1,1]]
-      peptide.slice!( 0..-2 )
-      peptide = peptide[0...(peptide.size-1)]
-    end
-    mod_array = []
-    (0...peptide.size).each do |i|
-      if hsh.key? peptide[i,2]
-        mod_array << Sequest::PepXML::SearchHit::ModificationInfo::ModAminoacidMass.new([ i+1 , hsh[peptide[i,2]] ])
-      end
-    end
-    if mod_array.size > 0
-      hash[:mod_aminoacid_masses] = mod_array
-    end
-    if hash.size > 1  # if there is more than just the modified peptide there
-      Sequest::PepXML::SearchHit::ModificationInfo.new(hash)
-      #Sequest::PepXML::SearchHit::ModificationInfo.new(hash.values_at(:modified_peptide, :mod_aminoacid_masses, :mod_nterm_mass, :mod_cterm_mass)
-    else
-      nil
-    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_table
-
-    ## 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',
-      } 
-      Sequest::PepXML::AAModification.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
-      Sequest::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 @masses_by_diff_mod
-  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_table
-    #################################
-    # 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 << Sequest::PepXML::AAModification.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,
-      }
-      Sequest::PepXML::TerminalModification.new(hash)
-    end
-
-    #########################
-    # COLLECT THEM
-    #########################
-    @aa_mods = static_mods + variable_mods
-    @term_mods = static_terminal_mods + variable_terminal_mods
-  end
-
-  ## Generates the pepxml for static and differential amino acid mods based on
-  ## sequest object
-  def to_pepxml
-    st = ''
-    if @aa_mods
-      st << @aa_mods.map {|v| v.to_pepxml }.join
-    end
-    if @term_mods
-      st << @term_mods.map {|v| v.to_pepxml }.join
-    end
-    st
-  end
-
-end
 
 # Modified aminoacid, static or variable
 # unless otherwise stated, all attributes can be anything
@@ -1456,3 +1216,5 @@ class Sequest::PepXML::SearchHit::ModificationInfo
 end
 
 Sequest::PepXML::SearchHit::ModificationInfo::ModAminoacidMass = Arrayclass.new(%w(position mass))
+
+=end

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

@@ -0,0 +1,247 @@
+require 'ms/ident/pepxml/search_hit/modification_info'
+
+module Ms ; end
+module Ms::Sequest ; end
+class Ms::Sequest::Pepxml ; end
+
+class Ms::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',
+      } 
+      Ms::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
+      Ms::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 << Ms::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,
+      }
+      Ms::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 = Ms::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 << Ms::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
+