mspire 0.5.0 → 0.6.1

data/lib/ms/mzml/plms1.rb

@@ -0,0 +1,34 @@
+
+require 'ms/plms1'
+
+module MS
+  class Mzml
+    # will use scan numbers if use_scan_nums is true, otherwise it will use index
+    # numbers in place of scan nums
+    def to_plms1(use_scan_nums=true)
+      spectrum_index_list = self.index_list[:spectrum]
+      scan_nums = 
+        if use_scan_nums 
+          spectrum_index_list.create_scan_to_index.keys
+        else
+          (0...spectrum_index_list.size).to_a
+        end
+      retention_times = self.enum_for(:each_spectrum_node).map do |xml_node|
+        rt_xml_node=xml_node.xpath("scanList/scan/cvParam[@accession='MS:1000016']")[0]
+        raise 'no retention time xml node' unless rt_xml_node
+        retention_time = rt_xml_node['value'].to_f
+        case rt_xml_node['unitName']
+        when 'minute'
+          retention_time * 60
+        when 'second'
+          retention_time
+        else
+          raise 'retention time must be in minutes or seconds (or add some code to handle)'
+        end
+      end
+      # plms1 only requires that the obect respond to :each, giving a spectrum
+      # object, so an Mzml object will work.
+      MS::Plms1.new(scan_nums, retention_times, self)
+    end
+  end
+end

data/lib/ms/mzml.rb

