ms-lipidomics 0.1.0

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,13 @@
+= ms-lipidomics
+
+Identify and quantify shotgun lipidomics samples.
+
+WARNING: VERY PRE-ALPHA RIGHT NOW.
+
+== Examples
+ 
+Use the commandline: lipidomic-search.rb
+
+== Copyright
+
+MIT (See LICENSE.txt)

data/Rakefile

@@ -0,0 +1,60 @@
+# 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 = "ms-lipidomics"
+  gem.homepage = "http://github.com/princelab/ms-lipidomics"
+  gem.license = "MIT"
+  gem.summary = %Q{mass spectrometry based lipidomics - especially shotgun lipidomics}
+  gem.description = %Q{does ms lipidomics}
+  gem.email = "jtprince@gmail.com"
+  gem.authors = ["John T. Prince"]
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+  gem.add_development_dependency "rspec", "~> 2.3.0"
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+  gem.add_development_dependency "bundler", "~> 1.0.0"
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+  gem.add_development_dependency "jeweler", "~> 1.6.4"
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+  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/bin/lipidomic-search.rb

@@ -0,0 +1,126 @@
+#!/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'
+
+# for html output: (just make the id clickable)
+LIPIDMAPS_SEARCH = "http://www.lipidmaps.org/data/LMSDRecord.php?LMID="
+
+DEFAULTS = { 
+  :bin_width => 5, 
+  :bin_unit => :ppm,
+  :search_unit => :ppm,
+}
+
+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 merge_ms1_spectra(file, opts)
+    spectra = []
+    warn "using number of peaks as proxy for ms level right now"
+    MS::Mzml.foreach(file) do |spectrum|
+      spectra << spectrum if spectrum.mzs.size > 1000  # <<<<<<------ kludge for ms_level == 1
+    end
+    spectra.each {|spectrum| spectrum.sort! }
+
+    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
+  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
+
+(lipidmaps, *files) = ARGV
+
+$VERBOSE = opts[:verbose]
+
+proton = MS::Lipid::Modification.new(:proton)
+h2o_loss = MS::Lipid::Modification.new(:water, :loss => true)
+
+lipids = MS::LipidMaps.parse_file(lipidmaps)
+
+ions = lipids.map do |lipid| 
+  [[proton], [proton, h2o_loss]].map do |mods|
+    MS::Lipid::Ion.new(lipid, mods)
+  end
+end.flatten(1)
+
+
+searcher = MS::Lipid::Search.new(ions, :ppm => (opts[:search_unit] == :ppm))
+
+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)
+
+  hit_info = [:qvalue, :pvalue, :observed_mz, :theoretical_mz, :delta, :ppm]
+  second_hit_info = [:ppm]
+
+  output = base + ext
+  puts "writing to #{output}" if $VERBOSE
+  File.open(output, 'w') do |out|
+    out.puts (hit_info + %w(2nd_hit_ppm first_isobar_name num_isobars isobars)).join("\t")
+    hit_groups[0,opts[:display_n]].each_with_index do |hit_group,i|
+      ar = []
+      tophit = hit_group.first
+      ar.push *hit_info.map {|mthd| tophit.send(mthd) }
+      ar.push *second_hit_info.map {|mthd| hit_group[1].send(mthd) }
+      common_name = tophit.db_isobar_group.first.lipid.common_name
+      common_name = tophit.db_isobar_group.first.lipid.systematic_name if common_name == "-"
+      ar.push common_name
+      ar.push tophit.db_isobar_group.size
+      ions = tophit.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(' ')
+      ar.push ions
+      out.puts ar.join("\t")
+    end
+  end
+end

data/lib/ms/lipid.rb

@@ -0,0 +1,19 @@
+
+module MS
+  class Lipid
+    def self.members
+      [:lm_id,:common_name,:systematic_name,:formula,:mass,:category,:main_class,:sub_class]
+    end
+
+    members.each {|mem| attr_accessor mem }
+
+    def initialize(*args)
+      (@lm_id,@common_name,@systematic_name,@formula,@mass,@category,@main_class,@sub_class) = args
+    end
+
+    def inspect
+      cut_common_name = (common_name.size <= 20) ? common_name : (common_name[0,20]+"...")
+      "<#{lm_id}: #{formula}: #{mass} #{cut_common_name}>"
+    end
+  end
+end

data/lib/ms/lipid/ion.rb

@@ -0,0 +1,39 @@
+
+module MS
+  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 MS::Lipid object
+      attr_accessor :lipid
+      # an MS::Lipid::Modifications object
+      attr_accessor :modifications
+      # the key attribute of a query
+
+      def initialize(lipid, mods=[])
+        @lipid = lipid
+        @modifications = mods
+        @mz = nil
+      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/ms/lipid/modification.rb

