mspire 0.7.7 → 0.7.8

data/VERSION

@@ -1 +1 @@
-0.7.7
+0.7.8

data/lib/mspire/cv/obo.rb

@@ -0,0 +1,20 @@
+
+require 'obo/ms'
+require 'obo/ims'
+require 'obo/unit'
+
+module Mspire
+  module CV
+    module Obo
+
+      # a hash keyed on ID that gives the cv term name
+      NAME = %w(MS IMS Unit).inject({}) do |hash,key|
+        hash.merge! ::Obo.const_get(key).id_to_name 
+      end
+      CAST = %w(MS IMS Unit).inject({}) do |hash,key|
+        hash.merge! ::Obo.const_get(key).id_to_cast
+      end
+
+    end
+  end
+end

data/lib/mspire/cv/param.rb

@@ -1,5 +1,5 @@
-require 'cv/param'
-require 'mspire/cv'
+require 'mspire/cv/param'
+require 'mspire/cv/obo'
 
 module Mspire
   module CV
@@ -28,8 +28,14 @@ module Mspire
           when 3
             Mspire::CV::Param[args.pop]
           end
-        obo_type = args[0][/([A-Za-z]+):/,1]
-        ::CV::Param.new(obo_type, args[0], Mspire::CV::Obo[obo_type][args.first], args[1], unit)
+        acc = args[0]
+        obo_type = acc[/([A-Za-z]+):/,1]
+        val = args[1]
+        if val
+          cast = Mspire::CV::Obo::CAST[acc]
+          (val = val.send(cast)) if cast
+        end
+        ::CV::Param.new(obo_type, args[0], Mspire::CV::Obo::NAME[acc], val, unit)
       end
     end
   end

data/lib/mspire/cv/paramable.rb

@@ -2,6 +2,7 @@ require 'cv/param'
 require 'mspire/user_param'
 require 'mspire/cv/param'
 require 'nokogiri'
+require 'andand'
 
 module Mspire
   module CV
@@ -15,16 +16,48 @@ module Mspire
         cv_params + ref_param_groups.flat_map(&:params) + user_params 
       end
 
+      def params?
+        total_num_params = cv_params.size + 
+          ref_param_groups.reduce(0) {|sum,group| sum + 
+            group.params.size } + user_params.size
+        total_num_params > 0
+      end
+
       def accessionable_params
         cv_params + ref_param_groups.flat_map(&:params)
       end
 
-      def params_by_name
-        params.index_by &:name
+      #def params_by_name
+      #  params.index_by &:name
+      #end
+
+      #def params_by_accession
+      #  accessionable_params.index_by &:accession
+      #end
+      
+      # returns the value if the param exists by that name.  Returns true if
+      # the param exists but has no value. returns false if no param
+      def fetch(name)
+        param = params.find {|param| param.name == name}
+        if param
+          param.value || true
+        else
+          false
+        end
       end
 
-      def params_by_accession
-        accessionable_params.index_by &:accession
+      def fetch_by_accession(acc)
+        param = accessionable_params.find {|v| v.accession == acc }
+        if param
+          param.value || true
+        else
+          false
+        end
+      end
+      alias_method :fetch_by_acc, :fetch_by_accession
+
+      def param?(name)
+        params.any? {|param| param.name == name }
       end
 
       def initialize(opts={params: []})
@@ -34,22 +67,10 @@ module Mspire
         describe_many!(opts[:params])
       end
 
-      # cast may be something like :to_i or :to_f
-      def find_param_value_by_accession(accession, cast=nil)
-        param = accessionable_params.find {|v| v.accession == accession }
-        if param
-          val = param.value
-          cast ? (val && val.send(cast)) : val
-        end
-      end
-
-      def find_param_by_accession(accession)
-        accessionable_params.find {|v| v.accession == accession }
-      end
-
-      def param_exists_by_accession?(accession)
-        accessionable_params.any? {|v| v.accession == accession }
+      def param_by_accession(acc)
+        accessionable_params.find {|v| v.accession == acc }
       end
+      alias_method :param_by_acc, :param_by_accession
 
       # takes an array of values, each of which is fed into describe!
       def describe_many!(array)
@@ -89,7 +110,7 @@ module Mspire
           param = 
             case arg.name
             when 'cvParam'
-              ::CV::Param.new(arg[:cvRef], arg[:accession], arg[:name], arg[:value])
+              Mspire::CV::Param[ arg[:accession], arg[:value] ]
             when 'userParam'
               Mspire::UserParam.new(arg[:name], arg[:value], arg[:type])
             end

data/lib/mspire/mzml.rb

@@ -22,14 +22,14 @@ require 'mspire/mzml/cv'
 require 'mspire/mzml/sample'
 
 module Mspire
-  # Reading an mzxml file:
+  # Reading an mzml file:
   #
   #     Mspire::Mzml.open("somefile.mzML") do |mzml|
   #       mzml.each do |spectrum|
   #         scan = spectrum.scan
   #         spectrum.mzs                  # array of m/zs
   #         spectrum.intensities          # array of intensities
-  #         spectrum.points.each do |mz,intensity|
+  #         spectrum.peaks do |mz,intensity|
   #           puts "mz: #{mz} intensity: #{intensity}" 
   #         end
   #       end

data/lib/mspire/mzml/spectrum.rb

@@ -70,7 +70,7 @@ module Mspire
       # returns the retention time of the first scan object in the scan list
       # *in seconds*!
       def retention_time
-        rt_param = scan_list.first.find_param_by_accession('MS:1000016')
+        rt_param = scan_list.first.param_by_acc('MS:1000016')
         if rt_param
           multiplier = 
             case rt_param.unit.accession
@@ -86,24 +86,24 @@ module Mspire
 
       # returns the ms_level as an Integer
       def ms_level
