mspire 0.3.9 → 0.4.2

data/lib/ms/parser.rb

@@ -86,23 +86,23 @@ module MS::Parser
 
   # 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)
+  def self.new(filetype_version, parse_type, opts={})
     unless filetype_version.is_a? Array
       filetype_version = filetype_and_version(filetype_version)
     end
-    require_and_create_parser(filetype_version, parse_type)
+    require_and_create_parser(filetype_version, parse_type, opts)
   end
 
   private 
 
   # returns a working parser.
-  def self.require_and_create_parser(filetype_version, parse_type)
+  def self.require_and_create_parser(filetype_version, parse_type, opts)
     (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)
+    parser_class.new(parse_type, version, opts)
   end
 
 end

data/lib/ms/precursor.rb

@@ -1,10 +1,25 @@
-require 'array_class'
+require 'arrayclass'
 
 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)) 
+# charge_states are the possible charge states of the precursor
+# parent references a scan
+#                                 0  1         2      3 
+MS::Precursor = Arrayclass.new(%w(mz intensity parent charge_states)) 
 
 class MS::Precursor
+
+  undef :intensity
+  
+  def intensity
+    if self[1].nil?
+      if s = self[2].spectrum
+        self[1] = s.intensity_at_mz(self[0])
+      else
+        nil   # if we didn't read in the spectra, we can't get this value!
+      end
+    end
+    self[1]
+  end
+
 end

data/lib/ms/scan.rb

@@ -1,13 +1,13 @@
-require 'array_class'
+require 'arrayclass'
 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) )
+MS::Scan = Arrayclass.new( %w(num ms_level time start_mz end_mz precursor spectrum) )
 
 # time in seconds
-# everything else in float/int or as array (precursors)
+# everything else in float/int
 
 class MS::Scan
   #@@order = %w(num ms_level time start_mz end_mz prec_mz prec_inten parent spectrum)
@@ -36,18 +36,18 @@ class MS::Scan
     display.compact!
     spec_display = 
       if spectrum
-        spectrum.mz.size
+        spectrum.mzs.size
       else
         'nil'
       end
-    "<MS::Scan:#{__id__} " + display.join(", ") + " precursors=#{precursors.inspect}" + " spectrum(size)=#{spec_display}" + " >"
+    "<MS::Scan:#{__id__} " + display.join(", ") + " precursor=#{precursor.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
+    if precursor then arr << precursor.mz end
+    if x = precursor.intensity then arr << x end
     arr.join(" ")
   end
 

data/lib/ms/spectrum.rb

@@ -10,27 +10,16 @@ class MS::Spectrum
   Unpack_little_endian_double = 'E*'
 
   # m/z's
-  attr_accessor :mz  
+  attr_accessor :mzs  
   # intensities
-  attr_accessor :intensity
+  attr_accessor :intensities
 
-  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) 
+  #######################
+  ## CLASS METHODS:
+  #######################
+  
+  # an already decoded string (ready to be unpacked as floating point numbers)
+  def self.string_to_array(string, precision=32, network_order=true)
     unpack_code = 
       if network_order
         if precision == 32
@@ -45,57 +34,57 @@ class MS::Spectrum
           Unpack_little_endian_double
         end
       end
-    b64d.unpack(unpack_code)
+    string.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)
+  # takes a base64 string and returns an array
+  def self.base64_to_array(b64_string, precision=32, network_order=true)
+    self.string_to_array(Base64.decode64(b64_string), precision, network_order)
   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)
+
+  def self.mzs_and_intensities_from_base64_peaks(b64_string, precision=32, network_order=true)
+    data = base64_to_array(b64_string, precision, network_order)
     sz = data.size/2
-    mz = Array.new(sz)
-    intensity = Array.new(sz)
+    mz_ar = Array.new(sz)
+    intensity_ar = Array.new(sz)
     ndata = []
     my_ind = 0
     data.each_with_index do |dat,ind|
       if (ind % 2) == 0  # even
-        mz[my_ind] = dat
+        mz_ar[my_ind] = dat
       else