@@ -0,0 +1,112 @@
+require 'ms/mass'
+
+module MS
+  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)
+        MS::Mass.formula_to_exact_mass(formula)
+        massdiff = MS::Mass.formula_to_exact_mass(formula)
+        massdiff -= (charge * MS::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 => 'NH3H',
+        :lithium => 'Li',
+        :water => 'H2O',
+      }
+      CHARGE = {
+        :proton => 1,
+        :ammonium => 1,
+        :lithium => 1,
+        :water => 0,
+      }
+
+      # determined by running formulas through MS::Mass.massdiff
+      MASSDIFFS = {}
+      FORMULAS.each do |name, formula|
+         MASSDIFFS[name] = self.massdiff(formula, CHARGE[name])
+      end
+
+      # as a symbol
+      attr_accessor :name
+      # as a molecular formula
+      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")
+      #     :massdiff = +/-Float
+      #     :charge = +/- Integer
+      #
+      #     instruction:
+      #     :loss = true   flips the mass diff sign during initialization
+      #                    necessary to get negative massdiff on named molecule
+      #                    (unnecessary if you input massdiff manually)
+      def initialize(name, opts={})
+        @name = name
+        @formula = opts[:formula] || FORMULAS[name]
+        @massdiff = opts[:massdiff] || MASSDIFFS[name]
+        @charge = opts[:charge] || CHARGE[name]
+        # 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 if opts[:loss]
+      end
+
+      def charged_formula
+        @formula + @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/ms/lipid/search.rb