-        find_param_value_by_accession('MS:1000511', :to_i)
+        fetch_by_acc('MS:1000511')
       end
 
       def centroided?
-        param_exists_by_accession?('MS:1000127')
+        fetch_by_acc('MS:1000127')
       end
 
       def profile?
-        param_exists_by_accession?('MS:1000128')
+        fetch_by_acc('MS:1000128')
       end
 
       # returns the charge state of the first precursor as an integer
       def precursor_charge
-        precursors.andand.first.andand.selected_ions.andand.first.andand.find_param_value_by_accession('MS:1000041', :to_i)
+        precursors.andand.first.andand.selected_ions.andand.first.andand.fetch_by_acc('MS:1000041')
       end
 
       def precursor_mz
-        precursors.andand.first.andand.selected_ions.andand.first.andand.find_param_value_by_accession('MS:1000744', :to_f)
+        precursors.andand.first.andand.selected_ions.andand.first.andand.fetch_by_acc('MS:1000744')
       end
 
       # takes a Nokogiri node and sets relevant properties

data/lib/mspire/peak.rb

@@ -1,108 +1,11 @@
 
-module Mspire ; end
-# an Mspire::Peak instance is an array of contiguous points (where each point is
-# a doublet: an x coordinate and a y coordinate)
-class Mspire::Peak < Array
-
-  # returns an Array of peaks.  Splits peak with 1 or more local minima into
-  # multiple peaks.  When a point is 'shared' between two adjacent peak-ish
-  # areas, the choice of how to resolve multi-peaks (runs of data above
-  # zero) is one of:
-  #
-  #     false/nil => only split on zeros
-  #     :share => give each peak its rightful portion of shared peaks, dividing the
-  #               intensity based on the intensity of adjacent peaks
-  #     :greedy_y => give the point to the peak with highest point next to
-  #                  the point in question. tie goes lower.
-  #
-  # if return_local_minima is true, a parallel array of local minima indices is
-  # returned (only makes sense if split_multipeaks is false)
-  # 
-  # assumes that a new point can be made with an array containing the x
-  # value and the y value.
-  def split(split_multipeaks=false, return_local_minima=false)
-    if split_multipeaks
-      (zeroed_peaks, local_min_ind_ar) = self.split(false, true)
-      $stderr.print "splitting on local minima ..." if $VERBOSE
-      no_local_minima_peaks = zeroed_peaks.zip(local_min_ind_ar).map do |peak, lm_indices|
-        new_peaks = [ peak.class.new ]
-        if lm_indices.size > 0
-          prev_lm_i = -1   # <- it's okay, we don't use until it is zero
-          lm_indices.each do |lm_i|
-            lm = peak[lm_i]
-            point_class = lm.class
-
-            # push onto the last peak all the points from right after the previous local min
-            # to just before this local min
-            new_peaks.last.push( *peak[(prev_lm_i+1)..(lm_i-1)] )
-            before_pnt = peak[lm_i-1]
-            after_pnt = peak[lm_i+1]
-
-            case split_multipeaks
-            when :share
-              sum = before_pnt[1] + after_pnt[1]
-              # push onto the last peak its portion of the local min
-              new_peaks.last << point_class.new( [lm[0], lm[1] * (before_pnt[1].to_f/sum)] )
-              # create a new peak that contains its portion of the local min
-              new_peaks << self.class.new( [point_class.new([lm[0], lm[1] * (after_pnt[1].to_f/sum)])] )
-              prev_lm_i = lm_i
-            when :greedy_y
-              if before_pnt[1] >= after_pnt[1]
-                new_peaks.last << lm
-                new_peaks << self.class.new
-                prev_lm_i = lm_i
-              else
-                new_peaks << self.class.new( [lm] )
-                prev_lm_i = lm_i
-              end
-            else
-              raise ArgumentError, "only recognize :share, :greedy_y, or false for the arg in #split(arg)"
-            end
-          end
-          new_peaks.last.push( *peak[(prev_lm_i+1)...peak.size] )
-          new_peaks
-        else
-          [peak]
-        end
-      end.flatten(1) # end zip
-      $stderr.puts "now #{no_local_minima_peaks.size} peaks." if $VERBOSE
-      no_local_minima_peaks 
-    else
-      $stderr.print "splitting on zeros..." if $VERBOSE
-      # first, split the peaks based on zero intensity values 
-      # and simultaneously keep track of the local minima within each
-      # resulting peak
-      peaks = []
-      local_min_ind_ar = []
-      in_peak = false
-      self.each_with_index do |point, index|
-        previous_y = self[index - 1][1]
-        if point[1] > 0
-          if !in_peak
-            in_peak = 0
-            peaks << self.class.new([point])
-            local_min_ind_ar << []
-          else
-            peaks.last << point
-            # if on_upslope(previous_y, point[1])
-            if previous_y < point[1]
-              # If we were previously on a downslope and we are now on an upslope
-              # then the previous index is a local min
-              prev_previous_y = self[index - 2][1]
-              # on_downslope(prev_previous_y, previous_y)
-              if prev_previous_y > previous_y
-                # We have found a local min
-                local_min_ind_ar.last << (in_peak-1)
-              end
-            end # end if (upslope)
-          end # end if !in_peak
-          in_peak += 1
-        elsif in_peak
-          in_peak = false
-        end # end if point[1] > 0
-      end
-      $stderr.puts "#{peaks.size} no-whitespace-inside peaks." if $VERBOSE
-      return_local_minima ? [peaks, local_min_ind_ar] : peaks
-    end # 
-  end # def split
+module Mspire
+  # A peak is typically a doublet: an x value and a y value.  In a spectrum
+  # this will be an m/z and intensity.  In a chromatogram this will be a
+  # retention time and an intensity.  (This class can be subclassed if
+  # desired)
+  class Peak < Array
+    alias_method :x, :first
+    alias_method :y, :last
+  end
 end

