mspire 0.7.12 → 0.7.13

data/VERSION

@@ -1 +1 @@
-0.7.12
+0.7.13

data/lib/mspire.rb

@@ -1,5 +1,5 @@
 
-require 'mspire/mass/aa' # requires mspire/mass
+require 'mspire/mass/aa' # requires mspire/mass & therefore mspire/molecular_formula
 
 module Mspire
   VERSION = IO.read(File.join(File.dirname(__FILE__), '..', 'VERSION')).chomp

data/lib/mspire/isotope/aa.rb

@@ -1,10 +1,5 @@
 require 'mspire/molecular_formula'
 
-module Mspire
-  class MolecularFormula < Hash
-  end
-end
-
 
 module Mspire
   class Isotope

data/lib/mspire/molecular_formula.rb

@@ -1,5 +1,4 @@
 require 'mspire/isotope'
-require 'mspire/isotope/aa'
 require 'mspire/mass'
 
 module Mspire
@@ -66,3 +65,5 @@ module Mspire
 
   end
 end
+
+require 'mspire/isotope/aa'

data/lib/mspire/{peak_list.rb → peaklist.rb}

@@ -2,9 +2,9 @@ require 'mspire/bin'
 require 'mspire/peak'
 
 module Mspire
-  # a collection of peak objects.  At a minimum, each peak should respond to
+  # a collection of Peak objects.  At a minimum, each peak should respond to
   # :x and :y
-  class PeakList < Array
+  class Peaklist < Array
 
     def lo_x
       self.first[0]
@@ -38,7 +38,7 @@ module Mspire
     # class methods
     class << self
 
-      # creates a new Mspire::PeakList and coerces each peak into an
+      # creates a new Mspire::Peaklist and coerces each peak into an
       # Mspire::Peak.  If your peaks already behave like peaks you should use
       # .new
       def [](*peaks)
@@ -98,17 +98,17 @@ module Mspire
           Mspire::Peak.new( [bin, bin.data.reduce(0.0) {|sum,peak| sum + peak.y }] )
         end
 
-        pseudo_peaklist = Mspire::PeakList.new(pseudo_peaks)
+        pseudo_peaklist = Mspire::Peaklist.new(pseudo_peaks)
 
         separate_peaklists = pseudo_peaklist.split(opts[:split])
 
         normalize_factor = opts[:normalize] ? peaklists.size : 1
 
         return_data = []
-        final_peaklist = Mspire::PeakList.new unless opts[:only_data]
+        final_peaklist = Mspire::Peaklist.new unless opts[:only_data]
 
         separate_peaklists.each do |pseudo_peaklist|
-          data_peaklist = Mspire::PeakList.new
+          data_peaklist = Mspire::Peaklist.new
           weight_x = 0.0
           tot_intensity = pseudo_peaklist.inject(0.0) {|sum, bin_peak| sum + bin_peak.y }
           #puts "TOT INTENSITY:"
@@ -144,7 +144,7 @@ module Mspire
         [final_peaklist, return_data]
       end
 
-      # returns a new peak_list which has been merged with the others. 
+      # returns a new peaklist which has been merged with the others. 
       # opts[:resolution]) and then segment according to monotonicity (sharing
       # intensity between abutting points).  The  final m/z is the weighted
       # averaged of all the m/z's in each peak.  Valid opts (with default listed
@@ -157,6 +157,7 @@ module Mspire
       #                                     number of spectra
       #     :return_data => false           returns a parallel array containing
       #                                     the peaks associated with each returned peak
+      #     :only_data => false           only returns the binned peaks
       #     :split => :zero|:greedy_y|:share  see Mspire::Peak#split
       #     :centroided => true             treat the data as centroided
       #
@@ -186,8 +187,42 @@ module Mspire
           peaklist
         end
       end
-    end # end class << self
 
