ms-msrun 0.0.1

data/lib/ms/msrun.rb

@@ -0,0 +1,297 @@
+
+require 'ms/scan'
+require 'ms/precursor'
+require 'ms/spectrum'
+require 'ms/msrun/search'
+
+module Ms; end
+class Ms::Msrun
+
+  # the retention time in seconds of the first scan (regardless of any
+  # meta-data written in the header)
+  attr_accessor :start_time
+  # the retention time in seconds of the last scan (regardless of any
+  # meta-data written in the header)
+  attr_accessor :end_time
+  # an array of scans
+  attr_accessor :scans
+
+  # The filetype. Valid types (for parsing) are:
+  #   :mzxml
+  #   :mzdata
+  #   :mzml
+  attr_accessor :filetype
+
+  # the string passed in to open the file for reading
+  attr_accessor :filename
+
+  # The version string of this type of file
+  attr_accessor :version
+  # the total number of scans
+  attr_writer :scan_count
+
+  # The basename of the parent file listed (e.g., a .RAW file).  Note that in
+  # v1 mzXML this will be *.mzXML while in later versions it's *.RAW.
+  # See parent_basename_noext for more robust value
+  attr_accessor :parent_basename
+
+  # The location of the parent file (e.g., a .RAW file).  In version mzXML v1
+  # this will be nil.
+  attr_accessor :parent_location
+
+  # Opens the filename 
+  def self.open(filename, &block)
+    File.open(filename) {|io| block.call( self.new(io, filename) ) }
+  end
+
+  # takes an io object.  The preferred way to access Msrun objects is through
+  # the open method since it ensures that the io object will be available for
+  # the lazy evaluation of spectra.
+  def initialize(io, filename=nil)
+    @scan_counts = nil
+    @filename = filename
+    @filetype, @version = Utils.filetype_and_version(io)
+    parser = Utils.get_parser(@filetype, @version)
+    parser.new.parse(self, io, @version)
+    @scan_counts = nil  # <- to keep warnings away
+  end
+
+  def parent_basename_noext
+    @parent_basename.chomp(File.extname(@parent_basename))
+  end
+
+  # returns each scan
+  def each(&block)
+    scans.each(&block)
+  end
+
+  # opens the file and yields each scan in the block
+  def self.foreach(filename, &block)
+    self.open(filename) do |obj|
+      obj.each(&block)
+    end
+  end
+
+  def scans_by_ms_level
+    by_level = []
+    scans.each do |scan|
+      by_level[scan.ms_level] = scan
+    end
+    by_level
+  end
+
+  # returns an array, whose indices provide the number of scans in each index level the ms_levels, [0] = all the scans, [1] = mslevel 1, [2] = mslevel 2,
+  # ...
+  def scan_counts
+    return @scan_counts if @scan_counts
+    ar = []
+    ar[0] = 0
+    scans.each do |sc|
+      level = sc.ms_level
+      unless ar[level]
+        ar[level] = 0
+      end
+      ar[level] += 1
+      ar[0] += 1
+    end
+    @scan_counts = ar
+  end
+
+  def scan_count(mslevel=0)
+    if @scan_counts
+      @scan_counts[mslevel]
+    else
+      if mslevel == 0
+        @scan_count 
+      else
+        num = 0
+        scans.each do |sc|
+          if sc.ms_level == mslevel
+            num += 1
+          end
+        end
+        num
+      end
+    end
+  end
+
+  # for level 1, finds first scan and asks if it has start_mz/end_mz
+  # attributes.  for other levels, asks for start_mz/ end_mz and takes the
+  # min/max.  If start_mz and end_mz are not found, goes through every scan
+  # finding the max/min first and last m/z. returns [start_mz (rounded down to
+  # nearest int), end_mz (rounded up to nearest int)]
+  def start_and_end_mz(mslevel=1)
+    if mslevel == 1
+      # special case for mslevel 1 (where we expect scans to be same length)
+      scans.each do |sc|
+        if sc.ms_level == mslevel
+          if sc.start_mz && sc.end_mz
+            return [sc.start_mz, sc.end_mz]
+          end
+          break
+        end
+      end
+    end
+    hi_mz = nil
+    lo_mz = nil
+    # see if we have start_mz and end_mz for the level we want
+    # set the initial hi_mz and lo_mz in any case
+    have_start_end_mz = false
+    scans.each do |sc|
+      if sc.ms_level == mslevel
+        if sc.start_mz && sc.end_mz
+          lo_mz = sc.start_mz
+          hi_mz = sc.end_mz
+        else
+          mz_ar = sc.spectrum.mzs
+          hi_mz = mz_ar.last
+          lo_mz = mz_ar.first
+        end
+        break
+      end
+    end
+    if have_start_end_mz
+      scans.each do |sc|
+        if sc.ms_level == mslevel
+          if sc.start_mz < lo_mz
+            lo_mz = sc.start_mz
+          end
+          if sc.end_mz > hi_mz
+            hi_mz = sc.end_mz
+          end
+        end
+      end
+    else
+      # didn't have the attributes (find by brute force)
+      scans.each do |sc|
+        if sc.ms_level == mslevel
+          mz_ar = sc.spectrum.mzs
+          if mz_ar.last > hi_mz
+            hi_mz = mz_ar.last
+          end
+          if mz_ar.last < lo_mz
+            lo_mz = mz_ar.last
+          end
+        end
+      end
+    end
+    [lo_mz.floor, hi_mz.ceil]
+  end
+
+  # returns an array of times and parallel array of spectra objects.
+  # ms_level = 0  then all spectra and times
+  # ms_level = 1 then all spectra of ms_level 1
+  def times_and_spectra(ms_level=0)
+    spectra = []
+    if ms_level == 0
+      times = @scans.map do |scan|
+        spectra << scan.spectrum  
+        scan.time
+      end
+      [times, spectra]
+    else  # choose a particular ms_level
+      times = []
+      @scans.each do |scan|
+        if ms_level == scan.ms_level
+          spectra << scan.spectrum  
+          times << scan.time
+        end
+      end
+      [times, spectra]
+    end
+  end
+end
+
+
+module Ms::Msrun::Axml ; end  # so we can get our parser
+
+module Ms::Msrun::Utils
+
+  def self.get_parser(filetype, version)
+    require "ms/msrun/axml/#{filetype}"
+    parser_class = filetype.to_s.capitalize
+    base_class = Ms::Msrun::Axml
+    if base_class.const_defined? parser_class
+      base_class.const_get parser_class
+    else
+      raise RuntimeError, "no class #{base_class}::#{parser_class}"
+    end
+  end
+
+  # only adds the parent if one is not already present!
+  def self.add_parent_scan(scans, add_intensities=false)
+    prev_scan = nil
+    parent_stack = [nil]
+    ## we want to set the level to be the first mslevel we come to
+    prev_level = scans.first.ms_level
+    scans.each do |scan|
+      #next unless scan  ## the first one is nil, (others?)
+      level = scan.ms_level
+      if prev_level < level
+        parent_stack.unshift prev_scan
+      end
+      if prev_level > level
+        (prev_level - level).times do parent_stack.shift end
+      end
+      if scan.ms_level > 1
+        precursor = scan.precursor
+        #precursor.parent = parent_stack.first  # that's the next line's
+        precursor[2] = parent_stack.first unless precursor[2]
+        #precursor.intensity
+        if add_intensities
+          precursor[1] = precursor[2].spectrum.intensity_at_mz(precursor[0])
+        end
+      end
+      prev_level = level
+      prev_scan = scan
+    end
+  end
+
+  Mzxml_regexp = /http:\/\/sashimi.sourceforge.net\/schema(_revision)?\/([\w\d_\.]+)/o
+  # 'http://sashimi.sourceforge.net/schema/MsXML.xsd' # version 1
+  # 'http://sashimi.sourceforge.net/schema_revision/mzXML_X.X' # others
+  Mzdata_regexp = /<mzData.*version="([\d\.]+)"/m
+  Raw_header_unpack_code = '@2axaxaxaxaxaxaxa'
+  Mzml_regexp = /http:\/\/psi.hupo.org\/schema_revision\/mzML_([\w\d\.]+)/o
+
+  def self.filetype_and_version(file_or_io)
+    if file_or_io.is_a? IO
+      io = file_or_io
+      found = nil
+      # Test for RAW file:
+      header = io.read(18).unpack(Raw_header_unpack_code).join
+      if header == 'Finnigan'
+        return [:raw, nil]
+      end
+      io.rewind
+      while (line = io.gets)
+        found = 
+          case line
+          when Mzml_regexp
+            [:mzml, $1.dup]
+          when Mzxml_regexp
+            mtch = $2.dup
+            case mtch
+            when /mzXML_([\d\.]+)/
+              [:mzxml, $1.dup]
+            when /MsXML/
+              [:mzxml, '1.0']
+            else
+              abort "Cannot determine mzXML version!"
+            end
+          when Mzdata_regexp
+            [:mzdata, $1.dup]
+          end
+        if found
+          break
+        end
+      end
+      io.rewind
+      found
+    else
+      File.open(file_or_io) do |io|
+        filetype_and_version(io)
+      end
+    end
+  end
+end