data/lib/mspire/peak_list.rb

@@ -0,0 +1,260 @@
+require 'mspire/bin'
+
+module Mspire
+  # a collection of peak objects
+  class PeakList < Array
+
+    def lo_x
+      self.first[0]
+    end
+
+    def hi_x
+      self.last[0]
+    end
+
+    DEFAULT_MERGE = {
+      :bin_width => 5,
+      :bin_unit => :ppm,
+      :normalize => true,
+      :return_data => false,
+      :split => :share,
+      :centroided => true,
+    }
+
+    class << self
+
+      def create_bins(peaklists, opts)
+        min, max = min_max_mz(peaklists)
+
+        divisions = []
+        bin_width = opts[:bin_width]
+        use_ppm = (opts[:bin_unit] == :ppm)
+        current_mz = min
+        loop do
+          if current_mz >= max
+            divisions << max
+            break
+          else
+            divisions << current_mz
+            current_mz += ( use_ppm ? current_mz./(1e6).*(bin_width) : bin_width )
+          end
+        end
+        # make each bin exclusive so there is no overlap
+        bins = divisions.each_cons(2).map {|pair| Mspire::Bin.new(*pair, true) }
+        # make the last bin *inclusive* of the terminating value
+        bins[-1] = Mspire::Bin.new(bins.last.begin, bins.last.end)
+        bins
+      end
+
+      def min_max_mz(peaklists)
+        # find the min and max across all spectra
+        first_peaklist = peaklists.first
+        min = first_peaklist.first[0]; max = first_peaklist.last[0]
+        peaklists.each do |peaklist|
+          min = peaklist.lo_x if peaklist.lo_x < min
+          max = peaklist.hi_x if peaklist.hi_x > max
+        end
+        [min, max]
+      end
+
+      def merge_centroids(peaklists, opts={})
+
+        # Create Mspire::Bin objects
+        bins = opts[:bins] ? opts[:bins] : create_bins(peaklists, opts)
+
+        peaklists.each do |peaklist|
+          Mspire::Bin.bin(bins, peaklist, &:first)
+        end
+
+        pseudo_peaks = bins.map do |bin|
+          [bin, bin.data.reduce(0.0) {|sum,peak| sum + peak[1] }]
+        end
+
+        pseudo_peaklist = Mspire::PeakList.new(pseudo_peaks)
+
+        peak_lists = pseudo_peaklist.split(opts[:split])
+
+        return_data = []
+        final_peaklist = []
+        peak_lists.each_with_index do |peak_list,i|
+          #peaks.each do |peak|
+          tot_intensity = peak_list.map(&:last).reduce(:+)
+          return_data_per_peak = [] if opts[:return_data]
+          weighted_mz = 0.0
+          peak_list.each do |peak|
+            pre_scaled_intensity = peak[0].data.reduce(0.0) {|sum,v| sum + v.last }
+            post_scaled_intensity = peak[1]
+            # some peaks may have been shared.  In this case the intensity
+            # for that peak was downweighted.  However, the actual data
+            # composing that peak is not altered when the intensity is
+            # shared.  So, to calculate a proper weighted avg we need to
+            # downweight the intensity of any data point found within a bin
+            # whose intensity was scaled.
+            correction_factor = 
+              if pre_scaled_intensity != post_scaled_intensity
+                post_scaled_intensity / pre_scaled_intensity
+              else
+                1.0
+              end
+
+            return_data_per_peak.push(*peak[0].data) if opts[:return_data]
+
+            peak[0].data.each do |lil_point|
+              weighted_mz += lil_point[0] * ( (lil_point[1].to_f * correction_factor) / tot_intensity)
+            end
+          end
+          return_data << return_data_per_peak if opts[:return_data]
+          final_peaklist << Mspire::Peak.new([weighted_mz, tot_intensity])
+        end
+        [final_peaklist, return_data]
+      end
+
+      # returns a new peak_list 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
+      # first):
+      #
+      #     :bin_width => 5 
+      #     :bin_unit => :ppm | :amu        interpret bin_width as ppm or amu
+      #     :bins => array of Mspire::Bin objects  for custom bins (overides other bin options)
+      #     :normalize => true              if true, divides total intensity by 
+      #                                     number of spectra
+      #     :return_data => false           returns a parallel array containing
+      #                                     the peaks associated with each returned peak
+      #     :split => false | :share | :greedy_y   see Mspire::Peak#split
+      #     :centroided => true             treat the data as centroided
+      #
+      # The binning algorithm is roughly the fastest possible algorithm that
+      # would allow for arbitrary, non-constant bin widths (a ratcheting
+      # algorithm O(n + m))
+      #
+      # Assumes the peaklists are already sorted by m/z.
+      def merge(peaklists, opts={})
+        opts = DEFAULT_MERGE.merge(opts)
+
+        (peaklist, returned_data) =  
+          if opts[:centroided]
+            merge_centroids(peaklists, opts)
+          else
+            raise NotImplementedError, "need to implement profile merging"
+          end
+
+        if opts[:normalize]
+          sz = peaklists.size
+          peaklist.each {|peak| peak[1] = peak[1].to_f / sz }
+        end
+        if opts[:return_data]
+          $stderr.puts "returning peaklist (#{peaklist.size}) and data" if $VERBOSE
+          [peaklist, returned_data]
+        else
+          $stderr.puts "returning peaklist (#{peaklist.size})" if $VERBOSE
+          peaklist 
+        end
+      end
+    end
+
+
+    # returns an Array of peaklist objects.  Splits run of 1 or more local
+    # minima into multiple peaklists.  When a point is 'shared' between two
+    # adjacent hill-ish areas, the choice of how to resolve multi-hills (runs
+    # of data above zero) is one of:
+    #
+    #     false/nil => only split on zeros
+    #     :share => give each peak its rightful portion of shared peaks, dividing the
+    #               intensity based on the intensity of adjacent peaks
+    #     :greedy_y => give the point to the peak with highest point next to
+    #                  the point in question. tie goes lower.
+    #
+    # if return_local_minima is true, a parallel array of local minima indices is
+    # returned (only makes sense if split_multipeaks is false)
+    # 
+    # assumes that a new peak can be made with an array containing the x
+    # value and the y value.
+    def split(split_multipeaks=false, return_local_minima=false)
+      if split_multipeaks
+        (zeroed_peaks, local_min_ind_ar) = self.split(false, true)
+        $stderr.print "splitting on local minima ..." if $VERBOSE
+        no_local_minima_peaks = zeroed_peaks.zip(local_min_ind_ar).map do |peak, lm_indices|
+          new_peaks = [ peak.class.new ]
+          if lm_indices.size > 0
+            prev_lm_i = -1   # <- it's okay, we don't use until it is zero
+            lm_indices.each do |lm_i|
+              lm = peak[lm_i]
+              point_class = lm.class
+
+              # push onto the last peak all the points from right after the previous local min
+              # to just before this local min
+              new_peaks.last.push( *peak[(prev_lm_i+1)..(lm_i-1)] )
+              before_pnt = peak[lm_i-1]
+              after_pnt = peak[lm_i+1]
+
+              case split_multipeaks
+              when :share
+                sum = before_pnt[1] + after_pnt[1]
+                # push onto the last peak its portion of the local min
+                new_peaks.last << point_class.new( [lm[0], lm[1] * (before_pnt[1].to_f/sum)] )
+                # create a new peak that contains its portion of the local min
+                new_peaks << self.class.new( [point_class.new([lm[0], lm[1] * (after_pnt[1].to_f/sum)])] )
+                prev_lm_i = lm_i
+              when :greedy_y
+                if before_pnt[1] >= after_pnt[1]
+                  new_peaks.last << lm
+                  new_peaks << self.class.new
+                  prev_lm_i = lm_i
+                else
+                  new_peaks << self.class.new( [lm] )
+                  prev_lm_i = lm_i
+                end
+              else
+                raise ArgumentError, "only recognize :share, :greedy_y, or false for the arg in #split(arg)"
+              end
+            end
+            new_peaks.last.push( *peak[(prev_lm_i+1)...peak.size] )
+            new_peaks
+          else
+            [peak]
+          end
+        end.flatten(1) # end zip
+        $stderr.puts "now #{no_local_minima_peaks.size} peaks." if $VERBOSE
+        no_local_minima_peaks 
+      else
+        $stderr.print "splitting on zeros..." if $VERBOSE
+        # first, split the peaks based on zero intensity values 
+        # and simultaneously keep track of the local minima within each
+        # resulting peak
+        peak_lists = []
+        local_min_ind_ar = []
+        in_peak = false
+        self.each_with_index do |peak, index|
+          previous_y = self[index - 1][1]
+          if peak[1] > 0
+            if !in_peak
+              in_peak = 0
+              peak_lists << self.class.new([peak])
+              local_min_ind_ar << []
+            else
+              peak_lists.last << peak
+              # if on_upslope(previous_y, point[1])
+              if previous_y < peak[1]
+                # If we were previously on a downslope and we are now on an upslope
+                # then the previous index is a local min
+                prev_previous_y = self[index - 2][1]
+                # on_downslope(prev_previous_y, previous_y)
+                if prev_previous_y > previous_y
+                  # We have found a local min
+                  local_min_ind_ar.last << (in_peak-1)
+                end
+              end # end if (upslope)
+            end # end if !in_peak
+            in_peak += 1
+          elsif in_peak
+            in_peak = false
+          end # end if point[1] > 0
+        end
+        $stderr.puts "#{peak_lists.size} no-whitespace-inside peak_lists." if $VERBOSE
+        return_local_minima ? [peak_lists, local_min_ind_ar] : peak_lists
+      end # 
+    end # def split
+  end
+end

