mspire-lipidomics 0.1.4

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2012 Brigham Young University
+authored by: John T. Prince
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,18 @@
+= mspire-lipidomics
+
+Identify and quantify shotgun lipidomics samples.
+
+== Examples
+ 
+Use the commandline: lipidomic-search.rb
+
+== Install
+
+    gem install mspire-lipidomics
+
+If you want to do fragmentation prediction or work with molecules you need to
+install the rubabel gem (which requires openbabel with ruby bindings).
+
+== License
+
+MIT (See LICENSE)

data/Rakefile

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "mspire-lipidomics"
+  gem.homepage = "http://github.com/princelab/mspire-lipidomics"
+  gem.license = "MIT"
+  gem.summary = %Q{mass spectrometry based lipidomics - especially shotgun lipidomics}
+  gem.description = %Q{does lipidomics}
+  gem.email = "jtprince@gmail.com"
+  gem.authors = ["John T. Prince"]
+  gem.add_dependency "mspire", ">= 0.7.8"
+  gem.add_development_dependency "rubabel", ">= 0.1.0"
+  gem.add_development_dependency "rspec", "~> 2.3.0"
+  gem.add_development_dependency "jeweler", "~> 1.6.4"
+  gem.add_development_dependency "rcov", ">= 0"
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "ms-lipidomics #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.4

data/bin/lipidomic-search.rb