+      # takes an array of peaklists, merges them together (like merge), then
+      # returns an array of doublets.  Each doublet is an m/z and an array of
+      # values (parallel to input) of intensities]
+      #
+      # If you are already using tagged peak objects, then you should set
+      # have_tagged_peaks to false (default is true).  The peaks will be
+      # deconvolved based on the sample_id in this case.
+      #
+      #     :have_tagged_peaks => false|true
+      #
+      def merge_and_deconvolve(peaklists, opts={})
+        unless htp=opts.delete(:have_tagged_peaks)
+          peaklists.each_with_index do |peaklist,i|
+            peaklist.map! do |peak|
+              TaggedPeak.new(peak, i)
+            end
+          end
+        end
+
+        # make sure we get the data back out
+        opts[:return_data] = true
+        opts[:only_data] = false
+
+        sample_ids = peaklists.map {|pl| pl.first.sample_id }
+        peaks, data = merge(peaklists, opts)
+        data.zip(peaks).map do |bucket_of_peaks, meta_peak|
+          signal_by_sample_id = Hash.new {|h,k| h[k] = 0.0 }
+          bucket_of_peaks.each do |peak|
+            signal_by_sample_id[peak.sample_id] += peak.y
+          end
+          [meta_peak.x, sample_ids.map {|sample_id| signal_by_sample_id[sample_id] } ]
+        end
+      end
+
+    end # end class << self
 
     # returns an array with the indices outlining each peak.  The first index
     # is the start of the peak, the last index is the last of the peak.
@@ -230,7 +265,7 @@ module Mspire
       peak_inds
     end
 
-    # returns an array of PeakList objects
+    # returns an array of Peaklist objects
     def split_on_zeros(given_peak_boundaries=nil)
       pk_bounds = given_peak_boundaries || peak_boundaries(0.0)
       pk_bounds.map do |indices|
@@ -238,7 +273,7 @@ module Mspire
       end
     end
 
-    # returns an array of PeakList objects
+    # returns an array of Peaklist objects
     # assumes that this is one connected list of peaks (i.e., no
     # zeros/whitespace on the edges or internally)
     #
@@ -255,31 +290,31 @@ module Mspire
       else
         peak_class = first.class
         prev_lm_i = 0  # <- don't worry, will be set to bumped to zero
-        peak_lists = [ self.class.new([self[0]]) ]
+        peaklists = [ self.class.new([self[0]]) ]
         local_min_indices.each do |lm_i|
-          peak_lists.last.push( *self[(prev_lm_i+1)..(lm_i-1)] )
+          peaklists.last.push( *self[(prev_lm_i+1)..(lm_i-1)] )
           case methd
           when :greedy_y
             if self[lm_i-1].y >= self[lm_i+1].y
-              peak_lists.last << self[lm_i]
-              peak_lists << self.class.new
+              peaklists.last << self[lm_i]
+              peaklists << self.class.new
             else
-              peak_lists << self.class.new( [self[lm_i]] )
+              peaklists << self.class.new( [self[lm_i]] )
             end
           when :share
             # for each local min, two new peaks will be created, with
-            # intensity shared between adjacent peak_lists
+            # intensity shared between adjacent peaklists
             lm = self[lm_i]
             sum = self[lm_i-1].y + self[lm_i+1].y
             # push onto the last peaklist its portion of the local min
-            peak_lists.last << peak_class.new( [lm.x, lm.y * (self[lm_i-1].y.to_f/sum)] )
+            peaklists.last << peak_class.new( [lm.x, lm.y * (self[lm_i-1].y.to_f/sum)] )
             # create a new peaklist that contains its portion of the local min
-            peak_lists << self.class.new( [peak_class.new([lm.x, lm.y * (self[lm_i+1].y.to_f/sum)])] )
+            peaklists << self.class.new( [peak_class.new([lm.x, lm.y * (self[lm_i+1].y.to_f/sum)])] )
           end
           prev_lm_i = lm_i
         end