data/lib/mspire/spectrum.rb

@@ -1,173 +1,19 @@
 require 'mspire/spectrum_like'
-require 'bsearch'
-require 'mspire/bin'
-require 'mspire/peak'
 
 module Mspire
-  # note that a point is an [m/z, intensity] doublet.
-  # A peak is considered a related string of points
   class Spectrum
     include Mspire::SpectrumLike
 
-    DEFAULT_MERGE = {
-      :bin_width => 5,
-      :bin_unit => :ppm,
-      :normalize => true,
-      :return_data => false,
-      :split => :share
-    }
-
-    class << self
-
-      def from_points(ar_of_doublets)
-        _mzs = []
-        _ints = []
-        ar_of_doublets.each do |mz, int|
-          _mzs << mz
-          _ints << int
-        end
-        self.new([_mzs, _ints])
-      end
-
-
-      # returns a new spectrum which has been merged with the others.  If the
-      # spectra are centroided (just checks the first one and assumes the others
-      # are the same) then it will bin the points (bin width determined by
-      # 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
-      # first):
-      #
-      #     :bin_width => 5 
-      #     :bin_unit => :ppm | :amu        interpret bin_width as ppm or amu
-      #     :bins => array of Bin objects   for custom bins (overides other bin options)
-      #     :normalize => false             if true, divides total intensity by 
-      #                                     number of spectra
-      #     :return_data => false           returns a parallel array containing
-      #                                     the peaks associated with each returned point
-      #     :split => false | :share | :greedy_y   see Mspire::Peak#split
-      #
-      # The binning algorithm is the fastest possible algorithm that would allow
-      # for arbitrary, non-constant bin widths (a ratcheting algorithm O(n + m))
-      def merge(spectra, opts={})
-        opt = DEFAULT_MERGE.merge(opts)
-        (spectrum, returned_data) =  
-          unless spectra.first.centroided? == false
-            # find the min and max across all spectra
-            first_mzs = spectra.first.mzs
-            min = first_mzs.first ; max = first_mzs.last
-            spectra.each do |spectrum| 
-              mzs = spectrum.mzs
-              min = mzs.first if mzs.first < min
-              max = mzs.last if mzs.last > max
-            end
-
-            # Create Bin objects
-            bins = 
-              if opt[:bins]
-                opt[:bins]
-              else
-                divisions = []
-                bin_width = opt[:bin_width]
-                use_ppm = (opt[:bin_unit] == :ppm)
-                current_mz = min
-                loop do
-                  if current_mz >= max
-                    divisions << max
-                    break
-                  else
-                    divisions << current_mz
-                    current_mz += ( use_ppm ? current_mz./(1e6).*(bin_width) : bin_width )
-                  end
-                end
-                # make each bin exclusive so there is no overlap
-                bins = divisions.each_cons(2).map {|pair| Bin.new(*pair, true) }
-                # make the last bin *inclusive* of the terminating value
-                bins[-1] = Bin.new(bins.last.begin, bins.last.end)
-                bins
-              end
-
-            spectra.each do |spectrum|
-              Bin.bin(bins, spectrum.points, &:first)
-            end
-
-            pseudo_points = bins.map do |bin|
-              #int = bin.data.reduce(0.0) {|sum,point| sum + point.last }.round(3)   # <- just for info:
-              [bin, bin.data.reduce(0.0) {|sum,point| sum + point.last }]
-            end
-
-            #p_mzs = [] 
-            #p_ints = [] 
-            #p_num_points = [] 
-            #pseudo_points.each do |psp|
-            #  p_mzs << ((psp.first.begin + psp.first.end)/2)
-            #  p_ints << psp.last
-            #  p_num_points <<  psp.first.data.size
-            #end
-
-            #File.write("file_#{opt[:bin_width]}_to_plot.txt", [p_mzs, p_ints, p_num_points].map {|ar| ar.join(' ') }.join("\n"))
-            #abort 'here'
-
-
-            peaks = Mspire::Peak.new(pseudo_points).split(opt[:split])
-
-            return_data = []
-            _mzs = [] ; _ints = []
-
-            #p peaks[97]
-            #puts "HIYA"
-            #abort 'here'
-
-            peaks.each_with_index do |peak,i|
-              #peaks.each do |peak|
-              tot_intensity = peak.map(&:last).reduce(:+)
-              return_data_per_peak = [] if opt[:return_data]
-              weighted_mz = 0.0
-              peak.each do |point|
-                pre_scaled_intensity = point[0].data.reduce(0.0) {|sum,v| sum + v.last }
-                post_scaled_intensity = point[1]
-                # some peaks may have been shared.  In this case the intensity
-                # for that peak was downweighted.  However, the actually data
-                # composing that peak is not altered when the intensity is
-                # shared.  So, to calculate a proper weighted avg we need to
-                # downweight the intensity of any data point found within a bin
-                # whose intensity was scaled.
-                correction_factor = 
-                  if pre_scaled_intensity != post_scaled_intensity
-                    post_scaled_intensity / pre_scaled_intensity
-                  else
-                    1.0
-                  end
-
-                return_data_per_peak.push(*point[0].data) if opt[:return_data]
-
-                point[0].data.each do |lil_point|
-                  weighted_mz += lil_point[0] * ( (lil_point[1].to_f * correction_factor) / tot_intensity)
-                end
-              end
-              return_data << return_data_per_peak if opt[:return_data]
-              _mzs << weighted_mz
-              _ints << tot_intensity
-            end
-            [Spectrum.new([_mzs, _ints]), return_data]
-          else
-            raise NotImplementedError, "the way to do this is interpolate the profile evenly and sum"
-          end
-
-        if opt[:normalize]
-          sz = spectra.size
-          spectrum.intensities.map! {|v| v.to_f / sz }
-        end
-        if opt[:return_data]
-          $stderr.puts "returning spectrum (#{spectrum.mzs.size}) and data" if $VERBOSE
-          [spectrum, return_data]
-        else
-          $stderr.puts "returning spectrum (#{spectrum.mzs.size})" if $VERBOSE
-          spectrum
-        end
+    def self.from_peaklist(peaklist)
+      _mzs = []
+      _ints = []
+      peaklist.each do |mz, int|
+        _mzs << mz
+        _ints << int
       end