@@ -0,0 +1,199 @@
+#!/usr/bin/env ruby
+
+require 'trollop'
+require 'ms/mzml'
+require 'ms/lipid/search'
+require 'ms/lipid/ion'
+require 'ms/lipid/search/query'
+require 'ms/lipid_maps'
+require 'ms/error_rate/qvalue'
+
+# for html output: (just make the id clickable)
+LIPIDMAPS_SEARCH = "http://www.lipidmaps.org/data/LMSDRecord.php?LMID="
+
+DECOY_MODULATOR = 0.8319
+
+DEFAULTS = { 
+  :bin_width => 5, 
+  :bin_unit => :ppm,
+  :search_unit => :ppm,
+}
+
+def LipidPoint < Array
+  attr_accessor :sample
+end
+
+class Sample
+  attr_accessor :file
+  attr_accessor :spectrum
+  def initialize(file, merge_opts={})
+    @file = file
+    @spectrum = merge_ms1_spectra(file, DEFAULTS.merge(merge_opts))
+  end
+
+  # returns a single spectrum object
+  def self.merge_ms1_spectra(files, opts)
+    files.map do |file|
+      MS::Mzml.foreach(file).select {|spec| spec.ms_level == 1 }.map(&:sort!)
+    end
+    MS::Spectrum.merge(spectra, opts)
+  end
+end
+
+ext = ".lipidID.tsv"
+
+parser = Trollop::Parser.new do
+  banner "usage: #{File.basename(__FILE__)} [OPTIONS] <lipidmaps>.tsv <file>.mzML ..."
+  text "output: <file>#{ext} ..."
+  text ""
+  text "note that sometimes you get an error from R like this:"
+  text "(`eval': voidEval failed: Packet[cmd=2130771970,len=<nil>, con='<nil>', status=error...)"
+  text "just re-run it and it will work"
+  text ""
+  opt :bin_width, "width of the bins for merging", :default => DEFAULTS[:bin_width]
+  opt :bin_unit, "units for binning (ppm or amu)", :default => DEFAULTS[:bin_unit].to_s
+  opt :search_unit, "unit for searching nearest hit (ppm or amu)", :default => DEFAULTS[:search_unit].to_s
+  opt :top_n_peaks, "the number of highest intensity peaks to query the DB with", :default => 1000
+  opt :display_n, "the number of best hits to display", :default => 20
+  text ""
+  text "modifications (at least 1 charged mod is required):"
+  opt :lithium, "search for lithium adducts"
+  opt :ammonium, "search for ammonium adducts"
+  opt :proton_gain, "search for proton gain"
+  opt :proton_loss, "search for proton loss"
+  opt :water_loss, "*all* mods are also considered with water loss"
+  opt :decoy, "search with an equal number of decoy modifications"
+  opt :verbose, "talk about it"
+end
+
+opts = parser.parse(ARGV)
+opts[:bin_unit] = opts[:bin_unit].to_sym
+opts[:search_unit] = opts[:search_unit].to_sym
+
+if ARGV.size < 2
+  parser.educate
+  exit
+end
+
+CHARGED_MODS = [:lithium, :ammonium, :proton_gain, :proton_loss]
+
+unless CHARGED_MODS.any? {|key| opts[key] }
+  puts "*" * 78
+  puts "ArgumentError: need at least one charged mod!"
+  puts "*" * 78
+  parser.educate
+  exit
+end
+
+(lipidmaps, *files) = ARGV
+
+$VERBOSE = opts[:verbose]
+
+MSLM = MS::Lipid::Modification
+
+mods = {
+  proton_gain: MSLM.new(:proton),
+  water_loss: MSLM.new(:water, :loss => true),
+  lithium: MSLM.new(:lithium),
+  ammonium: MSLM.new(:ammonium),
+  proton_loss: MS::Lipid::Modification.new(:proton, :loss => true, :charge => -1)
+}
+
+lipids = MS::LipidMaps.parse_file(lipidmaps)
+
+
+ions = []
+lipids.each do |lipid| 
+  CHARGED_MODS.each do |key|
+    if opts[key]
+      ions << MS::Lipid::Ion.new(lipid, [mods[key]])
+      if opts[:water_loss]
+        ions << MS::Lipid::Ion.new(lipid, [mods[key], mods[:water_loss]]) 
+      end
+    end
+  end
+ end
+
+
+searcher = MS::Lipid::Search.new(ions, :ppm => (opts[:search_unit] == :ppm))
+
+if opts[:decoy]
+  # assumes a mod group that is either the mod or a mod and water loss
+  decoy_ions = ions.map do |ion|
+    # modify the first mod and leave the second untouched (if any)
+    mod_group = ion.modifications
+    fake_mod = mod_group.first.dup
+    fake_mod.massdiff *= DECOY_MODULATOR
+    fake_mod.formula = "FAKE#{mod_group.first.formula}(#{fake_mod.massdiff})"
+    fake_mod.name = "fake_#{mod_group.first.name}".to_sym
+    new_mod_group = [fake_mod, *mod_group[1..-1]]
+    MS::Lipid::Ion.new(ion.lipid, new_mod_group)
+  end
+  decoy_searcher = MS::Lipid::Search.new(decoy_ions, :ppm => (opts[:search_unit] == :ppm)) 
+end
+
+files.each do |file|
+  base = file.chomp(File.extname(file))
+  puts "processing file: #{file}" if $VERBOSE
+  sample = Sample.new(file, opts)
+
+  num_points = sample.spectrum.mzs.size
+  puts "#{num_points} merged peaks in #{file}" if $VERBOSE
+
+  highest_points = sample.spectrum.points.sort_by(&:last).reverse[0,opts[:top_n_peaks]].sort
+
+  sample.spectrum = MS::Spectrum.from_points( highest_points )
+
+  queries = sample.spectrum.mzs.each_with_index.map {|mz,index| MS::Lipid::Search::Query.new(mz, index) }
+  hit_groups = searcher.search(queries, :return_order => :sorted)
+  if opts[:decoy]
+    decoy_hit_groups = decoy_searcher.search(queries, :return_order => :sorted)
+    hit_group_qvalue_pairs = MS::ErrorRate::Qvalue.target_decoy_qvalues(hit_groups, decoy_hit_groups, :monotonic => true, &:pvalue)
+    hit_group_qvalue_pairs.each do |hit_group, qval|
+      hit_group.first.decoy_qvalue = qval
+    end
+  end
+
+  # all info is relative to the hit_group
+  info = {
+    decoy_qvalue: :decoy_qvalue.to_proc,
+    qvalue:  :qvalue.to_proc,
+    pvalue:  :pvalue.to_proc,
+    observed_mz:  :observed_mz.to_proc,
+    theoretical_mz:  :theoretical_mz.to_proc,
+    delta:  :delta.to_proc,
+    ppm:  :ppm.to_proc,
+    hit2_ppm: proc {|hg| hg[1].ppm },
+    first_isobar_name: proc {|hg| (lipid=hg.first.db_isobar_group.first.lipid).common_name || lipid.systematic_name },
+    num_isobars: proc {|hg| hg.first.db_isobar_group.size },
+    ions: proc {|hg|
+      hg.first.db_isobar_group.map do |ion|
+        [ion.lipid.lm_id, ion.modifications.map do |mod| 
+          (mod.gain? ? '+' : '-') + "(#{mod.charged_formula})"
+        end.join
+        ].join(":")
+      end.join(' ')
+    }
+  }
+
+  output = base + ext
+  puts "writing to #{output}" if $VERBOSE
+  File.open(output, 'w') do |out|
+    out.puts info.keys.join("\t")
+    hit_groups[0,opts[:display_n]].each do |hit_group|
+      out.puts info.values.map {|prc| prc.call(hit_group) }.join("\t")
+    end
+  end
+
+  if opts[:decoy]
+    decoy_output = base + '.decoy' + ext
+    File.open(decoy_output, 'w') do |dout|
+      decoy_info = info.dup
+      [:qvalue, :decoy_qvalue].each {|key| decoy_info.delete(key) }
+      dout.puts decoy_info.keys.join("\t")
+      decoy_hit_groups[0,opts[:display_n]].each do |hit_group|
+        dout.puts decoy_info.values.map {|prc| prc.call(hit_group) }.join("\t")
+      end
+    end
+  end
+end