-        peak_lists.last.push(*self[(prev_lm_i+1)...(self.size)] )
-        peak_lists
+        peaklists.last.push(*self[(prev_lm_i+1)...(self.size)] )
+        peaklists
       end
     end
 
@@ -310,7 +345,7 @@ module Mspire
           if indices.size == 2
             no_lm_pklsts << peak
           else # have local minima
-            multipeak = PeakList.new(peak)
+            multipeak = Peaklist.new(peak)
             local_min_inds = indices[1..-2].map {|i| i-indices.first}
             peaklists = multipeak.split_contiguous(split_multipeaks_mthd, local_min_inds)
             no_lm_pklsts.push *peaklists

data/lib/mspire/spectrum_like.rb

@@ -64,7 +64,9 @@ module Mspire
       [@data_arrays[0][array_index], @data_arrays[1][array_index]]
     end
 
-    # yields(mz, inten) across the spectrum, or array of doublets if no block
+    # yields(mz, inten) across the spectrum, or array of doublets if no block.
+    # Note that each peak is merely an array of m/z and intensity.  For a
+    # genuine 
     def peaks(&block)
       @data_arrays[0].zip(@data_arrays[1], &block)
     end
@@ -72,6 +74,25 @@ module Mspire
     alias_method :each, :peaks
     alias_method :each_peak, :peaks
 
+    # returns a bonafide Peaklist object (i.e., each peak is cast as a
+    # Mspire::Peak object).  If peak_id is defined, each peak will be cast
+    # as a TaggedPeak object with the given peak_id
+    def to_peaklist(peak_id=nil)
+      # realize this isn't dry, but it is in such an inner loop it needs to be
+      # as fast as possible.
+      pl = Peaklist.new
+      if peak_id
+        peaks.each_with_index do |peak,i|
+          pl[i] = Mspire::Peak.new( peak )
+        end
+      else
+        peaks.each_with_index do |peak,i|
+          pl[i] = Mspire::TaggedPeak.new( peak, peak_id )
+        end
+      end
+      pl
+    end
+
     # if the mzs and intensities are the same then the spectra are considered
     # equal
     def ==(other)

data/lib/mspire/tagged_peak.rb

@@ -0,0 +1,44 @@
+
+module Mspire
+  # A TaggedPeak has a sample_id attribute.  In the rest of its interface it
+  # behaves like a normal Mspire::Peak.  There are no forward compatible
+  # guarantees if you use the array interface, but currently the TaggedPeak is
+  # arranged internally like this:
+  #
+  #   [x, sample_id, y]
+  #
+  # Note that the object is instantiated like this:
+  #
+  #   TaggedPeak.new( [x,y], sample_id )
+  #
+  # x and y value access are very fast because they are merely aliases against
+  # first and last.
+  class TaggedPeak < Array
+    # the m/z or x value
+    alias_method :x, :first
+    # the intensity or y value
+    alias_method :y, :last
+
+    def x=(val)
+      self[0] = val
+    end
+
+    def y=(val)
+      self[2] = val
+    end
+
+    def initialize(data, sample_id)
+      self[0] = data.first
+      self[1] = sample_id
+      self[2] = data.last
+    end
+
+    def sample_id
+      self[1]
+    end
+
+    def sample_id=(val)
+      self[1] = val
+    end
+  end
+end

data/script/quant_compare_direct_injections.rb

@@ -2,7 +2,8 @@
 
 require 'trollop'
 require 'mspire/mzml'
-require 'mspire/peak_list'
+require 'mspire/peaklist'
+require 'mspire/tagged_peak'
 require 'mspire/peak'
 
 def putsv(*args)
@@ -48,34 +49,6 @@ if ARGV.size == 0
   exit
 end
 
