ms-msrun 0.0.1

data/lib/ms/spectrum/compare.rb

@@ -0,0 +1,118 @@
+
+require 'ms/spectrum'
+
+module Kernel
+private
+   def this_method
+     caller[0] =~ /`([^']*)'/ and $1
+   end
+end
+
+class Array
+  def sum
+    self.inject(0.0) {|_sum, v| _sum += v }
+  end
+end
+
+module Ms
+  class Spectrum
+    module Compare
+
+      # (Σ (Ii*Ij)^½) / (ΣIi * ΣIj)^½
+      def sim_score(other, opts={})
+        numer = 0.0
+        compare(other, {:yield_diff => false}) do |sint, oint|
+          numer += Math.sqrt(sint * oint)
+        end
+        numer / Math.sqrt( self.ints.sum * other.ints.sum )
+      end
+
+      # opts[:type] == :mutual_best
+      #     will only return intensities on mutual best matches within radius.
+      #     yields [self_intensity, other_intensity] for each match within
+      #     the radius.  
+      #
+      # opts[:type] == :best
+      #     yields the best match in the radius peak.  If one peak is already
+      #     spoken for, a different peak may still match a close peak if it is
+      #     its best match (how to explain this?).
+      #
+      # if opts[:yield_diff] == true then returns [..., diff] (d: true)
+      # if opts[:yield_mz] == true then returns [mz, mz, int, int] (d: false)
+      # if opts[:yield_indices] == true then returns [i,j] (d: false)
+      # assumes mzs are increasing
+      def compare(other, opts={})
+        defaults = {:radius => 1.0, :type=>:mutual_best, :yield_diff => true, :yield_mz => false, :yield_indices => false}
+        (radius, type, yield_diff, yield_mz, yield_indices) = defaults.merge(opts).values_at(:radius, :type, :yield_diff, :yield_mz, :yield_indices)
+        blk = block_given?
+        output = [] if !blk
+        s_ints = self.intensities
+        s_size = self.mzs.size
+        o_mzs = other.mzs
+        o_size = o_mzs.size
+        o_ints = other.intensities
+        oi = 0
+        start_j = 0
+        save = []
+        self.mzs.each_with_index do |mz,i|
+          break if start_j >= o_size
+          hi = mz + radius
+          lo = mz - radius
+          start_j.upto(o_size-1) do |j|
+            diff = mz - o_mzs[j]
+            absdiff = diff.abs
+            if absdiff <= radius  # a potential hit!
+              save << [absdiff, i, j]
+            elsif diff < 0  # we overshot
+              break  
+            else  # undershot
+              start_j = j + 1  # this is for the benefit of the next search
+            end
+          end
+        end
+
+        #puts "BEFORE SORT: "
+        #p save
+        #save.sort!
+        #puts "AFTER SORT: "
+        #p save
+        iset = Array.new(s_size)
+        jset = Array.new(o_size)
+        save.each do |diff, i, j|
+          unless iset[i] || jset[j]
+            if type == :best
+              iset[i] = true
+              jset[j] = true
+            end
+            to_ret = 
+              if yield_indices
+                [i,j]
+              else
+                [s_ints[i], o_ints[j]]
+              end
+            if yield_mz
+              to_ret.unshift( s_mzs[i], o_mzs[j] )
+            end
+            if yield_diff
+              to_ret.push( diff )
+            end
+            if blk
+              yield to_ret
+            else
+              output << to_ret
+            end
+          end
+          if type == :mutual_best
+            iset[i] = true
+            jset[j] = true
+          end
+        end
+        output
+      end
+    end # Compare
+
+    include Compare
+  end # Spectrum
+end # Ms
+
+

data/lib/ms/spectrum/filter.rb

@@ -0,0 +1,46 @@
+require 'ms/spectrum'
+
+module Ms
+  class Spectrum
+    module Filter
+
+      def filter(by=:bins, opts={})
+        send("filter_by_#{by}".to_sym, opts)
+      end
+
+      # filters by binning the mz field
+      # bin_width is in m/z units
+      # num_peaks is the top peaks to include per bin
+      def filter_by_bins(opts={})
+        (bw, np) = {:bin_width => 100, :num_peaks => 7 }.merge(opts).values_at(:bin_width, :num_peaks)
+
+        stop = bw
+        track = []
+        track_all = [track]
+        ints = self.intensities
+        self.each do |mz,int|
+          if mz > stop
+            stop += bw
+            track = []
+            track_all << track
+          end
+          track << [int, mz]
+        end
+
+        include = []
+        track_all.each do |track|
+          track.sort!
+          start = (track.size < np) ? track.size : np
+          include.push( *( track[-start,np]) )
+        end
+
+        ret_ints = []
+        ret_mzs = include.map {|int, mz| [mz, int] }.sort.map {|mz,int| ret_ints << int ; mz }
+
+        return Spectrum.new(ret_mzs, ret_ints)
+      end
+
+    end
+    include Filter
+  end
+end

data/spec/lmat_spec.rb

@@ -0,0 +1,29 @@
+require File.expand_path( File.dirname(__FILE__) + '/spec_helper' )
+
+require 'lmat'
+
+class LmatUnitSpec < MiniTest::Spec
+
+  def initialize(*args)
+    @klass = Lmat
+    super(*args)
+  end
+
+  it 'can be created with no arguments' do
+    obj1 = @klass.new
+    obj1.class.must_equal @klass
+  end
+
+  xit 'can be created with arrays' do
+    obj = @klass[[1,2,3],[4,5,6]]
+    obj[0,0].must_equal 1
+    obj[1,0].must_equal 4
+    obj[1,2].must_equal 6
+  end
+
+  xit 'can find the max value' do
+    obj = @klass[[1,2,3],[1,8,3]]
+    obj.max.must_equal 8
+  end
+
+end

data/spec/ms/msrun/search_spec.rb

@@ -0,0 +1,56 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+require 'ms/msrun'
+
+class SearchSpec < MiniTest::Spec
+
+  xit 'works' do
+    @file = '/home/jtprince/ms-msrun/spec/files/opd1/000.v1.mzXML'
+    params = {
+      :bottom_mh => 300.0,
+      :top_mh => 4500.0,
+      :ms_levels => (2..-1),
+      :min_peaks => 10,
+    }
+
+    # no scans:
+    no_scans = [
+      [:min_peaks, 1000],
+      [:first_scan, 21],
+      [:first_scan, 10000],
+      [:last_scan, 0],
+      [:ms_levels, (3..4)],
+      [:ms_levels, 0], 
+      [:ms_levels, 3], 
+      [:top_mh, 0.0],
+      [:bottom_mh, 5000],
+    ]
+    Ms::Msrun.open(@file) do |ms|
+      no_scans.each do |k,v|
+        ms.to_mgf(nil, k => v).must_equal ""
+      end
+    end
+
+    some_scans = [
+      [:min_peaks, 0],
+      [:first_scan, 1],
+      [:first_scan, 9],
+      [:last_scan, 8],
+      [:ms_levels, 2],
+      [:ms_levels, (2..2)],
+      [:ms_levels, (2...3)],
+      [:top_mh, 1500],
+      [:bottom_mh, 500],
+    ]
+    Ms::Msrun.open(@file) do |ms|
+      no_scans.each do |k,v|
+        reply = ms.to_mgf(nil, k => v)
+        puts reply
+        reply.must_match(/BEGIN.IONS/)
+        reply.must_match(/END.IONS/)
+      end
+    end
+
+  end
+
+end

data/spec/ms/msrun_spec.rb

@@ -0,0 +1,50 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper.rb')
+
+require 'ms/msrun'
+
+module MsrunSpec
+  extend Shareable
+
+  before do
+    @file = nil  # you need to define this!
+    @key = nil   # <- do nothing with this.
+  end
+
+  def key
+    @key || @key = YAML.load_file(@file + '.key.yml')
+  end
+
+  it 'reads header information' do
+    Ms::Msrun.open(@file) do |ms|
+      key['header'].each do |k,v|
+        ms.send(k.to_sym).must_equal v
+      end
+    end
+  end
+
+end
+
+class Mzxml_v1 < MiniTest::Spec
+  include MsrunSpec
+  before do
+    super
+    @file = '/home/jtprince/ms-msrun/spec/files/opd1/000.v1.mzXML'
+  end
+end
+
+class Mzxml_v2_0 < MiniTest::Spec
+  include MsrunSpec
+  before do
+    super
+    @file = '/home/jtprince/ms-msrun/spec/files/opd1/020.v2.0.readw.mzXML'
+  end
+end
+
+class Mzxml_v2_1 < MiniTest::Spec
+  include MsrunSpec
+  before do
+    super
+    @file = '/home/jtprince/ms-msrun/spec/files/opd1/000.v2.1.mzXML'
+  end
+end
+

data/spec/ms/scan_spec.rb

@@ -0,0 +1,34 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+require 'ms/msrun'
+
+class ScanUnitSpec < MiniTest::Spec
+
+  before do
+    @scan = Ms::Scan.new
+    @scan.precursor = Ms::Precursor.new
+    @scan.spectrum = Ms::Spectrum.new([1,2,3,4], [2,4,4,2])
+  end
+
+
+  it 'determines if its +1 or not' do
+    # these have not been checked for accuracy, just sanity
+    reply = [0.1,2.5, 3.5, 5].map do |prec_mz|
+      @scan.precursor.mz = prec_mz
+      @scan.plus1?(-0.1)
+    end
+    reply.all? {|v| v == true }.must_equal true
+
+    reply = [0.1,2.5, 3.5, 5].map do |prec_mz|
+      @scan.precursor.mz = prec_mz
+      @scan.plus1?(1.0)
+    end
+    reply.all? {|v| v == false }.must_equal true
+
+    reply = [0.1,2.5, 3.5, 5].map do |prec_mz|
+      @scan.precursor.mz = prec_mz
+      @scan.plus1?(0.5)
+    end
+    reply.must_equal [false, false, true, true]
+  end
+end

data/spec/ms/spectrum/compare_spec.rb

@@ -0,0 +1,44 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper.rb')
+
+require 'ms/spectrum/compare'
+
+# when you switch order the return intensities are swapped:
+class Array
+  def rev_ab
+    each {|v| (v[0], v[1]) = v[1], v[0] }
+  end
+end
+
+class CompareSpec < MiniTest::Spec
+  include Ms
+
+  before do
+    @a = Spectrum.new([0,2,3,4], [5,6,7,8])
+    @b = Spectrum.new([0, 1.5, 3.5, 5.5], [9,10,11,12])
+
+    @c = Spectrum.new([0, 1], [8,9])
+    @d = Spectrum.new([0.6, 0.75], [10,11])
+  end
+
+  it 'compares spectra' do
+    # array form:
+    @c.compare(@d).rev_ab.must_equal( @d.compare(@c) )
+    @c.compare(@d).must_equal [[8, 10, 0.6]]
+
+    # block form
+    exp = [[5,9], [6,10], [7,11]]
+    # default radius 1.0
+    @a.compare(@b) do |int_a, int_b| 
+     exp.delete([int_a, int_b])
+    end
+    exp.size.must_equal 0
+  end
+
+  it 'computes similarity score' do
+    p @a.sim_score(@b)
+    p @a.sim_score(@a)
+  end
+
+end
+
+

data/spec/ms/spectrum/filter_spec.rb

@@ -0,0 +1,33 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper.rb')
+
+require 'ms/spectrum/filter'
+
+
+# when you switch order the return intensities are swapped:
+class Array
+  def rev_ab
+    each {|v| (v[0], v[1]) = v[1], v[0] }
+  end
+end
+
+class FilterSpec < MiniTest::Spec
+  include Ms
+
+  before do
+    @a = Spectrum.new([0,5,10, 15,16,17,18, 20.1], [0,1,2, 3,8,10,4, 0])
+    @null = Spectrum.new
+  end
+
+  it 'filters spectra' do
+    spec = @a.filter(:bins, :bin_width => 10, :num_peaks => 2)
+    spec.mzs.must_equal [5,10,16,17,20.1]
+    spec.ints.must_equal [1,2,8,10,0]
+
+    @a.filter(:bins, :bin_width => 100, :num_peaks => 8).must_equal @a
+    @a.filter(:bins, :bin_width => 1, :num_peaks => 1).must_equal @a
+    @a.filter(:bins, :bin_width => 1, :num_peaks => 0).must_equal @null
+  end
+
+end
+
+

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification 
+name: ms-msrun
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- John Prince
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-17 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: axml
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.0.5
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: runarray
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: A library for working with LC/MS runs. Part of mspire.  Has parsers for mzXML v1, 2, and 3, mzData and mzML.  Can convert to commonly desired search output (such as mgf)
+email: jtprince@gmail.com
+executables: 
+- ms_to_search.rb
+- base64_to_array.rb
+- ms_to_obiwarp.rb
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+files: 
+- lib/ms/spectrum.rb
+- lib/ms/msrun/axml/mzxml.rb
+- lib/ms/msrun/search.rb
+- lib/ms/msrun.rb
+- lib/ms/scan.rb
+- lib/ms/spectrum/compare.rb
+- lib/ms/spectrum/filter.rb
+- lib/ms/precursor.rb
+- lib/bsearch.rb
+- lib/lmat.rb
+- README
+- LICENSE
+- Rakefile
+has_rdoc: true
+homepage: http://mspire.rubyforge.org/projects/ms-msrun
+post_install_message: 
+rdoc_options: 
+- --main
+- README
+- --title
+- ms-msrun
+- --line-numbers
+- --inline-source
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: 
+- xmlparser (preferrably) or libxml
+rubyforge_project: mspire
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: A library for working with LC/MS runs
+test_files: 
+- spec/ms/msrun_spec.rb
+- spec/ms/msrun/search_spec.rb
+- spec/ms/spectrum/compare_spec.rb
+- spec/ms/spectrum/filter_spec.rb
+- spec/ms/scan_spec.rb
+- spec/lmat_spec.rb