@@ -0,0 +1,203 @@
+require 'ms/spectrum'
+require 'rserve/simpler'  # TODO: move to integrated interface with rserve when available
+require 'core_ext/array/in_groups'
+require 'ms/lipid/search/hit'
+require 'ms/lipid/search/bin'
+require 'ms/lipid/modification'
+require 'ms/lipid/search/probability_distribution'
+
+module MS
+  class Lipid
+    class Search
+      STANDARD_MODIFICATIONS = {
+        :proton => [1,2],
+        :ammonium => [1],
+        :lithium => [1],
+        :water => [1,2],
+      }
+      STANDARD_SEARCH = {
+        :units => :ppm,
+        :query_min_count_per_bin => 500,  # min number of peaks per bin
+        :num_rand_samples_per_bin => 1000,
+        :num_nearest => 2,
+        :return_order => :as_given,  # or :sorted 
+      }
+
+      attr_accessor :options
+      attr_accessor :search_function
+
+      # will generate PossibleLipid objects and return a new search object
+      # uses only one kind of loss at a time and one type of gain at a time
+      # will also do the combination of a gain and a loss if gain_and_loss is
+      # true
+      def self.generate_simple_queries(lipids, mods=STANDARD_MODIFICATIONS, gain_and_loss=false)
+        possible_lipids = []
+        real_mods_and_cnts = mods.map {|name, cnts| [MS::Lipid::Modification.new(name), cnts] }
+        # one of each
+        real_mods_and_cnts.each do |mod, counts|
+          counts.each do |cnt|
+            possible_lipids << MS::Lipid::Search::Query.new(lipid, Array.new(cnt, mod))
+          end
+        end
+        if gain_and_loss
+          # one of each gain + one of each loss
+          (gain_mod_cnt_pairs, loss_mod_cnt_pairs) = real_mods_and_cnts.partition {|mod, count| mod.gain }
+          gain_mod_cnt_pairs.each do |mod, cnt|
+            lipids.each do |lipid|
+              #### need to implement still (use combinations or something...)
+              get_this_working!
+            end
+          end
+        end
+        self.new(possible_lipids)
+      end
+
+      # ions are MS::Lipid::Ion objects
+      # each one should give a non-nil m/z value
+      def initialize(ions=[], opts={})
+        @options = STANDARD_SEARCH.merge(opts)
+        @db_isobar_spectrum = create_db_isobar_spectrum(ions)
+        @search_function = create_search_function(ions, @options)
+      end
+
+      # returns an array of HitGroup and a parallel array of BH derived
+      # q-values (will switch to Storey soon enough).  The HitGroups are
+      # returned in the order in which the mz_values are given.
+      # assumes search_queries are in ascending m/z order
+      def search(search_queries, opts={})
+        opt = @options.merge( opts )
+        hit_groups = @search_function.call(search_queries, opt[:num_nearest])
+        sorted_hit_groups = qvalues!(hit_groups, opt)
+        case opts[:return_order]
+        when :as_given
+          hit_groups
+        when :sorted
+          sorted_hit_groups
+        end
+      end
+
+      def qvalues!(hit_groups, opts)
+
+        # from http://stats.stackexchange.com/questions/870/multiple-hypothesis-testing-correction-with-benjamini-hochberg-p-values-or-q-va
+        # but I've already coded this up before, too, in multiple ways...
+        prev_bh_value = 0
+        num_total_tests = hit_groups.size
+
+        #hit_groups.each {|hg| p [hg.first.pvalue, hg] }
+
+        # calculate Q-values BH style for now:
+        # first hit is the best hit in the group
+        pval_hg_index_tuples = hit_groups.each_with_index.map {|hg,i| [hg.pvalue, hg.delta.abs, hg.ppm.abs, i, hg] }
+
+        if pval_hg_index_tuples.any? {|pair| pair.first.nan? }
+          $stderr.puts "pvalue of NaN!"
+          $stderr.puts ">>> Consider increasing query_min_count_per_bin or setting ppm to false <<<"
+          raise
+        end
+
+        sorted_pval_index_tuples = pval_hg_index_tuples.sort
+
+        sorted_pval_index_tuples.each_with_index do |tuple,i|
+          pval = tuple.first
+          bh_value = pval * num_total_tests / (i + 1)
+          # Sometimes this correction can give values greater than 1,
+          # so we set those values at 1
+          bh_value = [bh_value, 1].min
+
+          # To preserve monotonicity in the values, we take the
+          # maximum of the previous value or this one, so that we
+          # don't yield a value less than the previous.
+          bh_value = [bh_value, prev_bh_value].max
+          prev_bh_value = bh_value
+          tuple.last.first.qvalue = bh_value # give the top hit the q-value
+        end
+
+        sorted_pval_index_tuples.map(&:last)
+      end
+
+      def create_search_function(ions, opt)
+
+        db_isobar_spectrum = create_db_isobar_spectrum(ions)
+
+        search_bins = create_search_bins(db_isobar_spectrum, opt[:query_min_count_per_bin])
+
+        create_probability_distribution_for_search_bins!(search_bins, db_isobar_spectrum, opt[:num_rand_samples_per_bin], opt[:ppm])
+
+        # create the actual search function
+        # returns an array of hit_groups
+        lambda do |search_queries, num_nearest_hits|
+          Bin.bin(search_bins, search_queries, &:mz)
+          search_bins_with_data = search_bins.reject {|bin| bin.data.empty? }
+          hit_groups = search_bins_with_data.map {|bin| bin.queries_to_hit_groups!(opt[:num_nearest]) }.flatten(1)
+        end
+      end
+
+      #####################################################
+      # Ancillary to create_search_function:
+      #####################################################
+
+      # returns a DB isobar spectrum where the m/z values are all the m/z
+      # values to search for and the intensities each an array corresponding
+      # to all the lipid ions matching that m/z value
+      def create_db_isobar_spectrum(ions)
+        mzs = [] ; query_groups = []
+        pairs = ions.group_by(&:mz).sort_by(&:first)
+        pairs.each {|mz, ar| mzs << mz ; query_groups << ar }
+        MS::Spectrum.new([mzs, query_groups])
+      end
+
+      # use_ppm uses ppm or amu if false
+      # returns the search_bins
+      def create_probability_distribution_for_search_bins!(search_bins, db_isobar_spectrum, num_rand_samples_per_bin, use_ppm=true)
+        search_bins.each do |search_bin| 
+          rng = Random.new
+          random_mzs = num_rand_samples_per_bin.times.map { rng.rand(search_bin.to_range)  }
+          # find the deltas
+          diffs = random_mzs.map do |random_mz| 
+            nearest_random_mz = db_isobar_spectrum.find_nearest(random_mz)
+            delta = (random_mz - nearest_random_mz).abs
+            use_ppm ? delta./(nearest_random_mz).*(1e6) : delta
+          end
+          search_bin.probability_distribution = ProbabilityDistribution.deviations_to_probability_distribution((use_ppm ? :ppm : :amu), diffs)
+        end
+        search_bins
+      end
+
+      def create_search_bins(db_isobar_spectrum, min_n_per_bin)
+        # make sure we get the right bin size based on the input
+        ss = db_isobar_spectrum.mzs.size ; optimal_num_groups = 1
+        (1..ss).each do |divisions|
+          if  (ss.to_f / divisions) >= min_n_per_bin
+            optimal_num_groups = divisions
+          else ; break
+          end
+        end
+
+        mz_ranges = []
+        prev = nil
+
+        groups = db_isobar_spectrum.points.in_groups(optimal_num_groups,false).to_a
+
+        case groups.size
+        when 0
+          raise 'I think you need some data in your query spectrum!'
+        when 1
+          group = groups.first
+          [ MS::Lipid::Search::Bin.new( Range.new(group.first.first, group.last.first), db_isobar_spectrum ) ]
+        else
+          search_bins = groups.each_cons(2).map do |points1, points2|
+            bin = MS::Lipid::Search::Bin.new( Range.new(points1.first.first, points2.first.first, true), db_isobar_spectrum )
+            prev = points2
+            bin
+          end
+          _range = Range.new(prev.first.first, prev.last.first)
+          search_bins << MS::Lipid::Search::Bin.new(_range, db_isobar_spectrum) # inclusive
+        end
+      end
+    end
+  end
+end
+
+
+
+

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