-        intensity[my_ind] = dat 
+        intensity_ar[my_ind] = dat 
         my_ind += 1
       end
     end
-    self.new(mz, intensity)
+    [mz_ar, intensity_ar]
   end
 
+  # takes a base64 peaks string and sets spectrum
+  # returns self for chaining
+  def self.from_base64_peaks(b64_string, precision=32, network_order=true)
+    (mz_ar, intensity_ar) = self.mzs_and_intensities_from_base64_peaks(b64_string, precision, network_order)
+    self.new(mz_ar, intensity_ar)
+  end
 
+  def self.from_base64_pair(mz_string, mz_precision, mz_network_order, intensity_string, intensity_precision, intensity_network_order)
+    mz_ar = base64_to_array(mz_string, mz_precision, mz_network_order)
+    inten_ar = base64_to_array(intensity_string, intensity_precision, intensity_network_order)
+    self.new(mz_ar, inten_ar)
+  end
 
+  def initialize(mz_ar=[], intensity_ar=[])
+    @mzs = mz_ar
+    @intensities = intensity_ar
+  end
 
-  ######
-  # NOT REALLY USING RIGHT NOW:
-  ######
+  def has_mz_data?
+    @mzs && (@mzs.size > 0) && (@mzs.first.is_a?(Numeric))
+  end
 
-  # 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
+  def has_intensity_data?
+    @intensities && (@intensities.size > 0) && (@intensities.first.is_a?(Numeric))
   end
 
   # returns the index of the first value matching that m/z.  the argument m/z
@@ -103,17 +92,18 @@ class MS::Spectrum
   # given) but must be at least integer precision (after rounding)
   # implemented as binary search (bsearch from the web)
   def index(mz)
+    mz_ar = mzs
     return_val = nil
-    ind = @mz.bsearch_lower_boundary{|x| x <=> mz }
-    if @mz[ind] == mz
+    ind = mz_ar.bsearch_lower_boundary{|x| x <=> mz }
+    if mz_ar[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))
+      mz_size = mz_ar.size
+      if ((ind < mz_size) and equal_after_rounding?(mz_ar[ind], mz))
         return_val = ind
       else # run the loop
         up = ind
@@ -122,7 +112,7 @@ class MS::Spectrum
           if up >= mz_size
             break
           end
-          mz_up = @mz[up]
+          mz_up = mz_ar[up]
           if (mz_up.ceil  - mz.ceil >= 2)
             break
           else
@@ -138,7 +128,7 @@ class MS::Spectrum
           if dn < 0
             break
           end
-          mz_dn = @mz[dn]
+          mz_dn = mz_ar[dn]
           if (mz.floor - mz_dn.floor >= 2)
             break
           else
@@ -156,7 +146,7 @@ class MS::Spectrum
   # uses index function and returns the intensity at that value
   def intensity_at_mz(mz)
     if x = index(mz)
-      @intensity[x]
+      intensities[x]
     else
       nil
     end
@@ -189,5 +179,206 @@ class MS::Spectrum
     neg_exp10
   end
 