-
+      self.new([_mzs, _ints])
     end
+
   end
 end
 

data/lib/mspire/spectrum_like.rb

@@ -1,3 +1,5 @@
+require 'bsearch'
+
 module Mspire
   module SpectrumLike
     include Enumerable
@@ -63,12 +65,12 @@ module Mspire
     end
 
     # yields(mz, inten) across the spectrum, or array of doublets if no block
-    def points(&block)
+    def peaks(&block)
       @data_arrays[0].zip(@data_arrays[1], &block)
     end
 
-    alias_method :each, :points
-    alias_method :each_point, :points
+    alias_method :each, :peaks
+    alias_method :each_peak, :peaks
 
     # if the mzs and intensities are the same then the spectra are considered
     # equal
@@ -91,9 +93,9 @@ module Mspire
     # instruments are bad about this)
     # returns self
     def sort!
-      _points = points.to_a
-      _points.sort!
-      _points.each_with_index {|(mz,int), i| @data_arrays[0][i] = mz ; @data_arrays[1][i] = int }
+      _peaks = peaks.to_a
+      _peaks.sort!
+      _peaks.each_with_index {|(mz,int), i| @data_arrays[0][i] = mz ; @data_arrays[1][i] = int }
       self
     end
 
@@ -134,9 +136,5 @@ module Mspire
       find_all_nearest_index(val).map {|i| mzs[i] }
     end
 