@@ -0,0 +1,197 @@
+require 'nokogiri'
+require 'io/bookmark'
+require 'zlib'
+require 'ms/mzml/index_list'
+require 'ms/spectrum'
+
+module MS
+  #     MS::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.peaks.each do |mz,intensity|
+  #           puts "mz: #{mz} intensity: #{intensity}" 
+  #         end
+  #       end
+  #     end
+  class Mzml
+    module Parser
+      NOBLANKS = ::Nokogiri::XML::ParseOptions::DEFAULT_XML | ::Nokogiri::XML::ParseOptions::NOBLANKS
+    end
+    include Enumerable
+
+    attr_accessor :filename
+    attr_accessor :io
+    attr_accessor :index_list
+    attr_accessor :encoding
+
+    # io must respond_to?(:size), giving the size of the io object in bytes
+    # which allows seeking.  #get_index_list is called to get or create the
+    # index list.
+    def initialize(io)
+      @io = io
+      @encoding = @io.bookmark(true) {|io| io.readline.match(/encoding=["'](.*?)["']/)[1] }
+      @index_list = get_index_list
+    end
+
+    class << self
+      # read-only right now
+      def open(filename, &block)
+        File.open(filename) do |io|
+          block.call(self.new(io))
+        end
+      end
+
+      def foreach(filename, &block)
+        open(filename) do |mzml|
+          mzml.each(&block)
+        end
+      end
+
+      # unpack binary data based on an accesions.  accessions must only
+      # respond to :include?  So, hash keys, a set, or an array will all work.
+      def unpack_binary(base64string, accessions)
+        compressed =
+          if accessions.include?('MS:1000574') then true # zlib compression
+          elsif accessions.include?('MS:1000576') then false # no compression
+          else raise 'no compression info: check your MS accession numbers'
+          end
+        precision_unpack = 
+          if accessions.include?('MS:1000523') then 'E*'
+          elsif accessions.include?('MS:1000521') then 'e*'
+          else raise 'unrecognized precision: check your MS accession numbers'
+          end
+        data = base64string.unpack("m*").first
+        unzipped = compressed ? Zlib::Inflate.inflate(data) : data
+        unzipped.unpack(precision_unpack)
+      end
+    end
+
+    # name can be :spectrum or :chromatogram
+    def get_xml_string(start_byte, name=:spectrum)
+      io.seek(start_byte)
+      data = []
+      regexp = %r{</#{name}>}
+      io.each_line do |line|
+        data << line 
+        #unless (line.index('<binary') && line[-12..-1].include?('</binary>'))
+          break if regexp.match(line)
+        #end
+      end
+      data.join
+    end
+
+    def each_spectrum(&block)
+      (0...@index_list[:spectrum].size).each do |int|
+        block.call spectrum(int)
+      end
+    end
+
+    # returns the Nokogiri::XML::Node object associated with each spectrum
+    def each_spectrum_node(&block)
+      @index_list[:spectrum].each do |start_byte|
+        block.call spectrum_node_from_start_byte(start_byte)
+      end
+    end
+
+    alias_method :each, :each_spectrum
+
+    def spectrum_node_from_start_byte(start_byte)
+      xml = get_xml_string(start_byte, :spectrum)
+      doc = Nokogiri::XML.parse(xml, nil, @encoding, Parser::NOBLANKS)
+      doc.root
+    end
+
+    # @param [Object] arg an index number (Integer) or id string (String)
+    # @return [MS::Spectrum] a spectrum object
+    def spectrum(arg)
+      ################### trouble
+      start_byte = index_list[0].start_byte(arg)
+      data_arrays = spectrum_node_from_start_byte(start_byte).xpath('//binaryDataArray').map do |binary_data_array_n|
+        accessions = binary_data_array_n.xpath('./cvParam').map {|node| node['accession'] }
+        base64 = binary_data_array_n.xpath('./binary').text
+        MS::Mzml.unpack_binary(base64, accessions)
+      end
+      MS::Spectrum.new(data_arrays)
+    end
+
+    # returns the number of spectra
+    def size
+      @index_list[:spectrum].size
+    end
+
+    alias_method :'[]', :spectrum
+
+    # @param [Integer] scan_num the scan number 
+    # @return [MS::Spectrum] a spectrum object, or nil if not found
+    # @raise [ScanNumbersNotUnique] if scan numbers are not unique
+    # @raise [ScanNumbersNotFound] if spectra exist but scan numbers were not
+    #   found
+    def spectrum_from_scan_num(scan_num)
+      @scan_to_index ||= @index_list[0].create_scan_index
+      raise ScanNumbersNotUnique if @scan_to_index == false
+      raise ScanNumbersNotFound if @scan_to_index == nil
+      spectrum(@scan_to_index[scan_num])
+    end
+
+    # @return [MS::Mzml::IndexList] or nil if there is no indexList in the
+    # mzML
+    def read_index_list
+      if offset=MS::Mzml::Index.index_offset(@io)
+        @io.seek(offset)
+        xml = Nokogiri::XML.parse(@io.read, nil, @encoding, Parser::NOBLANKS)
+        index_list = xml.root
+        num_indices = index_list['count'].to_i
+        array = index_list.children.map do |index_n|
+          #index = Index.new(index_n['name'])
+          index = Index.new
+          index.name = index_n['name'].to_sym
+          ids = []
+          index_n.children.map do |offset_n| 
+            index << offset_n.text.to_i 
+            ids << offset_n['idRef']
+          end
+          index.ids = ids
+          index
+        end
+        IndexList.new(array)
+      end
+    end
+    # Reads through and captures start bytes
+    # @return [MS::Mzml::IndexList] 
+    def create_index_list
+      indices_hash = @io.bookmark(true) do |inner_io|   # sets to beginning of file
+        indices = {:spectrum => {}, :chromatogram => {}}
+        byte_total = 0
+        @io.each do |line|
+          if md=%r{<(spectrum|chromatogram).*?id=['"](.*?)['"][ >]}.match(line)
+            indices[md[1].to_sym][md[2]] = byte_total + md.pre_match.bytesize
+          end
+          byte_total += line.bytesize
+        end
+        indices
+      end
+
+      indices = indices_hash.map do |sym, hash|
+        indices = Index.new ; ids = []
+        hash.each {|id, startbyte| ids << id ; indices << startbyte }
+        indices.ids = ids ; indices.name = sym
+        indices
+      end
+      IndexList.new(indices)
+    end
+
+    # reads or creates an index list
+    # @return [Array] an array of indices
+    def get_index_list
+      read_index_list || create_index_list
+    end
+
+    class ScanNumbersNotUnique < Exception
+    end
+    class ScanNumbersNotFound < Exception
+    end
+  end
+end
+

data/lib/ms/obo.rb

@@ -0,0 +1,38 @@
+
+module MS
+  class OBO
+    attr_accessor :header
+    attr_accessor :elements
+
+    def initialize(file_or_io)
+      obo = Obo::Parser.new(file_or_io)
+      elements = obo.elements.to_a
+      header = elements.shift
+    end
+    # returns an id to name Hash
+    def id_to_name
+      @id_to_name ||= build_hash('id', 'name')
+    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
+
+    protected
+    def build_hash(key,val)
+      hash = {}
+      elements.each do |el| 
+        tv = el.tagvalues
+        if val.nil?
+          hash[tv[key].first] = el
+        else
+          hash[tv[key].first] = tv[val].first
+        end
+      end
+      hash
+    end
+  end
+end

data/lib/ms/plms1.rb

@@ -0,0 +1,156 @@
+
+require 'write_file_or_string'
+require 'ms/spectrum'
+require 'stringio'
+require 'openany'
+
+module MS
+
+=begin
+  # if given scans, will use those, or optionally takes a block where an
+  # array of ms1 scans are yielded and it expects Enumerable scans back.
+  def to_plms1(scans=nil)
+    times = []
+    scan_numbers = []
+    spectra = []
+
+    unless scans
+      scans = []
+      self.each(:ms_level => 1, :precursor => false) do |scan|
+        scans << scan
+      end
+    end
+
+    if block_given?
+      scans = yield(scans)
+    end
+
+    scans.each do |scan|
+      times << scan.time
+      scan_numbers << scan.num
+      spec = scan.spectrum
+      spectra << [spec.mzs.to_a, spec.intensities.to_a]
+    end
+    plms1 = Plms1.new
+    plms1.times = times
+    plms1.scan_numbers = scan_numbers
+    plms1.spectra = spectra
+    plms1
+  end
+=end
+
+  # Prince Lab MS 1: a simple format for reading and writing 
+  # MS1 level mass spec data
+  # 
+  # see MS::Plms1::SPECIFICATION for the file specification
+  class Plms1
+    SPECIFICATION =<<-HERE
+        # The file format contains no newlines but is shown here broken into lines for
+        # clarity.  Data should be little endian.  Comments begin with '#' but are not
+        # part of the spec. Angled brackets '<>' indicate the data type and square
+        # brackets '[]' the name of the data. An ellipsis '...' represents a
+        # continuous array of data points.
+
+        <uint32>[Number of scans]
+        <uint32>[scan number] ...  # array of scan numbers as uint32
+        <float64>[time point] ...  # array of time points as double precision floats (in seconds)
+        # this is a repeating unit based on [Number of scans]:
+        <uint32>[Number of data rows]  #  almost always == 2 (m/z, intensity)
+        # this is a repeating unit based on [Number of data rows]
+        <uint32>[Number of data points]
+        <float64>[data point] ...  # array of data points as double precision floats
+    HERE
+
+    # an array of scan numbers
+    attr_accessor :scan_numbers
+    # an array of time data
+    attr_accessor :times
+    # an array that contains spectrum objects
+    attr_accessor :spectra
+
+    def initialize(_scan_numbers=[], _times=[], _spectra=[])
+      (@scan_numbers, @times, @spectra) = [_scan_numbers, _times, _spectra]
+    end
+
+    # returns an array of Integers
+    def read_uint32(io, cnt=1)
+      io.read(cnt*4).unpack("V*")
+    end
+
+    # returns an array of Floats
+    def read_float64(io, cnt=1)
+      io.read(cnt*8).unpack("E*")
+    end
+
+    # returns self for chaining
+    def read(io_or_filename)
+      openany(io_or_filename) do |io|
+        num_scans = read_uint32(io)[0]
+        @scan_numbers = read_uint32(io, num_scans)
+        @times = read_float64(io, num_scans)
+        @spectra = num_scans.times.map do
+          data = read_uint32(io)[0].times.map do
+            read_float64(io, read_uint32(io)[0])
+          end
+          MS::Spectrum.new(data)
+        end
+      end
+      self
+    end
+
+    def write_uint32(out, data)
+      to_pack = data.is_a?(Array) ? data : [data]
+      out << to_pack.pack('V*')
+    end
+
+    def write_float64(out, data)
+      to_pack = data.is_a?(Array) ? data : [data]
+      out << to_pack.pack('E*')
+    end
+
+    # writes an ascii version of the format
+    # It is the same as the binary format, except a newline follows each
+    # length indicator or array of data. An empty line represents an empty
+    # array.
+    def write_ascii(filename=nil)
+      write_file_or_string(filename) do |out|
+        out.puts scan_numbers.size
+        out.puts scan_numbers.join(' ')
+        out.puts times.join(' ')
+        spectra.each do |spectrum|
+          out.puts spectrum.size
+          if spectrum.size > 0
+            out.puts spectrum.mzs.size
+            out.puts spectrum.mzs.join(' ')
+            out.puts spectrum.intensities.size
+            out.puts spectrum.intensities.join(' ')
+          end
+        end
+      end
+    end
+
+    # returns the string if no filename given 
+    def write(filename=nil, ascii=false)
+      if ascii
+        write_ascii(filename)
+      else
+        write_file_or_string(filename) do |out|
+          write_uint32(out, spectra.size)
+          write_uint32(out, scan_numbers)
+          write_float64(out, times)
+          spectra.each do |spectrum|
+            write_uint32(out, spectrum.size)  # number of rows
+            if spectrum.size > 0
+              mzs = spectrum.mzs
+              write_uint32(out, mzs.size)
+              write_float64(out, mzs)
+              intensities = spectrum.intensities
+              write_uint32(out, intensities.size)
+              write_float64(out, intensities)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ms/quant/qspec/protein_group_comparison.rb

@@ -0,0 +1,22 @@
+require 'ms/quant/protein_group_comparison'
+
+module Ms
+  module Quant
+    module ProteinGroupComparison
+    end
+  end
+end
+
+class Ms::Quant::ProteinGroupComparison::Qspec
+  include Ms::Quant::ProteinGroupComparison
+
+  attr_accessor :qspec_results_struct
+
+  # takes a protein group object, an array of experiment names and a qspec
+  # results struct
+  def initialize(protein_group, experiments, qspec_results_struct)
+    super(protein_group, experiments, qspec_results_struct.counts_array)
+    @qspec_results_struct = qspec_results_struct
+  end
+end
+

data/lib/ms/quant/qspec.rb

@@ -0,0 +1,112 @@
+module Ms ; end
+module Ms::Quant ; end
+
+class Ms::Quant::Qspec
+
+  # personal communication with Hyungwon Choi: "We typically use nburn=2000,
+  # niter=10000, which is quite sufficient to guarantee the reproducibility of
+  # results using the same data."
+  NBURNIN = 2000
+  NITER = 10000
+  INIT_HEADER = %w(protid protLen)
+  DELIMITER = "\t"
+
+  SUBMITTED_TO_QSPEC = 'submitted_to_qspec.txt'
+
+  # takes an ordered list of conditions ['cond1', 'cond1', 'cond2', 'cond2'] and
+  # returns an array of ints [0,0,0,1,1,1...]
+  def self.conditions_to_ints(conditions)
+    i = 0
+    current_condition = conditions.first
+    conditions.map do |cond| 
+      if current_condition == cond ; i
+      else
+        i += 1
+        current_condition = cond
+        i
+      end
+    end
+  end
+
+  # returns an array of Results structs which is each row of the returned file
+  # works with V2 of QSpec
+  def self.results_array(resultsfile)
+    rows = IO.readlines(resultsfile).map {|line| line.chomp.split("\t") }
+    headers = rows.shift
+    start_bayes = headers.index {|v| v =~ /BayesFactor/i }
+    rows.map do |row| 
+      data = [row[0]]
+      data.push( row[1...start_bayes].map(&:to_f) )
+      data.push( *row[start_bayes,4].map(&:to_f) )
+      data.push( row[start_bayes+4] )
+      Results.new(*data)
+    end
+  end
+
+  # returns the right executable based on the array of conditions
+  def self.executable(conditions)
+    biggest_size = conditions.group_by {|v| v }.values.map(&:size).max
+    (biggest_size >= 3) ? 'qspecgp' : 'qspec'
+  end
+
+  # protname_length_pairs is an array of doublets: [protname, length]
+  # condition_to_count_array is an array doublets: [condition, array_of_counts]
+  def initialize(protname_length_pairs, condition_to_count_array)
+    @protname_length_pairs = protname_length_pairs
+    @condition_to_count_array = condition_to_count_array
+  end
+
+  def conditions
+    @condition_to_count_array.map(&:first)
+  end
+
+  # writes a qspec formatted file to filename
+  def write(filename)
+    ints = Ms::Quant::Qspec.conditions_to_ints(conditions)
+    header_cats = INIT_HEADER + ints
+    rows = @protname_length_pairs.map {|pair| pair.map.to_a }
+    @condition_to_count_array.each do |cond,counts|
+      rows.zip(counts) {|row,cnt| row << cnt }
+    end
+    File.open(filename,'w') do |out|
+      out.puts header_cats.join(DELIMITER)
+      rows.each {|row| out.puts row.join(DELIMITER) }
+    end
+  end
+
+  # returns an array of Qspec::Results objects (each object can be considered
+  # a row of data)
+  def run(normalize=true, opts={})
+    puts "normalize: #{normalize}" if $VERBOSE
+    tfile = Tempfile.new("qspec")
+    write(tfile.path)
+    if opts[:keep]
+      local_file = File.join(Dir.pwd,File.basename(tfile.path))
+      FileUtils.cp(tfile.path, local_file, :verbose => $VERBOSE)
+      puts "(copy of) file submitted to qspec: #{local_file}" if $VERBOSE
+    end
+    qspec_exe = self.class.executable(conditions)
+    cmd = [qspec_exe, tfile.path, NBURNIN, NITER, (normalize ? 1 : 0)].join(' ')
+    if $VERBOSE
+      puts "running #{cmd}" if $VERBOSE
+    else
+      cmd << " 2>&1"
+    end
+    reply = `#{cmd}`
+    puts reply if $VERBOSE
+    outfile = tfile.path + '_' + qspec_exe
+    results = self.class.results_array(outfile)
+    if opts[:keep]
+      local_outfile = File.join(Dir.pwd, File.basename(outfile))
+      FileUtils.cp(outfile, local_outfile, :verbose => $VERBOSE)
+      puts "(copy of) file returned from qspec: #{outfile}"
+    end
+    tfile.unlink
+    results
+  end
+
+  # for version 2 of QSpec
+  # counts array is parallel to the experiment names passed in originally
+  Results = Struct.new(:protid, :counts_array, :bayes_factor, :fold_change, :rb_stat, :fdr, :flag)
+end
+