@@ -0,0 +1,79 @@
+require 'bin'
+
+module MS
+  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 < ::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 MS::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/ms/lipid/search/db_isobar_group.rb

@@ -0,0 +1,20 @@
+
+module MS
+  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

data/lib/ms/lipid/search/hit.rb

@@ -0,0 +1,75 @@
+
+module MS
+  class Lipid
+    class Search
+      class Hit
+        # the db_isobar_group this hit is associated with.  Each hit is only
+        # associated with a single db_isobar_group!
+        attr_accessor :db_isobar_group
+        # the experimental m/z value
+        attr_accessor :observed_mz
+        # the probability the hit is due to random chance
+        attr_accessor :pvalue
+        # the FDR if the threshold accepts this pvalue.  Note that this value
+        # is relative to the number of tests performed and not completely 
+        # intrinsic to the hit itself.
+        attr_accessor :qvalue
+
+        # the probability distribution that can be used to determine its
+        # pvalue
+        attr_accessor :probability_distribution
+
+        def initialize(hash={})
+          hash.each {|k,v| instance_variable_set("@#{k}", v) }
+        end
+
+        # observed_mz - query m/z
+        def delta
+          @observed_mz - @db_isobar_group.first.mz.to_f
+        end
+
+        alias_method :amu, :delta
+
+        # the absolute value of distance from true val
+        def delta_abs
+          delta.abs
+        end
+
+        # parts per million (divided by theoretical m/z)
+        def ppm
+          (delta / @db_isobar_group.first.mz) * 1e6
+        end
+
+        def theoretical_mz
+          @db_isobar_group.first.mz
+        end
+
+        def inspect
+          "<<#{super} -- <ppm=#{ppm} delta=#{delta} theoretical_mz=#{theoretical_mz}>>"
+        end
+      end
+
+      # A query that matched multiple items.  Each search returns a hit group
+      # which consists of the best hits for that experimental m/z.  When
+      # queried for values like delta or ppm, it will delegate to the first hit.
+      # So, in many ways it can be used as a container for hits, but it puts
+      # its best face forward.
+      class HitGroup < Array
+
+        # should implement with delegator obviously...
+        # should allow setting ???
+
+        def delta() first.delta end
+        def ppm() first.ppm end
+        def theoretical_mz() first.theoretical_mz end
+        def query_group() first.query_group end
+        def observed_mz() first.observed_mz end
+        def pvalue() first.pvalue end
+        def qvalue() first.pvalue end
+
+        def best_hit() first end
+
+      end
+    end
+  end
+end

data/lib/ms/lipid/search/probability_distribution.rb

@@ -0,0 +1,49 @@
+
+module MS
+  class Lipid
+    class Search
+      class ProbabilityDistribution
+        DEFAULT_TYPE = :ppm
+        R = Rserve::Simpler.new
+
+        # takes location, scale and shape parameters
+        attr_accessor :location, :scale, :shape
+        # type is :ppm or :delta_abs
+        attr_accessor :type
+        def initialize(location, scale, shape, type=DEFAULT_TYPE)
+          @location, @scale, @shape = location, scale, shape
+          @type = type
+        end
+
+        # takes a deviation and returns the pvalue
+        def pvalue(hit)
+          R.converse "pgev(log(#{hit.send(type)}), #{@location}, #{@scale}, #{@shape})"
+        end
+
+        # same as pvalue, just tries to limit the number of calls to R to
+        # speed things up!
+        def pvalues(hits)
+          deltas = hits.map {|v| v.send(type).abs }
+          R.converse("sapply(r_devs, function(elt) pgev(log(elt), #{@location}, #{@scale}, #{@shape}))", :r_devs => deltas)
+        end
+
+        def self.require_r_library(lib)
+          reply = R.converse "library(#{lib})"
+          unless reply.size > 4  # ~roughly
+            $stderr.puts "The libraries ismev and evd must be installed in your R env!"
+            $stderr.puts "From within R (works best if R is started with sudo or root for installing):"
+            $stderr.puts %Q{install.packages("ismev") ; install.packages("evd")}
+            raise "must have R (rserve) and ismev and evd installed!"
+          end
+        end
+
+        # returns an EVD object
+        def self.deviations_to_probability_distribution(type, devs)
+          %w(ismev evd).each {|lib| require_r_library(lib) }
+          params = R.converse("m <- gev.fit(log(devs_r))\n c(m$mle[1], m$mle[2], m$mle[3])", :devs_r => devs )
+          self.new(*params, type)
+        end
+      end
+    end
+  end
+end

data/lib/ms/lipid/search/query.rb

@@ -0,0 +1,23 @@
+
+
+
+module MS
+  class Lipid
+    class Search
+      class Query
+
+        # the experimentally observed lowest mz
+        attr_accessor :mz
+
+        # the index of search spectrum that the m/z was derived from
+        # this allows for the creation of an isotope envelope starting from a
+        # particular m/z value.
+        attr_accessor :index
+
+        def initialize(mz, index)
+          @mz, @index = mz, index
+        end
+      end
+    end
+  end
+end