data/lib/mspire/lipid/ion/fragment.rb

@@ -0,0 +1,68 @@
+
+module Mspire
+  class Lipid
+
+    # goes from 1 to 99
+    CHAIN_PREFIXES = {
+      'meth' => 1,
+      'eth' => 2,
+      'prop' => 3,
+      'but' => 4,
+      'pent' => 5,
+      'hex' => 6,
+      'hept' => 7,
+      'oct' => 8,
+      'non' => 9,
+      'dec' => 10,
+      'undec' => 11,
+      'dodec' => 12,
+      'tridec' => 13,
+      'tetradec' => 14,
+      'pentadec' => 15,
+      'hexadec' => 16,
+      'heptadec' => 17,
+      'octadec' => 18,
+      'nonadec' => 19,
+      'eicos' => 20,
+      'heneicos' => 21,
+      'docos' => 22,
+      'tricos' => 23,
+      'tetracos' => 24,
+      'pentacos' => 25,
+      'hexacos' => 26,
+      'heptacos' => 27,
+      'octacos' => 28,
+      'nonacos' => 29
+    }
+
+    consistent = { 
+      0 => '',
+      1 => 'hen',
+      2 => 'do',
+      3 => 'tri',
+      4 => 'tetra',
+      5 => 'penta',
+      6 => 'hexa',
+      7 => 'hepta',
+      8 => 'octa',
+      9 => 'nona',
+    }
+
+    (3..9).each do |tens_place|
+      (0..9).each do |ones_place| 
+        key = consistent[ones_place] + consistent[tens_place] + "cont"
+        CHAIN_PREFIXES[key] = 10*tens_place + ones_place
+      end
+    end
+
+    class Ion
+      module Fragment
+        # predicts the MS/MS fragments for this ion
+        def predict_fragment_mzs
+        end
+      end
+
+      include Fragment
+    end
+  end
+end

data/lib/mspire/lipid/ion.rb

@@ -0,0 +1,57 @@
+require 'mspire/lipid/ion/fragment'
+
+module Mspire
+  class Lipid
+    # a lipid with modifications (typically the mods give it a charge so that
+    # it can be seen in the mass spec)
+    class Ion
+      # an Mspire::Lipid object
+      attr_accessor :lipid
+      # an Mspire::Lipid::Modifications object
+      attr_accessor :modifications
+      # the key attribute of a query
+
+      def initialize(lipid, mods=[])
+        @lipid = lipid
+        @modifications = mods
+        @mz = nil
+      end
+
+      def charge
+        z = 0
+        @modifications.each do |mod|
+          z -= mod.charge
+        end
+        z
+      end
+
+      def formula
+        formula = lipid.formula.dup
+        modifications.each do |mod|
+          formula += mod.formula
+        end
+        formula
+      end
+
+      def mz
+        return @mz if @mz
+        mass = @lipid.mass
+        charge = 0
+        @modifications.each do |mod|
+          mass += mod.massdiff 
+          charge += mod.charge
+        end
+        if charge == 0
+          @mz = nil
+        else
+          @mz = mass / charge
+        end
+      end
+
+      def inspect
+        "<|| Ion mz=#{mz} #{lipid.inspect} + #{modifications.map(&:inspect).join(', ')} ||>"
+      end
+
+    end
+  end
+end