+  ######
+  # NOT REALLY USING RIGHT NOW:
+  ######
+
+  # takes a base64 peaks string and returns an array of [m/z,intensity] 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
+
+end
+
+# This implements a spectrum that stores itself as string data and only
+# evaluates the information when it is called
+class MS::Spectrum::LazyString < MS::Spectrum
+
+  undef mzs=
+  undef intensities=
+
+  # beware that this converts the information in @mz_string every time it is
+  # called
+  def mzs
+    MS::Spectrum.string_to_array(@mz_string, @mz_precision, @mz_network_order)
+  end
+
+  # beware that this converts the information in @intensity_string every time
+  # it is
+  def intensities
+    MS::Spectrum.string_to_array(@intensity_string, @intensity_precision, @intensity_network_order)
+  end
+
+  # this takes a decoded base64 string that is then interpreted when
+  # information is accessed
+  def initialize(mz_string, mz_precision, mz_network_order, intensity_string, intensity_precision, intensity_network_order)
+    @mz_string = mz_string
+    @mz_precision = mz_precision
+    @mz_network_order = mz_network_order
+    @intensity_string = intensity_string
+    @intensity_precision = intensity_precision
+    @intensity_network_order = intensity_network_order
+  end
+  
+  # from mzXML files where information is held in peaks (m/z, intensity,
+  # m/z...)
+  def self.from_base64_peaks(b64_string, precision=32, network_order=true)
+    # decode
+    string = Base64.decode64(b64_string)
+    # split into two strings:
+    bytes_per_number = precision / 8 
+    s_size = string.size
+    num_numbers = s_size / bytes_per_number
+    mz_pieces = Array.new(num_numbers)
+    intensity_pieces = Array.new(num_numbers)
+    index = 0
+    (0...string.size).step(bytes_per_number) do |i|
+      if index % 2 == 0
+        mz_pieces[index] = string[i,bytes_per_number]
+      else
+        intensity_pieces[index] = string[i,bytes_per_number]
+      end
+      index += 1
+    end
+    self.new(mz_pieces.join, precision, network_order, intensity_pieces.join, precision, network_order)
+  end
+
+  # from mzML and mzData style files where mz and intensity information are
+  # kept in different strings.
+  def self.from_base64_pair(b64_mz_string, mz_precision, mz_network_order, b64_intensity_string, intensity_precision, intensity_network_order)
+    self.new(Base64.decode64(b64_mz_string), mz_precision, mz_network_order,  Base64.decode64(b64_intensity_string), intensity_precision, intensity_network_order)
+  end
+
+  def has_mz_data?
+    @mz_string.is_a?(String) && @mz_precision && !@mz_network_order.nil?
+  end
+
+  def has_intensity_data?
+    @intensity_string.is_a?(String) && @intensity_precision && !@intensity_network_order.nil?
+  end
+
+end
+
+module MS::Spectrum::LazyIO
+  def self.new(*args)
+    if args.size == 5  # mzXMl
+      MS::Spectrum::LazyIO::Peaks.new(*args)
+    elsif args.size == 9   # other
+      MS::Spectrum::LazyIO::Pair.new(*args)
+    else
+      raise RunTimeError, "must give 5 or 7 args for peak data and pair data respectively"
+    end
+  end
 end
 
+
+# stores an io object and the start and end indices and only evaluates the
+# spectrum when information is requested
+class MS::Spectrum::LazyIO::Pair < MS::Spectrum
+  include MS::Spectrum::LazyIO
+
+  undef mzs=
+  undef intensities=
+
+  def initialize(io, mz_start_index, mz_num_bytes, mz_precision, mz_network_order, intensity_start_index, intensity_num_bytes, intensity_precision, intensity_network_order)
+    @io = io
+
+    @mz_start_index = mz_start_index
+    @mz_num_bytes = mz_num_bytes
+    @mz_precision = mz_precision
+    @mz_network_order = mz_network_order
+
+    @intensity_start_index = intensity_start_index
+    @intensity_num_bytes = intensity_num_bytes
+    @intensity_precision = intensity_precision
+    @intensity_network_order = intensity_network_order
+
+  end
+
+  # beware that this converts the information on disk every time it is called.  
+  def mzs
+    @io.pos = @mz_start_index
+    b64_string = @io.read(@mz_num_bytes)
+    MS::Spectrum.base64_to_array(b64_string, @mz_precision, @mz_network_order)
+  end
+
+  # beware that this converts the information in @intensity_string every time
+  # it is called.
+  def intensities
+    @io.pos = @intensity_start_index
+    b64_string = @io.read(@intensity_num_bytes)
+    MS::Spectrum.base64_to_array(b64_string, @intensity_precision, @intensity_network_order)
+  end
+
+  def has_mz_data?
+    (!@io.closed?) && @mz_start_index && @mz_num_bytes && @mz_precision && !@mz_network_order.nil?
+  end
+
+  def has_intensity_data?
+    (!@io.closed?) && @intensity_start_index && @intensity_num_bytes && @intensity_precision && !@intensity_network_order.nil?
+  end
+
+end
+
+class MS::Spectrum::LazyIO::Peaks < MS::Spectrum
+  include MS::Spectrum::LazyIO
+
+  undef mzs=
+  undef intensities=
+
+  def initialize(io, start_index, num_bytes, precision, network_order)
+    @io = io
+    @start_index = start_index
+    @num_bytes = num_bytes
+    @precision = precision
+    @network_order = network_order
+  end
+
+  # returns two arrays: an array of m/z values and an array of intensity
+  # values.  This is the preferred way to access mzXML file information under
+  # lazy evaluation
+  def mzs_and_intensities
+    @io.pos = @start_index
+    b64_string = @io.read(@num_bytes)
+    MS::Spectrum.mzs_and_intensities_from_base64_peaks(b64_string, @precision, @network_order)
+  end
+
+  # when using 'io' lazy evaluation on files with m/z and intensity data
+  # interwoven (i.e., mzXML) it is more efficient to call 'mzs_and_intensities'
+  # if you are using both mz and intensity data. 
+  def mzs
+    # TODO: this can be made slightly faster
+    mzs_and_intensities.first
+  end
+
+  # when using 'io' lazy evaluation on files with m/z and intensity data
+  # interwoven (i.e., mzXML) it is more efficient to call
+  # 'mzs_and_intensities'
+  # if you are using both mz and intensity data. 
+  def intensities
+    # TODO: this can be made slightly faster
+    mzs_and_intensities.last  
+  end
+
+
+  def has_mz_data?
+    (!@io.closed?) && @start_index && @num_bytes && @precision && !@network_order.nil?
+  end
+
+  def has_intensity_data?
+    (!@io.closed?) && @start_index && @num_bytes && @precision && !@network_order.nil?
+  end
+
+end