data/lib/ms/lipid_maps.rb

@@ -0,0 +1,31 @@
+require 'ms/lipid'
+require 'ms/mass'
+
+module MS
+  module LipidMaps
+    # returns an array of Lipids
+    # if high_res_mass is true (default), then the formula is used to calculate a higher
+    # resolution mass than what is in lipidmaps
+    def self.parse_file(lipidmaps_tsv, high_res_mass=true, skip_clas_defs=true)
+      seen_first_line = false
+      IO.foreach(lipidmaps_tsv).map do |line|
+        line.chomp!
+        pieces = line.split("\t")
+        if pieces[3] !~ /[A-Z]/  # <- there is no formula!
+          nil
+        else
+          if seen_first_line
+            pieces[4] = MS::Mass.formula_to_exact_mass(pieces[3]) if high_res_mass
+            l = MS::Lipid.new *pieces
+          else
+            seen_first_line = true
+            warn "lipidmaps column headers are not right!" unless pieces.map(&:downcase) == MS::Lipid.members.map(&:to_s)
+            nil
+          end
+        end
+      end.compact
+    end
+  end
+end
+
+

data/spec/ms/lipid/ion_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+
+require 'ms/lipid'
+require 'ms/lipid/modification'
+require 'ms/lipid/ion'
+
+describe MS::Lipid::Ion do
+  before do
+    lipid = MS::Lipid.new
+    lipid.mass = 300.2
+    proton = MS::Lipid::Modification.new(:proton)
+    h2o_loss = MS::Lipid::Modification.new(:water, :loss => true)
+    @plus1 = MS::Lipid::Ion.new(lipid, [proton, h2o_loss])
+    @plus2 = MS::Lipid::Ion.new(lipid, [proton, proton, h2o_loss])
+  end
+
+  it 'calculates the correct m/z' do
+    @plus1.mz.should be_within(1e5).of(283.196711735)
+    @plus2.mz.should be_within(1e5).of(142.101994085)
+  end
+
+end

data/spec/ms/lipid/modification_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+require 'ms/lipid/modification'
+
+describe MS::Lipid::Modification do
+  Mod = MS::Lipid::Modification
+
+  it 'can create common mods easily' do
+    # water loss
+    water_loss = Mod.new(:water, :loss => true)
+    water_loss.loss?.should be_true
+    water_loss.massdiff.<(0).should be_true
+    water_loss.charge.should == 0
+    water_loss.charged_formula.should == 'H2O'
+
+    # proton gain
+    prot = Mod.new(:proton)
+    prot.gain?.should be_true
+    prot.massdiff.>(0).should be_true
+    prot.charge.should == 1
+    prot.charged_formula.should == 'H+'
+
+    ammon = Mod.new(:ammonium)
+    ammon.gain?.should be_true
+    ammon.massdiff.>(0).should be_true
+    ammon.charge.should == 1
+    ammon.charged_formula.should == 'NH3H+'
+  end
+
+  it 'can create custom mods' do
+    mymod = Mod.new(:super_snazzy)
+    mymod.formula.should be_nil
+    mymod.massdiff.should be_nil
+    mymod.charge.should be_nil
+
+    mymod.formula = 'CH4'
+    mymod.charge = 2
+    mymod.massdiff = MS::Lipid::Modification.massdiff(mymod.formula, mymod.charge)
+    mymod.massdiff.should be_within(1e4).of(16.030202)
+  end
+end