data/lib/mspire/lipid/modification.rb

@@ -0,0 +1,125 @@
+require 'mspire/mass'
+require 'mspire/molecular_formula'
+
+module Mspire
+  class Lipid
+
+
+    # the convention is all mods are gains unless the name ends in an
+    # underscore
+    class Modification
+
+      # given a string with a formula and charge, returns the formula portion
+      # and the charges (as a signed integer)
+      def self.formula_and_charge(string)
+        md = string.match(/([^+]*)(\+*)$/)
+        charges_string = md[2]
+        if charges_string.nil?
+          0
+        else
+          charges_string.count(charges_string[0])
+          int = -int if charges_string[0] == '-'
+        end
+        [md[1], int]
+      end
+
+      # calculates the mass diff.  For every positive charge the mass of an
+      # electron is subtracted; for every negative charge the mass of an
+      # electron is added.  If gain is false, then the mass diff will be
+      # negative.
+      def self.massdiff(formula, charge, gain=true)
+        Mspire::Mass.formula_to_exact_mass(formula)
+        massdiff = Mspire::Mass.formula_to_exact_mass(formula)
+        massdiff -= (charge * Mspire::Mass::ELECTRON) # + charge subtracts, - charge adds
+        massdiff = -massdiff unless gain
+        massdiff
+      end
+
+      # the charge on the mod should be represented by the number of plusses
+      # or minuses after the formula (Li+ for a +1 charge Lithium or H2++, 2
+      # protons with a total of 2 charges)
+      FORMULAS = {
+        :proton => 'H',
+        :ammonium => 'NH4',
+        :lithium => 'Li',
+        :water => 'H2O',
+      }
+      CHARGE = {
+        :proton => 1,
+        :ammonium => 1,
+        :lithium => 1,
+        :water => 0,
+      }
+
+      # determined by running formulas through Mspire::Mass.massdiff
+      MASSDIFFS = {}
+      FORMULAS.each do |name, formula|
+         MASSDIFFS[name] = self.massdiff(formula, CHARGE[name])
+      end
+
+      # as a symbol
+      attr_accessor :name
+      # as a MolecularFormula object
+      attr_accessor :formula
+      # negative indicates a loss
+      attr_accessor :massdiff
+      # the charge 
+      attr_accessor :charge
+
+      # if no mass or formula is given then it searches command mods for the name
+      # @param [Symbol] name the name of the mod
+      # A number of opts are expected if they are not found in the FORMULAS,
+      # CHARGE, or MASSDIFFS hashes:
+      #
+      #     attributes:
+      #     :formula = the chemical formula, lipidmaps style ("C2H4BrO") or
+      #                any valid argument to MolecularFormula.new
+      #     :massdiff = +/-Float
+      #     :charge = +/- Integer
+      #
+      #     instruction:
+      #     :loss = true   negates the mass diff sign and charge during initialization
+      #                    this option is typically only done for molecules
+      #                    already present in the FORMULA hash (e.g.)
+      #
+      #     proton_loss = Mspire::Lipid::Modification.new(:proton, :loss => true)
+      #     water_loss = Mspire::Lipid::Modification.new(:water, :loss => true)
+      #
+      def initialize(name, opts={})
+        @name = name
+        @formula = 
+          if ( form_string = (opts[:formula] || FORMULAS[name]) )
+            Mspire::MolecularFormula.new( form_string )
+          end
+        @massdiff = opts[:massdiff] || MASSDIFFS[name]
+        @charge = opts[:charge] || CHARGE[name]
+
+        if opts[:loss]
+          @charge = -@charge
+          # necessary if you are using a named molecule and you want its loss
+          # rather than gain (i.e., you want a negative massdiff)
+          @massdiff = -@massdiff 
+        end
+      end
+
+      def charged_formula
+        @formula.to_s + @charge.abs.times.map { (@charge > 0) ? '+' : '-' }.join
+      end
+
+      def gain?
+        massdiff > 0
+      end
+
+      def loss?
+        !gain?
+      end
+
+      def inspect
+        "<Mod: #{charged_formula}>"
+      end
+
+    end
+  end
+end
+
+