data/lib/ms/msrun/axml/mzxml.rb

@@ -0,0 +1,141 @@
+
+require 'ms/msrun'
+require 'ms/precursor'
+require 'axml'
+
+module Ms
+  class Msrun
+    module Axml
+    end
+  end
+end
+
+class Ms::Msrun::Axml::Mzxml
+  NetworkOrder = true
+
+  # version is a string
+  def parse(msrun_obj, io, version)
+    root = AXML.parse(io, :text_indices => 'peaks', :parser => :xmlparser)
+    msrun_n = msrun_node(root, version)
+
+    # The filename
+    parent_n = msrun_n.find_first_child('parentFile')
+    fn = parent_n['fileName']
+    fn.gsub!(/\\/, '/')
+    msrun_obj.parent_basename = File.basename(fn)
+    dn = File.dirname(fn)
+    dn = nil if dn == '.' && !fn.include?('/')
+    msrun_obj.parent_location = dn
+
+    ## HEADER
+    scan_count = msrun_n['scanCount'].to_i
+    msrun_obj.scan_count = scan_count
+
+    scans_by_num = Array.new(scan_count + 1)
+
+    ## SPECTRUM
+    parent = nil
+    scans = Array.new( scan_count )
+    scn_index = 0
+
+    if version >= '3.0'
+      warn '[version 3.0 parsing may fail if > 1 peak list per scan]'
+      # note that mzXML version 3.0 *can* have more than one peak...
+      # I'm not sure how to deal with that since I have one spectrum/scan
+    end
+
+    scan_nodes = msrun_n.find_children('scan')
+    add_scan_nodes(scan_nodes, scans, scn_index, scans_by_num, version, io)
+
+    ## update the scan's parents
+    Ms::Msrun::Utils.add_parent_scan(scans)
+
+    # note that startTime and endTime are optional AND in >2.2 are dateTime
+    # instead of duration types!, so we will just use scan times...
+    # Also, note that startTime and endTime are BROKEN on readw -> mzXML 2.0
+    # export.  They give the start and end time in seconds, but they are
+    # really minutes.  All the more reason to use the first and last scans!
+    msrun_obj.start_time = scans.first.time
+    msrun_obj.end_time = scans.last.time
+    msrun_obj.scans = scans
+  end
+
+  # takes a scan node and creates a scan object
+  # the parent scan is the one directly above it in mslevel
+  def create_scan(scan_n, scans_by_num, io=nil)
+    scan = new_scan_from_node(scan_n)
+    prec = nil
+    scan_n.each do |node|
+      case node.name
+      when 'precursorMz'
+        # should be able to do this!!!
+        #scan[5] = scan_n.find('child::precursorMz').map do |prec_n|
+        raise RuntimeError, "the msrun object can only handle one precursor!" unless prec.nil?
+        prec = Ms::Precursor.new
+        prec[1] = node['precursorIntensity'].to_f
+        prec[0] = node.content.to_f
+        if x = node['precursorScanNum']
+          prec[2] = scans_by_num[x.to_i]
+        end
+      when 'peaks'
+        # assumes that parsing was done with a LazyPeaks parser!
+        nc = node.text
+        #p nc
+        #if nc.first < 0 || nc.last < 0
+        #  puts "PROBLEM: "
+        #  p nc
+        #  abort 'here'
+        #end
+        scan[8] = Ms::Spectrum.lazy(io, nc.first, nc.last, node['precision'].to_i, NetworkOrder)
+      end
+    end
+    scan[7] = prec
+    scan
+  end
+
+
+  # assumes that node contains scans and checks any scan nodes for children
+  def add_scan_nodes(nodes, scans, scn_index, scans_by_num, version, io)
+    nodes.each do |scan_n|
+      scan = create_scan(scan_n, scans_by_num, io)
+      #puts "scannum: "
+      #p scan[0]
+      scans[scn_index] = scan
+      scans_by_num[scan[0]] = scan 
+      scn_index += 1
+      if version > '1.0'
+        new_nodes = scan_n.find('child::scan')
+        if new_nodes.size > 0
+          scn_index = add_scan_nodes(new_nodes, scans, scn_index, scans_by_num, version, io)
+        end
+      end
+    end
+    scn_index
+  end
+
+  def msrun_node(node, version)
+    if version >= '2.0' 
+      kids = node.children.select {|v| v.name == 'msRun' }
+      raise(NotImplementedError, "one msrun per doc right now" ) if kids.size > 1
+      kids.first
+    else
+      node
+    end
+  end
+
+  def new_scan_from_node(node)
+    scan = Ms::Scan.new  # array class creates one with 9 positions
+    scan[0] = node['num'].to_i
+    scan[1] = node['msLevel'].to_i
+    if x = node['retentionTime']
+      scan[2] = x[2...-1].to_f
+    end
+    if x = node['startMz']
+      scan[3] = x.to_f
+      scan[4] = node['endMz'].to_f
+      scan[5] = node['peaksCount'].to_i
+      scan[6] = node['totIonCurrent'].to_f
+    end
+    scan
+  end
+end