-class TracedPeak < Array
-  # the m/z or x value
-  alias_method :x, :first
-  # the intensity or y value
-  alias_method :y, :last
-
-  def x=(val)
-    self[0] = val
-  end
-
-  def y=(val)
-    self[2] = val
-  end
-
-  def initialize(data, sample_id)
-    self[0] = data.first
-    self[1] = sample_id
-    self[2] = data.last
-  end
-
-  def sample_id
-    self[1]
-  end
-
-  def sample_id=(val)
-    self[1] = val
-  end
-end
 
 files = ARGV.dup
 
@@ -85,52 +58,39 @@ if opts[:sample_ids]
   basename_to_sample_id = YAML.load_file(opts[:sample_ids]) 
 end
 
-index_to_sample_id = {}
-sample_ids = files.each_with_index.map do |filename,index|
+sample_ids = files.map do |filename|
   basename = filename.chomp(File.extname(filename))
-  sample_id = basename_to_sample_id ? basename_to_sample_id[basename] : basename
+  basename_to_sample_id ? basename_to_sample_id[basename] : basename
+end
+
+peaklists = files.map do |filename|
   putsv "processing: #{filename}"
+  bunch_of_peaks = []
   Mspire::Mzml.open(filename) do |mzml|
     mzml.each_with_index do |spec,i|
       if spec.ms_level == 1
-        peaks = spec.peaks
-        #p peaks.size
-        peaks.each do |peak|
-          tp = TracedPeak.new(peak, index)
-          peaklist << tp
-        end
+        bunch_of_peaks.push(*spec.peaks)
       end
     end
   end
-  index_to_sample_id[index] = sample_id
-  sample_id
+  peaklist.sort_by!(&:x)
+  peaklist
 end
 
-putsv "gathered #{peaklist.size} peaks!"
-
-putsv "sorting all peaks"
-peaklist.sort! 
-
 putsv "merging peaks"
 share_method = :greedy_y
 #share_method = :share
 
-
-peaks, data = Mspire::PeakList.merge([peaklist], opts.merge( {:split => share_method, :return_data => true} ))
+ar_of_doublets = Mspire::PeakList.merge_and_deconvolve(peaklists, opts.merge( {:split => share_method, :return_data => true} ))
 
 File.open(opts[:outfile],'w') do |out|
 
   header = ["mzs", *sample_ids]
   out.puts header.join("\t")
 
-  data.zip(peaks) do |bucket_of_peaks, meta_peak|
-
-    signal_by_sample_index = Hash.new {|h,k| h[k] = 0.0 }
-    bucket_of_peaks.each do |peak|
-      signal_by_sample_index[peak.sample_id] += peak.y
-    end
+  ar_of_doublets.each do |mz, ar_of_signals|
 
-    row = [opts[:mz_prefix] + (meta_peak.x + opts[:simple_calibrate]).round(opts[:round_mz]).to_s, *sample_ids.each_with_index.map {|id,index| signal_by_sample_index[index].round(opts[:round_intensity]) }]
+    row = [opts[:mz_prefix] + (mz + opts[:simple_calibrate]).round(opts[:round_mz]).to_s, *ar_of_signals.map {|signal| signal.round(opts[:round_intensity]) }]
     out.puts row.join("\t")
   end
 end

data/spec/mspire/peak_list_spec.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
 
-require 'mspire/peak_list'
+require 'mspire/peaklist'
 require 'mspire/peak'
 
-describe Mspire::PeakList do
+describe Mspire::Peaklist do
 
   describe '#split' do
 
@@ -30,28 +30,28 @@ describe Mspire::PeakList do
 
     it 'outlines peak boundaries' do
 
-      peaklist = Mspire::PeakList[[5.08, 3]]
+      peaklist = Mspire::Peaklist[[5.08, 3]]
       boundaries = peaklist.peak_boundaries
       boundaries.should == [[0,0]]
 
-      peaklist = Mspire::PeakList[[5.08, 3], [5.09, 8]]
+      peaklist = Mspire::Peaklist[[5.08, 3], [5.09, 8]]
       boundaries = peaklist.peak_boundaries
       boundaries.should == [[0,1]]
 