data/spec/ms/lipid/search_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+require 'ms/lipid_maps'
+require 'ms/lipid/search'
+require 'ms/lipid/search/query'
+require 'ms/lipid/modification'
+
+describe MS::Lipid::Search do
+  before do
+    @proton = MS::Lipid::Modification.new(:proton)
+    @h2o_loss = MS::Lipid::Modification.new(:water, :loss => true)
+  end
+  describe 'searching a section of lipid maps' do
+    before do
+      @lipids = MS::LipidMaps.parse_file(TESTFILES + '/lipidmaps_short.tsv')
+      @ions = @lipids.map do |lipid| 
+        [[@proton], [@proton, @h2o_loss]].map do |mods|
+          MS::Lipid::Ion.new(lipid, mods)
+        end
+      end.flatten(1)
+      @samples = Hash[ {
+        :sample1 => [[187.1633, 244.22, 616.51, 717.50], 
+          [100, 200, 100, 200]],
+        :sample2 => [[187.164, 396.15, 244.24, 347.28, 618.502],
+          [110, 210, 110, 210, 110]],
+        :sample3 => [[187.160, 396.28, 244.24, 347.263, 618.511],
+          [120, 220, 120, 220, 120]],
+        :sample4 => [[187.157, 396.20, 244.30, 618.22, 933.01],
+          [30, 33, 38, 99, 22]],
+      }.map {|key,data| [key, MS::Spectrum.new(data)] } ]
+      @pretend_search_mzs = [187.157, 396.20, 244.30, 618.22, 933.01]
+    end
+
+    xit 'creates a query search spectrum' do
+      #spec = .create_query_search_spectrum(@ions)
+      #spec.mzs.any? {|mz| mz.nil? }.should be_false
+      #spec.mzs.size.should == 56
+      #spec.intensities.map(&:size).count(2).should == 4
+      #spec.intensities.map(&:size).count(1).should == 52
+    end
+
+    xit 'creates a probability function' do
+      #subject.create_search_function(@ions, :prob_min_bincnt => 20)
+    end
+
+    xit 'searches mz values' do
+      searcher = MS::Lipid::Search.new(@ions, :query_min_count_per_bin => 8, :num_rand_samples_per_bin => 1000, :ppm => false)
+      num_nearest_hits = 3
+      (hit_groups, qvals) = searcher.search(@pretend_search_mzs, 3)
+      p hit_groups.map(&:first).map(&:pvalue)
+    end
+  end
+
+  describe 'searching a full lipid maps' do
+
+    before do
+      # this will be specific to your install since it's not part of install
+      path_to_lipidmaps_db = "#{ENV['HOME']}/tmp/tamil/lipidmaps_20120103_classes_1_2_3_4_5_6_7_8.exact_mass.tsv"
+      @lipids = MS::LipidMaps.parse_file(path_to_lipidmaps_db)
+      @ions = @lipids.map do |lipid| 
+        [[@proton], [@proton, @proton], [@proton, @h2o_loss]].map do |mods|
+          MS::Lipid::Search::Query.new(lipid, mods)
+        end
+      end.flatten(1)
+      @pretend_search_mzs = [187.157, 396.20, 244.30, 618.22, 933.01]
+    end
+
+    it 'returns hit groups parallel with input m/zs' do
+      searcher = MS::Lipid::Search.new(@ions, :query_min_count_per_bin => 1000, :ppm => false)
+      hit_groups = searcher.search(@pretend_search_mzs, 3)
+      best_hits = hit_groups.map(&:best_hit)
+      best_hits.map {|hit| hit.observed_mz }.should == @pretend_search_mzs
+    end
+
+    it 'works with :ppm => true'
+
+  end
+
+end

data/spec/ms/lipid_maps_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+require 'ms/lipid_maps'
+
+describe MS::LipidMaps do
+
+  before do
+    @tfile = TESTFILES + '/lipidmaps_short.tsv'
+  end
+
+  it 'parses lipid maps files' do
+    lipids = MS::LipidMaps.parse_file(@tfile)
+    lipids.size.should == 30  # one is rejected for no formula
+    ll = lipids.last
+    ll.sub_class.should == 'Isoflavonoids [PK1205]'
+    ll.lm_id.should == "LMPK12050388"
+  end
+end
+

data/spec/ms/lipid_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+require 'ms/lipid'
+
+describe MS::Lipid do
+
+  before do
+    @data = ['LMFA00000007', 'n-decanohydroxamic acid', 'N-hydroxydecanamide', 'C10H21NO2', 187.16, 'Fatty Acyls [FA]', 'Other Fatty Acyls [FA00]']
+  end
+
+  it 'can be initialized with an array' do
+    lipid = MS::Lipid.new(*@data)
+    lipid.mass.should == @data[4]
+    lipid.sub_class.should == nil
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end
+
+TESTFILES = File.expand_path(File.join(File.dirname(__FILE__), "testfiles"))

data/spec/testfiles/lipidmaps_short.tsv