-    # uses Mspire::Spectrum.merge
-    def merge(other_spectra, opts={})
-      Mspire::Spectrum.merge([self, *other_spectra], opts)
-    end
   end
 end

data/lib/obo/ontology.rb

@@ -1,5 +1,35 @@
 require 'obo' # the gem obo
 
+module Obo
+  class Stanza
+
+    def cast_method
+      xref = @tagvalues['xref'].first
+      @cast_method = 
+        if xref.nil? || (@cast_method == false)
+          false
+        else
+          if @cast_method
+            @cast_method
+          else
+            case xref[/value-type:xsd\\:([^\s]+) /, 1]
+            when 'float'  ; :to_f
+            when 'int'    ; :to_i
+            when 'string' ; :to_s
+            else          ; false
+            end
+          end
+        end
+    end
+
+    # returns the value cast based on rules in first xref
+    # no casting performed if there is no xref
+    def cast(val)
+      @cast_method ? val.send(@cast_method) : val
+    end
+  end
+end
+
 module Obo
   class Ontology
     DIR = File.expand_path(File.dirname(__FILE__) + '/../../obo')
@@ -16,10 +46,16 @@ module Obo
     def id_to_name
       @id_to_name ||= build_hash('id', 'name')
     end
+    
+    def id_to_cast
+      @id_to_cast ||= Hash[ id_to_element.map {|id,el| [id, el.cast_method] } ]
+    end
+
     # returns a name to id Hash
     def name_to_id
       @name_to_id ||= build_hash('name', 'id')
     end
+
     def id_to_element
       @id_to_element ||= build_hash('id', nil)
     end

data/mspire.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "mspire"
-  s.version = "0.7.7"
+  s.version = "0.7.8"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["John T. Prince", "Simon Chiang"]
-  s.date = "2012-03-27"
+  s.date = "2012-03-29"
   s.description = "mass spectrometry proteomics, lipidomics, and tools, a rewrite of mspire, merging of ms-* gems"
   s.email = "jtprince@gmail.com"
   s.executables = ["mzml_to_imzml"]
@@ -31,7 +31,7 @@ Gem::Specification.new do |s|
     "lib/merge.rb",
     "lib/mspire.rb",
     "lib/mspire/bin.rb",
-    "lib/mspire/cv.rb",
+    "lib/mspire/cv/obo.rb",
     "lib/mspire/cv/param.rb",
     "lib/mspire/cv/paramable.rb",
     "lib/mspire/digester.rb",
@@ -102,7 +102,7 @@ Gem::Specification.new do |s|
     "lib/mspire/mzml/spectrum_list.rb",
     "lib/mspire/obo.rb",
     "lib/mspire/peak.rb",
-    "lib/mspire/peak/point.rb",
+    "lib/mspire/peak_list.rb",
     "lib/mspire/plms1.rb",
     "lib/mspire/quant/qspec.rb",
     "lib/mspire/quant/qspec/protein_group_comparison.rb",
@@ -123,7 +123,9 @@ Gem::Specification.new do |s|
     "script/mzml_read_binary.rb",
     "spec/cv/param_spec.rb",
     "spec/mspire/bin_spec.rb",
+    "spec/mspire/cv/obo_spec.rb",
     "spec/mspire/cv/param_spec.rb",
+    "spec/mspire/cv/paramable_spec.rb",
     "spec/mspire/digester_spec.rb",
     "spec/mspire/error_rate/qvalue_spec.rb",
     "spec/mspire/fasta_spec.rb",
@@ -148,7 +150,7 @@ Gem::Specification.new do |s|
     "spec/mspire/mzml/source_file_spec.rb",
     "spec/mspire/mzml/spectrum_spec.rb",
     "spec/mspire/mzml_spec.rb",
-    "spec/mspire/peak_spec.rb",
+    "spec/mspire/peak_list_spec.rb",
     "spec/mspire/plms1_spec.rb",
     "spec/mspire/quant/qspec_spec.rb",
     "spec/mspire/spectrum_spec.rb",

data/spec/mspire/cv/obo_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+require 'mspire/cv/obo'
+
+describe 'Mspire::CV::Obo' do
+  it 'finds names based on id' do
+    id_to_name = Mspire::CV::Obo::NAME
+    id_to_name.should be_a(Hash)
+    id_to_name['MS:1000005'].should == 'sample volume'
+  end
+
+  it 'finds casts based on id' do
+    id_to_cast = Mspire::CV::Obo::CAST
+    id_to_cast.should be_a(Hash)
+    id_to_cast['MS:1000005'].should == :to_f
+  end
+
+end

data/spec/mspire/cv/param_spec.rb

@@ -19,5 +19,17 @@ describe Mspire::CV::Param do
       param2.unit.accession.should == 'UO:0000024'
     end
 
+    it 'casts values based on info in the obo itself' do
+      param = Mspire::CV::Param['MS:1000005', "2.2"]
+      param.value.should == 2.2
+      param.value.should be_a(Float)
+      param = Mspire::CV::Param['MS:1000041', "3"]
+      param.value.should be_a(Integer)
+      param.value.should == 3
+      # doesn't get greedy about casting things like nil
+      param = Mspire::CV::Param['MS:1000041', nil]
+      param.value.should be_nil
+    end
+
   end
 end