data/lib/ms/msrun/search.rb

@@ -0,0 +1,118 @@
+
+module Ms
+  class Msrun
+
+    #config :first_scan, 0, :short => 'F', &c.integer # first scan
+    #config :last_scan, 1e12, :short => 'L', &c.integer  # last scan
+    ## if not determined to be +1, then create these charge states
+    #config( :charge_states, [2,3], :short => 'c') {|v| v.split(',') }
+    #config :bottom_mh, 0, :short => 'B', &c.float # bottom MH+ 
+    #config :top_mh, -1.0, :short => 'T', &c.float # top MH+
+    #config :min_peaks, 0, :short => 'P', &c.integer # minimum peak count
+    #config :ms_levels, 2..-1, :short => 'M', &c.range  # ms levels to export
+
+    module Search
+
+      PROTON_MASS = 1.007276
+
+      # returns a string, or writes the string to file if given an out_filename
+      # if given a filename or IO object, returns the number of spectra
+      # written
+      def to_mgf(file_or_io=nil, opts={})
+        opts = {
+          :bottom_mh => 0.0,
+          :top_mh => nil,
+          :ms_levels => (2..-1),  # range or intger, -1 at end will be substituted for last level
+          :min_peaks => 0,
+          :first_scan => 0,
+          :last_scan => nil,
+          :prec_mz_precision => 6,
+          :prec_int_precision => 2,
+          :frag_mz_precision => 5,
+          :frag_int_precision => 1,
+        }.merge(opts)
+       (_first_scan, _last_scan, _bottom_mh, _top_mh, _ms_levels, _min_peaks, _charge_states, _prec_mz_precision, _prec_int_precision, _frag_mz_precision, _frag_int_precision) = opts.values_at(:first_scan, :last_scan, :bottom_mh, :top_mh, :ms_levels, :min_peaks, :charge_states, :prec_mz_precision, :prec_int_precision, :frag_mz_precision, :frag_int_precision)
+
+       sep = ' '
+
+       if _top_mh.nil? || _top_mh == -1
+         _top_mh = nil
+       end
+
+       if _last_scan.nil? or _last_scan == -1
+         _last_scan = scans.last.num
+       end
+
+       if !_ms_levels.is_a?(Integer) && _ms_levels.last == -1
+         _ms_levels = ((_ms_levels.first)..(scan_counts.size-1))
+       end
+
+        prec_string = "PEPMASS=%0.#{_prec_mz_precision}f %0.#{_prec_int_precision}f\n"
+        frag_string = "%0.#{_frag_mz_precision}f%s%0.#{_frag_int_precision}f\n"
+
+        any_input(file_or_io) do |out, out_type|
+          scans.each do |scan|
+            sn = scan.num
+
+            next unless _ms_levels === scan.ms_level
+            next unless sn >= _first_scan and sn <= _last_scan
+            next unless scan.num_peaks >= _min_peaks
+
+            # tic under precursor > 95% and true = save the spectrum info
+            scan.spectrum.save!
+            if scan.plus1?(0.95)
+              _charge_states = [1]
+            end
+
+            # (scanHeader.precursorMZ * iCharge) - (iCharge - 1)*dChargeMass;
+
+            pmz = scan.precursor && scan.precursor.mz
+
+            _charge_states.each do |z|
+              mh = (pmz * z) - (z - 1)*PROTON_MASS
+              next unless (mh >= _bottom_mh) 
+              next unless (mh <= _top_mh) if _top_mh
+              out.puts "BEGIN IONS"
+              out.puts "TITLE=#{self.parent_basename_noext}.#{sn}.#{sn}.#{z}"
+              out.puts "CHARGE=#{z}+"
+              out.printf(prec_string, pmz, scan.precursor.intensity)
+              scan.spectrum.peaks do |mz,int|
+                out.printf(frag_string, mz, sep, int )
+              end
+              out.puts "END IONS\n\n"
+            end
+
+            scan.spectrum.flush!
+          end
+
+          if out_type == :string_io
+            out.string
+          else
+            count
+          end
+        end
+
+      end
+
+
+      # yields an IO object and the type input (:io, :filename, :string_io)
+      def any_input(arg, &block)
+        # this is pretty ugly, can we clean up?
+          if arg.is_a? IO  # an IO object passed in
+            block.call(arg, :io)
+          elsif arg && arg.is_a?(String)  # open the file
+            File.open(arg, 'w') do |io|
+              block.call(io, :filename)
+            end
+          else  # nil
+            st_io = StringIO.new
+            block.call(st_io, :string_io)
+          end
+      end
+
+
+    end
+
+    include Search
+  end
+end