@@ -0,0 +1,32 @@
+LM_ID	COMMON_NAME	SYSTEMATIC_NAME	FORMULA	MASS	CATEGORY	MAIN_CLASS	SUB_CLASS
+LMFA00000007	n-decanohydroxamic acid	N-hydroxydecanamide	C10H21NO2	187.16	Fatty Acyls [FA]	Other Fatty Acyls [FA00]	
+LMFA00000008	(9S,10S)-10-hydroxy-9-(phosphonooxy)octadecanoic acid	(9S,10S)-10-hydroxy-9-(phosphonooxy)octadecanoic acid	C18H37O7P	396.23	Fatty Acyls [FA]	Other Fatty Acyls [FA00]	
+LMFA00000009	N-(6-aminohexanoyl)-6-aminohexanoic acid	6-(6-aminohexanamido)hexanoic acid	C12H24N2O3	244.18	Fatty Acyls [FA]	Other Fatty Acyls [FA00]	
+LMFA00000014	Virodhamine	2-aminoethyl-5Z,8Z,11Z,14Z-eicosatetraenoate	C22H37NO2	347.28	Fatty Acyls [FA]	Other Fatty Acyls [FA00]	
+MGL02010062	DG(16:0/20:3(8Z,11Z,14Z)/0:0)[iso2]	1-hexadecanoyl-2-(8Z,11Z,14Z-eicosatrienoyl)-sn-glycerol	C39H70O5	618.52	Glycerolipids [GL]	Diradylglycerols [GL02]	Diacylglycerols [GL0201]
+LMGL02010063	DG(18:2(9Z,12Z)/18:2(9Z,12Z)/0:0)	1,2-di-(9Z,12Z-octadecadienoyl)-sn-glycerol	C39H68O5	616.51	Glycerolipids [GL]	Diradylglycerols [GL02]	Diacylglycerols [GL0201]
+LMGL02010064	DG(18:1(9Z)/18:3(9Z,12Z,15Z)/0:0)[iso2]	1-(9Z-octadecenoyl)-2-(9Z,12Z,15Z-octadecatrienoyl)-sn-glycerol	C39H68O5	616.51	Glycerolipids [GL]	Diradylglycerols [GL02]	Diacylglycerols [GL0201]
+LMGL02010065	DG(18:0/19:0/0:0)[iso2]	1-octadecanoyl-2-nonadecanoyl-sn-glycerol	C40H78O5	638.58	Glycerolipids [GL]	Diradylglycerols [GL02]	Diacylglycerols [GL0201]
+MGP01011596	PC(18:1(9Z)/13:0)	1-(9Z-octadecenoyl)-2-tridecanoyl-glycero-3-phosphocholine	C39H76NO8P	717.53	Glycerophospholipids [GP]	Glycerophosphocholines [GP01]	Diacylglycerophosphocholines [GP0101]
+LMGP01011597	PC(18:1(9Z)/14:1(9Z))	1-(9Z-octadecenoyl)-2-(9Z-tetradecenoyl)-glycero-3-phosphocholine	C40H76NO8P	729.53	Glycerophospholipids [GP]	Glycerophosphocholines [GP01]	Diacylglycerophosphocholines [GP0101]
+LMGP01011598	PC(18:1(9Z)/15:0)	1-(9Z-octadecenoyl)-2-pentadecanoyl-glycero-3-phosphocholine	C41H80NO8P	745.56	Glycerophospholipids [GP]	Glycerophosphocholines [GP01]	Diacylglycerophosphocholines [GP0101]
+LMGP01011599	PC(18:1(9Z)/15:1(9Z))	1-(9Z-octadecenoyl)-2-(9Z-pentadecenoyl)-glycero-3-phosphocholine	C41H78NO8P	743.55	Glycerophospholipids [GP]	Glycerophosphocholines [GP01]	Diacylglycerophosphocholines [GP0101]
+LMGP01011600	PC(18:1(9Z)/17:0)	1-(9Z-octadecenoyl)-2-heptadecanoyl-glycero-3-phosphocholine	C43H84NO8P	773.59	Glycerophospholipids [GP]	Glycerophosphocholines [GP01]	Diacylglycerophosphocholines [GP0101]
+MSP0502AN07	-	Galalpha1-3Galalpha1-3Galalpha1-3Galalpha1-4Galbeta1-4Glcbeta-Cer(d18:1/24:1(15Z))	C78H141NO33	1619.94	Sphingolipids [SP]	Neutral glycosphingolipids [SP05]	GalNAcbeta1-3Galalpha1-4Galbeta1-4Glc- (Globo series) [SP0502]
+LMSP0502AN08	-	Galalpha1-3Galalpha1-3Galalpha1-3Galalpha1-4Galbeta1-4Glcbeta-Cer(d18:1/26:1(17Z))	C80H145NO33	1647.97	Sphingolipids [SP]	Neutral glycosphingolipids [SP05]	GalNAcbeta1-3Galalpha1-4Galbeta1-4Glc- (Globo series) [SP0502]
+LMSP0502AO00	-	Galbeta1-3Galalpha1-4Galbeta1-4Glcbeta-Cer	-	-	Sphingolipids [SP]	Neutral glycosphingolipids [SP05]	GalNAcbeta1-3Galalpha1-4Galbeta1-4Glc- (Globo series) [SP0502]
+LMSP0502AO01	-	Galbeta1-3Galalpha1-4Galbeta1-4Glcbeta-Cer(d18:1/16:0)	C58H107NO23	1185.72	Sphingolipids [SP]	Neutral glycosphingolipids [SP05]	GalNAcbeta1-3Galalpha1-4Galbeta1-4Glc- (Globo series) [SP0502]
+MST02020021	Dehydroepiandrosterone	3beta-hydroxyandrost-5-en-17-one	C19H28O2	288.21	Sterol Lipids [ST]	Steroids [ST02]	C19 steroids (androgens) and derivatives [ST0202]
+LMST02020023	Epiandrosterone	3beta-hydroxy-androstan-17-one	C19H30O2	290.22	Sterol Lipids [ST]	Steroids [ST02]	C19 steroids (androgens) and derivatives [ST0202]
+LMST02020025	Fluoxymesterone	9alpha-fluoro-11beta,17beta-dihydroxy-17-methylandrost-4-en-3-one	C20H29FO3	336.21	Sterol Lipids [ST]	Steroids [ST02]	C19 steroids (androgens) and derivatives [ST0202]
+LMST02020026	Formyldienolone	11alpha,17beta-dihydroxy-17-methyl-3-oxoandrosta-1,4-diene-2-carboxaldehyde	C21H28O4	344.20	Sterol Lipids [ST]	Steroids [ST02]	C19 steroids (androgens) and derivatives [ST0202]
+LMST02020027	Mestanolone	17beta-hydroxy-17-methyl-androstan-3-one	C20H32O2	304.24	Sterol Lipids [ST]	Steroids [ST02]	C19 steroids (androgens) and derivatives [ST0202]
+MPR03010008	Decaprenol	3,7,11,15,19,23,27,31,35,39-decamethyltetraconta-2Z,6Z,10Z,14Z,18Z,22Z,26Z,30Z,34E,38-decaen-1-ol	C50H82O	698.64	Prenol Lipids [PR]	Polyprenols [PR03]	Bactoprenols [PR0301]
+LMPR03020001	undecaprenyl phosphate	3,7,11,15,19,23,27,31,35,39,43-undecamethyltetratetraconta-2Z,6Z,10Z,14Z,18Z,22Z,26Z,30Z,34E,38E,42-undecaen-1-yl phosphate	C55H91O4P	846.67	Prenol Lipids [PR]	Polyprenols [PR03]	Bactoprenol monophosphates [PR0302]
+LMPR03020002	Undecaprenyl phosphate mannose	Alpha-mannosyl-undecaprenyl phosphate	C61H101O9P	1008.72	Prenol Lipids [PR]	Polyprenols [PR03]	Bactoprenol monophosphates [PR0302]
+LMPR03020004	Dodecaprenyl phosphate-galacturonic acid	-	C66H107O10P	1090.76	Prenol Lipids [PR]	Polyprenols [PR03]	Bactoprenol monophosphates [PR0302]
+MPK12050384	Irisolidone	5,7-Dihydroxy-6,4'-dimethoxyisoflavone	C17H14O6	314.08	Polyketides [PK]	Flavonoids [PK12]	Isoflavonoids [PK1205]
+LMPK12050385	Tectorigenin	5,7,4'-Trihydroxy-6-methoxyisoflavone	C16H12O6	300.06	Polyketides [PK]	Flavonoids [PK12]	Isoflavonoids [PK1205]
+LMPK12050386	6-Hydroxygenistein	-	C15H10O6	286.05	Polyketides [PK]	Flavonoids [PK12]	Isoflavonoids [PK1205]
+LMPK12050387	Irisolone	4'-Hydroxy-5-methoxy-6,7-methylenedioxyisoflavone	C17H12O6	312.06	Polyketides [PK]	Flavonoids [PK12]	Isoflavonoids [PK1205]
+LMPK12050388	7-O-Methyltectorigenin	5,4'-Dihydroxy-6,7-dimethoxyisoflavone	C17H14O6	314.08	Polyketides [PK]	Flavonoids [PK12]	Isoflavonoids [PK1205]

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: ms-lipidomics
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- John T. Prince
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &7075680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+  type: :development
+  prerelease: false
+  version_requirements: *7075680
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &7075180 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *7075180
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &7074680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.4
+  type: :development
+  prerelease: false
+  version_requirements: *7074680
+- !ruby/object:Gem::Dependency
+  name: rcov
+  requirement: &7074200 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *7074200
+description: does ms lipidomics
+email: jtprince@gmail.com
+executables:
+- lipidomic-search.rb
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.rdoc
+files:
+- .document
+- .rspec
+- LICENSE
+- README.rdoc
+- Rakefile
+- bin/lipidomic-search.rb
+- lib/ms/lipid.rb
+- lib/ms/lipid/ion.rb
+- lib/ms/lipid/modification.rb
+- lib/ms/lipid/search.rb
+- lib/ms/lipid/search/bin.rb
+- lib/ms/lipid/search/db_isobar_group.rb
+- lib/ms/lipid/search/hit.rb
+- lib/ms/lipid/search/probability_distribution.rb
+- lib/ms/lipid/search/query.rb
+- lib/ms/lipid_maps.rb
+- spec/ms/lipid/ion_spec.rb
+- spec/ms/lipid/modification_spec.rb
+- spec/ms/lipid/search_spec.rb
+- spec/ms/lipid_maps_spec.rb
+- spec/ms/lipid_spec.rb
+- spec/spec_helper.rb
+- spec/testfiles/lipidmaps_short.tsv
+homepage: http://github.com/princelab/ms-lipidomics
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: mass spectrometry based lipidomics - especially shotgun lipidomics
+test_files: []