data/spec/mspire/cv/paramable_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+require 'mspire/cv/paramable'
+require 'mspire/cv/param'
+require 'mspire/user_param'
+require 'mspire/mzml/referenceable_param_group'
+
+class MockObject
+  include Mspire::CV::Paramable
+end
+
+describe 'Mspire::CV::Paramable' do
+
+  subject do
+    paramable = MockObject.new :params => ['MS:1000007', ['MS:1000511', 2]]
+    paramable.user_params << Mspire::UserParam.new('hello', 477)
+    paramable.ref_param_groups << Mspire::Mzml::ReferenceableParamGroup.new('id1', :params => [['MS:1000512', 'filter string']])
+    paramable
+  end
+
+  it 'can be initialized with different types of params' do
+    subject.cv_params.size.should == 2
+    subject.ref_param_groups.size.should == 1
+    subject.user_params.size.should == 1
+  end
+
+  it '#params grabs all params' do
+    params = subject.params
+    params.size.should == 4
+    params.map(&:class).uniq.size.should == 2
+  end
+
+  it '#params? asks if there are any' do
+    subject.params?.should be_true
+  end
+
+  it '#accessionable_params returns those with accession numbers' do
+    subject.accessionable_params.size.should == 3
+  end
+
+  it '#param finds the value or true if param name exists' do
+    # doesn't take accessions!
+    subject.fetch('MS:1000511').should be_false
+    subject.fetch('ms level').should == 2
+    subject.fetch('inlet type').should be_true
+  end
+
+  it '#params? tells if has any' do
+    subject.params?.should be_true
+    mine = subject.dup
+    [:cv_params, :user_params, :ref_param_groups].each do |key|
+      mine.send("#{key}=", []) 
+    end
+    mine.params?.should be_false
+  end
+end
+

data/spec/mspire/mzml_spec.rb

@@ -40,10 +40,11 @@ describe Mspire::Mzml do
 
       it 'goes through spectrum with #each or #each_spectrum' do
         mz_sizes = [20168, 315, 634]
-        centroided = [false, true, true]
+        centroided_list = [false, true, true]
         @mzml.each do |spec|
           spec.mzs.size.should == mz_sizes.shift
-          spec.centroided?.should == centroided.shift
+          centroided = centroided_list.shift
+          spec.centroided?.should == centroided
         end
       end
 
@@ -71,7 +72,7 @@ describe Mspire::Mzml do
 
       it 'can gracefully determine the m/z with highest peak in select scans' do
         highest_mzs = Mspire::Mzml.foreach(@file).select {|v| v.ms_level > 1 }.map do |spec|
-          spec.points.sort_by(&:last).first.first
+          spec.peaks.sort_by(&:last).first.first
         end
         highest_mzs.map(&:round).should == [453, 866]
       end

data/spec/mspire/{peak_spec.rb → peak_list_spec.rb}

@@ -1,9 +1,9 @@
 require 'spec_helper'
 
+require 'mspire/peak_list'
 require 'mspire/peak'
-require 'mspire/peak/point'
 
-describe Mspire::Peak do
+describe Mspire::PeakList do
 
   describe '#split' do
 
@@ -25,11 +25,11 @@ describe Mspire::Peak do
         mz += diff
       end
       @xs.map! {|mz| mz.round(2) }
-      @points = @xs.zip(@intensities).map {|pair| Mspire::Peak::Point.new(pair) }
+      @peaks = @xs.zip(@intensities).map {|pair| Mspire::Peak.new(pair) }
     end
 
     it 'splits on zeros by default' do