-      peaklist = Mspire::PeakList[*@peaks]
+      peaklist = Mspire::Peaklist[*@peaks]
       boundaries = peaklist.peak_boundaries
       #                      5        8     10       13 14       17     19       22 23       26  27
       #act = [0, 3, 8, 9, 7, 2, 0, 0, 3, 8, 2, 9, 7, 1, 3, 0, 0, 10, 8, 2, 9, 7, 1, 3, 0, 0, 10, 8, 0] 
       boundaries.should == [[1, 5], [8, 10, 13, 14], [17, 19, 22, 23], [26, 27]]
 
       # another case that was failing early on:
-      peaklist = Mspire::PeakList[[5.08, 3], [5.09, 8], [5.1, 2], [5.11, 9], [5.12, 7], [5.13, 1], [5.14, 3]]
+      peaklist = Mspire::Peaklist[[5.08, 3], [5.09, 8], [5.1, 2], [5.11, 9], [5.12, 7], [5.13, 1], [5.14, 3]]
       boundaries = peaklist.peak_boundaries
       boundaries.should == [[0,2,5,6]]
     end
 
     it 'splits on zeros by default' do
-      peaklist = Mspire::PeakList[*@peaks] # <- maybe more like a collection of peaks, but PeakList is flexible
+      peaklist = Mspire::Peaklist[*@peaks] # <- maybe more like a collection of peaks, but Peaklist is flexible
       split_peaklist = peaklist.split
       split_peaklist.size.should == 4
       split_peaklist.should == [
@@ -64,36 +64,36 @@ describe Mspire::PeakList do
 
     # which it should since zeros are the ultimate local min!
     it 'always cleans up surrounding zeros and does not split non-multipeaks' do
-      peak = Mspire::PeakList[*@peaks[0,7]]  # simple
+      peak = Mspire::Peaklist[*@peaks[0,7]]  # simple
       [:share, :greedy_y].each do |multipeak_split_method|
         peaks = peak.split(multipeak_split_method)
-        peaks.first.should be_an_instance_of(Mspire::PeakList)
+        peaks.first.should be_an_instance_of(Mspire::Peaklist)
         peaks.first.to_a.should == [[50.01, 3], [50.02, 8], [50.03, 9], [50.04, 7], [50.05, 2]]
       end
     end
 
-    describe 'splitting a peak_list that is a multipeak' do
+    describe 'splitting a peaklist that is a multipeak' do
       subject do
-        Mspire::PeakList[[50.07, 0], [50.08, 3], [50.09, 8], [50.1, 2], [50.11, 9], [50.12, 7], [50.13, 1], [50.14, 3], [50.15, 0]]
+        Mspire::Peaklist[[50.07, 0], [50.08, 3], [50.09, 8], [50.1, 2], [50.11, 9], [50.12, 7], [50.13, 1], [50.14, 3], [50.15, 0]]
       end
 
       it 'can split a multipeak' do
-        multipeak = Mspire::PeakList[[5.08, 3], [5.09, 8]]
+        multipeak = Mspire::Peaklist[[5.08, 3], [5.09, 8]]
         peaklists = multipeak.split_contiguous(:greedy_y)
         peaklists.should == [[5.08, 3], [5.09, 8]]
 
-        multipeak = Mspire::PeakList[[5.08, 3]]
+        multipeak = Mspire::Peaklist[[5.08, 3]]
         peaklists = multipeak.split_contiguous(:greedy_y)
         peaklists.should == [[5.08, 3]]
 
-        multipeak = Mspire::PeakList[[5.08, 3], [5.09, 8], [5.1, 2], [5.11, 9], [5.12, 7], [5.13, 1], [5.14, 3]]
+        multipeak = Mspire::Peaklist[[5.08, 3], [5.09, 8], [5.1, 2], [5.11, 9], [5.12, 7], [5.13, 1], [5.14, 3]]
         peaklists = multipeak.split_contiguous(:greedy_y)
-        peaklists.all? {|pl| pl.should be_a(Mspire::PeakList) }
+        peaklists.all? {|pl| pl.should be_a(Mspire::Peaklist) }
         peaklists.should == [[[5.08, 3], [5.09, 8]], [[5.1, 2], [5.11, 9], [5.12, 7], [5.13, 1]], [[5.14, 3]]]
 
-        multipeak = Mspire::PeakList[[5.08, 3], [5.09, 8], [5.1, 2], [5.11, 9], [5.12, 7], [5.13, 1], [5.14, 3]]
+        multipeak = Mspire::Peaklist[[5.08, 3], [5.09, 8], [5.1, 2], [5.11, 9], [5.12, 7], [5.13, 1], [5.14, 3]]
         peaklists = multipeak.split_contiguous(:share)
-        peaklists.all? {|pl| pl.should be_a(Mspire::PeakList) }
+        peaklists.all? {|pl| pl.should be_a(Mspire::Peaklist) }
         peaklists.should == [[[5.08, 3], [5.09, 8], [5.1, 2*(8.0/17)]], [[5.1, 2*(9.0/17)], [5.11, 9], [5.12, 7], [5.13, 7.0/10]], [[5.13, 3.0/10], [5.14, 3]]]
 
       end
@@ -133,7 +133,7 @@ describe Mspire::PeakList do
         # test a tie -> goes left!
         peaks = @peaks[7,9]
         peaks[2] = Mspire::Peak.new([peaks[2][0], 9])
-        multipeak2 = Mspire::PeakList[ *peaks ]
+        multipeak2 = Mspire::Peaklist[ *peaks ]
         multipeak2.split(:greedy_y).should == answer
       end
 
@@ -154,34 +154,34 @@ describe Mspire::PeakList do
       list2 = [[9.11, 6], [10.49, 5], [10.71, 7], [13.48, 8]].map {|pair| Mspire::Peak.new pair }
       list3 = [[9.09, 11], [10.51, 9], [10.72, 10], [13.51, 12]].map {|pair| Mspire::Peak.new pair }
 
-      [list1, list2, list3].map {|peaks| Mspire::PeakList.new( peaks ) }
+      [list1, list2, list3].map {|peaks| Mspire::Peaklist.new( peaks ) }
     end
 
     it 'whether we ask for data back or not, the peaklist is equal' do
-      (peaklist1, data) = Mspire::PeakList.merge(subject, :bin_width => 0.08, :bin_unit => :amu, :return_data => true, :split => false) 
-      peaklist2 = Mspire::PeakList.merge(subject, :bin_width => 0.08, :bin_unit => :amu, :split => :zero)
+      (peaklist1, data) = Mspire::Peaklist.merge(subject, :bin_width => 0.08, :bin_unit => :amu, :return_data => true, :split => false) 
+      peaklist2 = Mspire::Peaklist.merge(subject, :bin_width => 0.08, :bin_unit => :amu, :split => :zero)
       peaklist1.should == peaklist2
 
       peaks = [[10.097333333333331, 10.502222222222223, 10.713809523809525, 11.498333333333333], [5.0, 6.0, 7.0, 8.0]].transpose
-      #compare_peaklist_sets(peaklist1, Mspire::PeakList.new(peaks))
+      #compare_peaklist_sets(peaklist1, Mspire::Peaklist.new(peaks))
       #compare_peaklist_sets(data, [[[10.1, 1], [10.11, 5], [10.09, 9]], [[10.5, 2], [10.49, 6], [10.51, 10]], [[10.7, 3], [10.71, 7], [10.72, 11]], [[11.5, 4], [11.48, 8], [11.51, 12]]] )
 
     end
 
     it 'gives one peak with large bin width' do
       [true, false].zip([26.0, 78.0]) do |normalize, inten|
-        peak_list = Mspire::PeakList.merge(subject, :bin_width => 2.5, :bin_unit => :amu, :normalize => normalize, :split => :greedy_y)
-        peak_list.size.should == 1
-        peak_list.first.x.should be_within(0.00000000001).of(11.136153846153846)
-        peak_list.first.y.should == inten
+        peaklist = Mspire::Peaklist.merge(subject, :bin_width => 2.5, :bin_unit => :amu, :normalize => normalize, :split => :greedy_y)
+        peaklist.size.should == 1
+        peaklist.first.x.should be_within(0.00000000001).of(11.136153846153846)
+        peaklist.first.y.should == inten
       end
     end
 
     it 'regardless of split method, the total intensity remains the same' do
       (0.1..2.3).step(0.1).to_a.each do |bw|
         tot_ints = [:zero, :split, :greedy_y].map do |splt|
-          peak_list = Mspire::PeakList.merge(subject, :bin_width => bw, :bin_unit => :amu, :split => :zero)
-          peak_list.map(&:y).reduce(:+)
+          peaklist = Mspire::Peaklist.merge(subject, :bin_width => bw, :bin_unit => :amu, :split => :zero)
+          peaklist.map(&:y).reduce(:+)
         end
         tot_ints.all? {|v| tot_ints.first == v }.should be_true
       end
@@ -191,7 +191,7 @@ describe Mspire::PeakList do
       before = Marshal.load(Marshal.dump(subject))
       subj = Marshal.load(Marshal.dump(subject))
       [:zero, :greedy_y].each do |split_mthd|
-        Mspire::PeakList.merge(subj, :bin_width => 2.2, :bin_unit => :amu, :split => split_mthd, :return_data => true)
+        Mspire::Peaklist.merge(subj, :bin_width => 2.2, :bin_unit => :amu, :split => split_mthd, :return_data => true)
         subj.should == before
       end
     end
@@ -201,9 +201,9 @@ describe Mspire::PeakList do
       it "gives reasonable m/z values with very small binwidths (#{methd})" do
         expected = [[9.09, 3.6666666666666665], [9.1, 0.6666666666666666], [9.11, 2.0], [10.49, 1.6666666666666667], [10.5, 0.3333333333333333], [10.51, 3.0], [10.7, 1.0], [10.71, 2.3333333333333335], [10.72, 3.3333333333333335], [13.48, 2.6666666666666665], [13.5, 1.3333333333333333], [13.51, 4.0]]
         bw = 0.001
-        peak_list = Mspire::PeakList.merge(subject, :bin_width => bw, :bin_unit => :amu, :split => methd)
-        peak_list.size.should == expected.size
-        expected.zip(peak_list) do |exp, act|
+        peaklist = Mspire::Peaklist.merge(subject, :bin_width => bw, :bin_unit => :amu, :split => methd)
+        peaklist.size.should == expected.size
+        expected.zip(peaklist) do |exp, act|
           act.first.should == exp.first
           act.last.should be_within(0.00000000001).of(exp.last)
         end
@@ -211,24 +211,24 @@ describe Mspire::PeakList do
 
       it 'gives reasonable m/z values for large binwidths' do
         bw = 2.2
-        peak_list = Mspire::PeakList.merge(subject, :bin_width => bw, :bin_unit => :amu, :split => methd)
-        (peak_list.last.x > 13.51).should_not be_true
-        (peak_list.size > 2).should_not be_true
+        peaklist = Mspire::Peaklist.merge(subject, :bin_width => bw, :bin_unit => :amu, :split => methd)
+        (peaklist.last.x > 13.51).should_not be_true
+        (peaklist.size > 2).should_not be_true
       end
 
       it 'gives same total intensity' do
         bw = 0.8
         total_intensity = subject.inject(0.0) {|sum,peaklist| sum + peaklist.map(&:y).reduce(:+) }
-        peak_list, data = Mspire::PeakList.merge(subject, :bin_width => bw, :bin_unit => :amu, :split => methd, :normalize => false, :return_data => true)
-        after = peak_list.inject(0.0) {|sum,peak| sum + peak.y }
+        peaklist, data = Mspire::Peaklist.merge(subject, :bin_width => bw, :bin_unit => :amu, :split => methd, :normalize => false, :return_data => true)
+        after = peaklist.inject(0.0) {|sum,peak| sum + peak.y }
         after.should be_within(0.00000001).of(total_intensity)
       end
 
       it 'gives reasonable m/z values for medium-large binwidths' do
         expected = [[10.086296296296297, 18.0], [13.498333333333333, 8.0]]
         bw = 1.3
-        peak_list = Mspire::PeakList.merge(subject, :bin_width => bw, :bin_unit => :amu, :split => methd)
-        expected.zip(peak_list) do |exp, act|
+        peaklist = Mspire::Peaklist.merge(subject, :bin_width => bw, :bin_unit => :amu, :split => methd)
+        expected.zip(peaklist) do |exp, act|
 
           act.first.should == exp.first
           act.last.should be_within(0.00000000001).of(exp.last)
@@ -239,14 +239,14 @@ describe Mspire::PeakList do
 
 
 =begin
-      data = Mspire::PeakList.merge(subject, :bin_width => 1000, :bin_unit => :ppm, :only_data => true)
+      data = Mspire::Peaklist.merge(subject, :bin_width => 1000, :bin_unit => :ppm, :only_data => true)
       # just frozen, and checking for sanity, not checked for perfect, accuracy at this level:
       data.should == [[[10.09, 9]], [[10.1, 1]], [[10.11, 5]], [[10.49, 6]], [[10.5, 2]], [[10.51, 10]], [[10.7, 3]], [[10.71, 7]], [[10.72, 11]], [[11.48, 8]], [[11.5, 4]], [[11.51, 12]]]
 
       [[[10.1, 1], [10.09, 9], [10.11, 5]], [[10.49, 6], [10.5, 2]], [[10.5, 2], [10.51, 10]], [[10.7, 3], [10.71, 7], [10.72, 11]], [[11.48, 8], [11.5, 4]], [[11.5, 4], [11.51, 12]]]
-      #peaklist3 = Mspire::PeakList.merge(subject, :bin_width => 100, :bin_unit => :ppm)
+      #peaklist3 = Mspire::Peaklist.merge(subject, :bin_width => 100, :bin_unit => :ppm)
       #p peaklist3
-      peaklist4 = Mspire::PeakList.merge(subject, :bin_width => 1000, :bin_unit => :ppm, :normalize => false)
+      peaklist4 = Mspire::Peaklist.merge(subject, :bin_width => 1000, :bin_unit => :ppm, :normalize => false)
       peaklist4.should == [[10.097333333333331, 15.0], [10.49111111111111, 6.75], [10.508888888888887, 11.25], [10.713809523809525, 21.0], [11.483333333333334, 9.6], [11.508333333333331, 14.4]] 
 =end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mspire
 version: !ruby/object:Gem::Version
-  version: 0.7.12
+  version: 0.7.13
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-10 00:00:00.000000000 Z
+date: 2012-07-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -282,13 +282,14 @@ files:
 - lib/mspire/mzml/spectrum_list.rb
 - lib/mspire/obo.rb
 - lib/mspire/peak.rb
-- lib/mspire/peak_list.rb
+- lib/mspire/peaklist.rb
 - lib/mspire/plms1.rb
 - lib/mspire/quant/qspec.rb
 - lib/mspire/quant/qspec/protein_group_comparison.rb
 - lib/mspire/spectrum.rb
 - lib/mspire/spectrum/centroid.rb
 - lib/mspire/spectrum_like.rb
+- lib/mspire/tagged_peak.rb
 - lib/mspire/user_param.rb
 - lib/obo/ims.rb
 - lib/obo/ms.rb