data/lib/mspire.rb

@@ -1,4 +1,4 @@
 
 module Mspire
-  Version = '0.3.9'
+  Version = '0.4.2'
 end

data/lib/spec_id/bioworks.rb

@@ -5,7 +5,7 @@ require 'xmlparser'
 require 'spec_id'
 require 'zlib'
 require 'hash_by'
-require 'array_class'
+require 'arrayclass'
 require 'fasta'
 
 ## have to pre-declare some guys
@@ -377,7 +377,7 @@ class Bioworks::Prot
   end
 end
 
-Bioworks::Pep = ArrayClass.new( %w(sequence mass deltamass charge xcorr deltacn sp rsp ions count tic prots base_name first_scan last_scan peptide_probability file _num_prots _first_prot aaseq) )
+Bioworks::Pep = Arrayclass.new( %w(sequence mass deltamass charge xcorr deltacn sp rsp ions count tic prots base_name first_scan last_scan peptide_probability file _num_prots _first_prot aaseq) )
 # 0=sequence 1=mass 2=deltamass 3=charge 4=xcorr 5=deltacn 6=sp 7=rsp 8=ions 9=count 10=tic 11=prots 12=base_name 13=first_scan 14=last_scan 15=peptide_probability 16=file 17=_num_prots 18=_first_prot 19=aaseq
 
 class Bioworks::Pep

data/lib/spec_id/precision/filter/cmdline.rb

@@ -145,7 +145,14 @@ module SpecID
 
             op.separator ""
             op.separator "OTHER OPTIONS: "
-            op.opt(:interactive) {|v| opts[:interactive] = v }
+            op.opt(:interactive) do |v| 
+              opts[:interactive] = 
+                if v
+                  v 
+                else
+                  true
+                end
+            end
             op.opt(:interactive_verbose) {|v| opts[:interactive_verbose] = v }
             
             op.opt(:top_hit_by) {|v| opts[:top_hit_by] = v.to_sym}

data/lib/spec_id/precision/prob/cmdline.rb

@@ -123,10 +123,10 @@ module SpecID
             end
             postfilter = 
               if spec_id_obj.class == SQTGroup or spec_id_obj.class == Proph::PepSummary
-                puts 'making background estimates with: top_per_scan'
+                #puts 'making background estimates with: top_per_scan'
                 :top_per_scan
               else