-      peak = Mspire::Peak.new(@points) # <- maybe more like a collection of peaks, but Peak is flexible
+      peak = Mspire::PeakList.new(@peaks) # <- maybe more like a collection of peaks, but PeakList is flexible
       peaks = peak.split
       peaks.size.should == 4
       peaks.should == [
@@ -46,17 +46,17 @@ describe Mspire::Peak 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::Peak.new(@points[0,7])  # simple
+      peak = Mspire::PeakList.new(@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::Peak)
+        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
 
     it 'does #split(:share) and shares the peak proportional to adjacent peaks' do
       data = [[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]]
-      multipeak1 = Mspire::Peak.new( data )
+      multipeak1 = Mspire::PeakList.new( data )
 
       answer = [
         [[50.08, 3], [50.09, 8], [50.1, (2*8.0/17)]], 
@@ -79,12 +79,34 @@ describe Mspire::Peak do
       ] 
 
       # test a tie -> goes left!
-      points = @points[7,9]
-      points[2] = Mspire::Peak::Point.new([points[2][0], 9])
-      multipeak2 = Mspire::Peak.new( points )
+      peaks = @peaks[7,9]
+      peaks[2] = Mspire::Peak.new([peaks[2][0], 9])
+      multipeak2 = Mspire::PeakList.new( peaks )
       multipeak2.split(:greedy_y).should == answer
 
     end
   end
 
+  describe '#merge' do
+
+    subject do  
+
+      list1 = [[10.1, 1], [10.5, 2], [10.7, 3], [11.5, 4]]
+      list2 = [[10.11, 5], [10.49, 6], [10.71, 7], [11.48, 8]]
+      list3 = [[10.09, 9], [10.51, 10], [10.72, 11], [11.51, 12]]
+
+      [list1, list2, list3].map {|peaks| Mspire::PeakList.new( peaks ) }
+    end
+
+    it 'merges, giving exact weighted average m/z values for each cluster' do
+      (peaklist1, data) = Mspire::PeakList.merge(subject, :bin_width => 0.08, :bin_unit => :amu, :return_data => true)
+      peaklist2 = Mspire::PeakList.merge(subject, :bin_width => 0.08, :bin_unit => :amu)
+      peaklist1.should == peaklist2
+      peaks = [[10.097333333333331, 10.502222222222223, 10.713809523809525, 11.498333333333333], [5.0, 6.0, 7.0, 8.0]].transpose
+      peaklist1.should == Mspire::PeakList.new(peaks)
+      data.should == [[[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
+  end
+
 end
+

data/spec/mspire/spectrum_spec.rb

@@ -44,22 +44,4 @@ describe Mspire::Spectrum do
       spec.intensities.should == subject.intensities
     end
   end
-
-  describe 'merging spectra' do
-    subject do  
-      data = [ [10.10, 10.5, 10.7, 11.5], [1, 2, 3, 4] ],
-        [ [10.11, 10.49, 10.71, 11.48], [5, 6, 7, 8] ],
-        [ [10.09, 10.51, 10.72, 11.51], [9, 10, 11, 12] 
-      ]
-      data.map {|datum| Mspire::Spectrum.new( datum ) }
-    end
-    it 'merges, giving exact weighted average m/z values for each cluster' do
-      (spec1, data) = Mspire::Spectrum.merge(subject, :bin_width => 0.08, :bin_unit => :amu, :return_data => true)
-      spec2 = Mspire::Spectrum.merge(subject, :bin_width => 0.08, :bin_unit => :amu)
-      spec1.should == spec2
-      spec1.should == Mspire::Spectrum.new([[10.097333333333331, 10.502222222222223, 10.713809523809525, 11.498333333333333], [5.0, 6.0, 7.0, 8.0]])
-      data.should == [[[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
-  end
-
 end

data/spec/obo_spec.rb

@@ -5,6 +5,7 @@ require 'obo/ims'
 require 'obo/unit'
 
 describe 'accessing a specific Obo::Ontology' do
+
   it 'can access MS obo' do
     Obo::MS.id_to_name['MS:1000004'].should == 'sample mass'
     Obo::MS.name_to_id['sample mass'].should == 'MS:1000004'
@@ -22,4 +23,15 @@ describe 'accessing a specific Obo::Ontology' do
     Obo::Unit.name_to_id['temperature unit'].should == 'UO:0000005'
     Obo::Unit.id_to_element['UO:0000005'].should be_a(Obo::Stanza)
   end
+
+end
+
+describe 'Obo::Stanza' do
+  it 'can properly cast values' do
+    Obo::MS.id_to_element['MS:1000511'].cast('1').should == 1
+    Obo::MS.id_to_element['MS:1000004'].cast('2.2').should == 2.2
+    # don't ask me why mass resolution is cast into a string, but it is!
+    Obo::MS.id_to_element['MS:1000011'].cast('2.2').should == '2.2'
+    Obo::MS.id_to_element['MS:1000018'].cast('low to high').should == 'low to high'
+  end
 end

data/spec/testfiles/mspire/mzml/mspire_simulated.MSn.check.mzML

@@ -67,7 +67,7 @@
             <selectedIonList count="1">
               <cvParam cvRef="MS" accession="MS:1000744" name="selected ion m/z" value="2.0"/>
               <cvParam cvRef="MS" accession="MS:1000041" name="charge state" value="2"/>
-              <cvParam cvRef="MS" accession="MS:1000042" name="peak intensity" value="5"/>
+              <cvParam cvRef="MS" accession="MS:1000042" name="peak intensity" value="5.0"/>
             </selectedIonList>
           </precursor>
         </precursorList>

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mspire
 version: !ruby/object:Gem::Version
-  version: 0.7.7
+  version: 0.7.8
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-27 00:00:00.000000000 Z
+date: 2012-03-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -195,7 +195,7 @@ files:
 - lib/merge.rb
 - lib/mspire.rb
 - lib/mspire/bin.rb
-- lib/mspire/cv.rb
+- lib/mspire/cv/obo.rb
 - lib/mspire/cv/param.rb
 - lib/mspire/cv/paramable.rb
 - lib/mspire/digester.rb
@@ -266,7 +266,7 @@ files:
 - lib/mspire/mzml/spectrum_list.rb
 - lib/mspire/obo.rb
 - lib/mspire/peak.rb
-- lib/mspire/peak/point.rb
+- lib/mspire/peak_list.rb
 - lib/mspire/plms1.rb
 - lib/mspire/quant/qspec.rb
 - lib/mspire/quant/qspec/protein_group_comparison.rb
@@ -287,7 +287,9 @@ files:
 - script/mzml_read_binary.rb
 - spec/cv/param_spec.rb
 - spec/mspire/bin_spec.rb
+- spec/mspire/cv/obo_spec.rb
 - spec/mspire/cv/param_spec.rb
+- spec/mspire/cv/paramable_spec.rb
 - spec/mspire/digester_spec.rb
 - spec/mspire/error_rate/qvalue_spec.rb
 - spec/mspire/fasta_spec.rb
@@ -312,7 +314,7 @@ files:
 - spec/mspire/mzml/source_file_spec.rb
 - spec/mspire/mzml/spectrum_spec.rb
 - spec/mspire/mzml_spec.rb
-- spec/mspire/peak_spec.rb
+- spec/mspire/peak_list_spec.rb
 - spec/mspire/plms1_spec.rb
 - spec/mspire/quant/qspec_spec.rb
 - spec/mspire/spectrum_spec.rb

data/lib/mspire/cv.rb

@@ -1,16 +0,0 @@
-
-require 'cv'
-require 'obo/ms'
-require 'obo/ims'
-require 'obo/unit'
-
-module Mspire
-  module CV
-    Obo = {
-      'MS' => Obo::MS.id_to_name,
-      'IMS' => Obo::IMS.id_to_name,
-      'UO' => Obo::Unit.id_to_name,
-    }
-  end
-end
-

data/lib/mspire/peak/point.rb

@@ -1,13 +0,0 @@
-
-module Mspire
-  class Peak
-    # A point is typically a doublet: an x value and a y value.  In a spectrum
-    # this will be an m/z and intensity.  In a chromatogram this will be a
-    # retention time and an intensity.  (This class can be subclassed if
-    # desired)
-    class Point < Array
-      alias_method :x, :first
-      alias_method :y, :last
-    end
-  end
-end