data/lib/mspire/lipid/search/bin.rb

@@ -0,0 +1,79 @@
+require 'mspire/bin'
+
+module Mspire
+  class Lipid
+    class Search
+
+      # A Search::Bin is a range that contains the *entire* query spectrum
+      # (not just the portion covered by the range).  the query spectrum, and
+      # a ProbabilityDistribution -- the probability that a peak's delta to
+      # nearest peak is that small by chance.
+      class Bin < Mspire::Bin
+        # the intensity value of the query spectrum should be a query
+        attr_accessor :db_spectrum
+        attr_accessor :probability_distribution
+
+        def initialize(range_obj, db_spectrum)
+          super(range_obj.begin, range_obj.end, range_obj.exclude_end?)
+          @db_spectrum = db_spectrum
+        end
+
+        def <<(query)
+          @data << query
+        end
+
+        # returns the nearest num_hits Mspire::Lipid::Search::Hits sorted by delta
+        # [with tie going to the lower m/z]
+        # searches all queries and removes them from the data queue
+        def queries_to_hit_groups!(num_hits=1)
+          queries = @data.dup
+          @data.clear
+
+          @db_isobar_groups_by_index = @db_spectrum.intensities
+
+          hit_groups = queries.map do |query|
+            best_hits(query, num_hits)
+          end
+
+          all_top_hits = hit_groups.map(&:first)
+
+          # updates the pvalues for all the hits
+          pvalues = probability_distribution.pvalues( all_top_hits )
+          all_top_hits.zip(pvalues) {|hit, pvalue| hit.pvalue = pvalue }
+
+          hit_groups
+        end
+
+        # returns a HitGroup object
+        def best_hits(query, num_hits)
+          query_mz = query.mz
+          #puts "MZ: #{query_mz}"
+          db_mzs = @db_spectrum.mzs
+          index = @db_spectrum.find_nearest_index(query_mz)
+          _min = index - (num_hits-1)
+          (_min >= 0) || (_min = 0)
+          _max = index + (num_hits-1)
+          (_max < db_mzs.size) || (_max = @db_spectrum - 1)
+          delta_index_pairs = (_min.._max).map {|i| [query_mz.-(db_mzs[i]).abs, i] }
+          closest_delta_index_pairs = delta_index_pairs.sort
+          top_num_hits_delta_index_pairs = closest_delta_index_pairs[0, num_hits]
+          top_num_hit_indices = top_num_hits_delta_index_pairs.map(&:last)
+          hit_group = top_num_hit_indices.map do |index|
+            Hit.new( :db_isobar_group => @db_isobar_groups_by_index[index], :observed_mz => query_mz)
+          end
+          HitGroup.new(hit_group)
+        end
+
+        def inspect
+          "<(#{super}) @db_spectrum(points size)=#{db_spectrum.mzs.size} @probability_distribution=#{probability_distribution}>"
+        end
+
+        def to_range
+          Range.new( self.begin, self.end, self.exclude_end? )
+        end
+      end
+    end
+  end
+end
+
+

data/lib/mspire/lipid/search/db_isobar_group.rb

@@ -0,0 +1,20 @@
+
+module Mspire
+  class Lipid
+    class Search
+      # this is a group of Lipid::Ion objects that all have the same (or
+      # possibly similar) m/z
+      class DBIsobarGroup < Array
+        # it is implemented like this so that the isobar group *could* have
+        # individuals in it with slightly different m/z values and this coudl
+        # still be used as a container.  In my current implementation they
+        # have exactly the same m/z
+        attr_accessor :mz
+        def initialize( ar=[], mz=nil)
+          @mz = mz if mz
+          self.replace(ar)
+        end
+      end
+    end
+  end
+end