-                puts 'making background estimates with: top_per_aaseq_charge'
+                #puts 'making background estimates with: top_per_aaseq_charge'
                 :top_per_aaseq_charge
               end
             opts[:validators] = Validator::Cmdline.prepare_validators(opts, !opts[:ties], opts[:interactive], postfilter, spec_id_obj)

data/lib/spec_id/precision/prob.rb

@@ -216,6 +216,7 @@ class SpecID::Precision::Prob
     else
       out[:probabilities] = probabilities
     end
+    out[:pephits] = ordered_peps  # just in case they want to see
     out[:count] = num_pephits
     out[:aaseqs] = pepstrings
     out[:charges] = pepcharges

data/lib/spec_id/proph/pep_summary.rb

@@ -1,5 +1,5 @@
 
-require 'array_class'
+require 'arrayclass'
 require 'spec_id/sequest/pepxml'
 require 'spec_id/parser/proph'
 
@@ -61,11 +61,10 @@ module Proph
 
   # this is a SpecID::Pep (by interface: not including stuff yet)
   class PepSummary::Pep < Sequest::PepXML::SearchHit
-
     # aaseq is defined in SearchHit
     
     %w(probability fval ntt nmc massd prots).each do |guy|
-      self.add_member(guy) 
+      self.add_member(guy)
     end
 
     # returns self
@@ -91,7 +90,7 @@ module Proph
     end
   end
 
-  ::Proph::PepSummary::Prot = ArrayClass.new(%w(name protein_descr peps))
+  ::Proph::PepSummary::Prot = Arrayclass.new(%w(name protein_descr peps))
 
   class PepSummary::Prot
     def first_entry ; self[0] end ## name

data/lib/spec_id/proph/prot_summary.rb

@@ -3,7 +3,7 @@ require 'hash_by'
 require 'instance_var_set_from_hash'
 require 'axml'
 require 'spec_id'
-require 'array_class'
+require 'arrayclass'
 
 require 'spec_id/parser/proph'
 
@@ -122,7 +122,7 @@ end  # Proph
 
 
 
-Proph::Prot = ArrayClass.new(%w(protein_name probability n_indistinguishable_proteins percent_coverage unique_stripped_peptides group_sibling_id total_number_peptides pct_spectrum_ids description peps))
+Proph::Prot = Arrayclass.new(%w(protein_name probability n_indistinguishable_proteins percent_coverage unique_stripped_peptides group_sibling_id total_number_peptides pct_spectrum_ids description peps))
 
 # note that 'description' is found in the element 'annotation', attribute 'protein_description'
 # NOTE!: unique_stripped peptides is an array rather than + joined string
@@ -142,7 +142,7 @@ end
 
 # this is a pep from a -prot.xml file
 
-Proph::Prot::Pep = ArrayClass.new(%w(peptide_sequence charge initial_probability nsp_adjusted_probability weight is_nondegenerate_evidence n_enzymatic_termini n_sibling_peptides n_sibling_peptides_bin n_instances is_contributing_evidence calc_neutral_pep_mass modification_info prots))
+Proph::Prot::Pep = Arrayclass.new(%w(peptide_sequence charge initial_probability nsp_adjusted_probability weight is_nondegenerate_evidence n_enzymatic_termini n_sibling_peptides n_sibling_peptides_bin n_instances is_contributing_evidence calc_neutral_pep_mass modification_info prots))
 
 class Proph::Prot::Pep
   include SpecID::Pep

data/lib/spec_id/protein_summary.rb

@@ -428,7 +428,7 @@ class ProteinSummary
       op.on("--#{PRECISION_PROGRAM_BASE}", "include output of #{PRECISION_PROGRAM_BASE}.rb,") {|v| opt.precision = v}
       op.separator("                                     type '#{PRECISION_PROGRAM_BASE}.rb' for details")
       op.separator ""
-      op.separator "MSific to ProteinProphet (with no concatenated DB):"
+      op.separator "specific to ProteinProphet (with no concatenated DB):"
       op.on("-c", "--cutoff percent", "false positive predictive rate (FPPR)% for given cutoff") {|v| opt.c = v }
       op.on("--cut_at percent", "only reports proteins within FPPR %") {|v| opt.cut_at = v }
       op.on("--get_annotation", "retrieves annotation by gi code") {|v| opt.get_annotation = v}

data/lib/spec_id/sequest/pepxml.rb

@@ -1206,7 +1206,7 @@ class Sequest::PepXML::SearchDatabase
 
 end
 
-Sequest::PepXML::SpectrumQuery = ArrayClass.new(%w(spectrum start_scan end_scan precursor_neutral_mass index assumed_charge search_results pepxml_version))
+Sequest::PepXML::SpectrumQuery = Arrayclass.new(%w(spectrum start_scan end_scan precursor_neutral_mass index assumed_charge search_results pepxml_version))
 
 class Sequest::PepXML::SpectrumQuery
   include SpecIDXML
@@ -1292,7 +1292,7 @@ class Sequest::PepXML::SpectrumQuery
 end
 
 
-Sequest::PepXML::SearchHit = ArrayClass.new( %w( hit_rank peptide peptide_prev_aa peptide_next_aa protein num_tot_proteins num_matched_ions tot_num_ions calc_neutral_pep_mass massdiff num_tol_term num_missed_cleavages is_rejected deltacnstar xcorr deltacn spscore sprank modification_info spectrum_query) )
+Sequest::PepXML::SearchHit = Arrayclass.new( %w( hit_rank peptide peptide_prev_aa peptide_next_aa protein num_tot_proteins num_matched_ions tot_num_ions calc_neutral_pep_mass massdiff num_tol_term num_missed_cleavages is_rejected deltacnstar xcorr deltacn spscore sprank modification_info spectrum_query) )
 
 # 0=hit_rank 1=peptide 2=peptide_prev_aa 3=peptide_next_aa 4=protein 5=num_tot_proteins 6=num_matched_ions 7=tot_num_ions 8=calc_neutral_pep_mass 9=massdiff 10=num_tol_term 11=num_missed_cleavages 12=is_rejected 13=deltacnstar 14=xcorr 15=deltacn 16=spscore 17=sprank 18=modification_info 19=spectrum_query
 
@@ -1312,7 +1312,7 @@ class Sequest::PepXML::SearchHit
   tmp_verb = $VERBOSE
   $VERBOSE = nil
   def initialize(hash=nil)
-    super(@@arr_size)
+    super(self.class.size)
     if hash
       self[0,20] = [hash[:hit_rank], hash[:peptide], hash[:peptide_prev_aa], hash[:peptide_next_aa], hash[:protein], hash[:num_tot_proteins], hash[:num_matched_ions], hash[:tot_num_ions], hash[:calc_neutral_pep_mass], hash[:massdiff], hash[:num_tol_term], hash[:num_missed_cleavages], hash[:is_rejected], hash[:deltacnstar], hash[:xcorr], hash[:deltacn], hash[:spscore], hash[:sprank], hash[:modification_info], hash[:spectrum_query]]
     end
@@ -1379,7 +1379,7 @@ class Sequest::PepXML::SearchHit
 end
 
 
-Sequest::PepXML::SearchHit::ModificationInfo = ArrayClass.new(%w(modified_peptide mod_aminoacid_masses mod_nterm_mass mod_cterm_mass))
+Sequest::PepXML::SearchHit::ModificationInfo = Arrayclass.new(%w(modified_peptide mod_aminoacid_masses mod_nterm_mass mod_cterm_mass))
 
 # Positions and masses of modifications
 class Sequest::PepXML::SearchHit::ModificationInfo
@@ -1455,4 +1455,4 @@ class Sequest::PepXML::SearchHit::ModificationInfo
   # </modification_info>
 end
 
-Sequest::PepXML::SearchHit::ModificationInfo::ModAminoacidMass = ArrayClass.new(%w(position mass))
+Sequest::PepXML::SearchHit::ModificationInfo::ModAminoacidMass = Arrayclass.new(%w(position mass))