ms-msrun 0.0.1 → 0.1.0

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

@@ -1,4 +1,7 @@
 
+require 'ms/spectrum'
+require 'ms/data'
+require 'ms/data/lazy_io'
 require 'ms/msrun'
 require 'ms/precursor'
 require 'axml'
@@ -48,7 +51,7 @@ class Ms::Msrun::Axml::Mzxml
     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)
+    Ms::Msrun.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...
@@ -80,13 +83,8 @@ class Ms::Msrun::Axml::Mzxml
       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)
+        data = Ms::Data::LazyIO.new(io, nc.first, nc.last, Ms::Data::LazyIO.unpack_code(node['precision'].to_i, NetworkOrder))
+        scan[8] = Ms::Spectrum.new(Ms::Data::Interleaved.new(data))
       end
     end
     scan[7] = prec

data/lib/ms/msrun/index.rb

@@ -0,0 +1,130 @@
+require 'ms/msrun'
+
+module Ms ; end
+class Ms::Msrun ; end
+
+# an index by scan number of the doublets where each doublet = [start_byte,
+# length] for the scan.  Index objects are enumerable and yield doublets.
+# Index#scan_nums gives an array of the scan numbers.
+# Index#first and Index#last return the first and the last scan, regardless of
+# the scan numbers.
+#
+#     index.scan_nums  # -> [1,2,3,4]
+#     index.each do |starting_byte, length|
+#       IO.read(myfile.mzXML, length, starting_byte) # -> xml for each scan
+#     end
+#     index[0]         # -> nil
+#     index.first      # -> [<start_byte>, <length>] # for scan number 1 
+class Ms::Msrun::Index < Array
+  include Enumerable
+
+  MZXML_INDEX_TAG = 'indexOffset'
+  MZML_INDEX_TAG = 'indexListOffset'
+
+  # returns the length from the start to the first scan
+  def header_length
+    self.each {|pair| return (pair.first) }
+  end
+
+  # returns an array of the scan numbers
+  attr_reader :scan_nums
+
+  # takes an mzxml filename or io object
+  # and returns an array of offsets and lengths for the scans
+  # note that the offset 
+  def initialize(filename_or_io)
+    (ft, version) = Ms::Msrun.filetype_and_version(filename_or_io)
+    tag = case ft
+          when :mzml : MZML_INDEX_TAG
+          when :mzxml : MZXML_INDEX_TAG
+          end
+    fn = 
+      if filename_or_io.is_a? String
+        filename_or_io  # a filename
+      else # a File object
+        filename_or_io.path
+      end
+    size = File.size(fn)
+    io =
+      if filename_or_io.is_a? String
+        File.open(filename_or_io)
+      else
+        filename_or_io
+      end
+    (offset, length) = index_offset(io, size, tag)
+    io.pos = offset
+    xml = io.read(length)
+    io.close if filename_or_io.is_a?(String)
+    self.replace( index_to_array(xml, offset, ft) )
+    self
+  end
+
+  def each(&block)
+    scan_nums.each do |scan_num|
+      block.call( self[scan_num] )
+    end
+  end
+
+  def first
+    self[scan_nums.first]
+  end
+
+  def last
+    self[scan_nums.last]
+  end
+
+  # returns [index_offset, length_of_index]
+  def index_offset(io, size, tag=MZML_INDEX_TAG, bytes_backwards=150) # :nodoc:
+    tag_re = /<#{tag}>([\-\d]+)<\/#{tag}>/
+      io.pos = size-1
+    io.pos = io.pos - bytes_backwards
+    index_offset = nil
+    index_end = nil
+    io.each do |line|
+      if line =~ tag_re
+        index_offset = $1.to_i
+        index_end = io.pos - line.size
+        break
+      end
+    end
+    if index_offset
+      [index_offset, index_end - index_offset]
+    else
+      [nil,nil]
+    end
+  end
+
+  # last_offset is used to calculate the length of the last scan object (or
+  # whatever)
+  def index_to_array(xml_string, last_offset, type=:mzml) # :nodoc:
+    indices = []
+    @scan_nums = []
+    case type
+    when :mzxml
+      xml_string.each_line("\n") do |line|
+        if line =~ /id="(\d+)".*>(\d+)</
+          @scan_nums << $1.to_i
+          indices << $2.to_i
+        end
+      end
+      #doc = Nokogiri::XML.parse(xml_string, *Ms::Msrun::Nokogiri::PARSER_ARGS)
+      #root_el = doc.root
+      #raise RuntimeError, "expecting scan index!" unless root_el['name'] == 'scan'
+      #root_el.children.each do |el|
+      #  indices << el.text.to_i
+      #  @scan_nums << el['id'].to_i
+      #end
+    when :mzml
+      raise NotImplementedError
+    end
+    indices << last_offset
+
+    new_indices = []
+    0.upto(indices.size-2) do |i|
+      val = indices[i]
+      next unless val
+      new_indices[@scan_nums[i]] = [indices[i], indices[i+1] - indices[i]]
+    end
+    new_indices
+  end
+end

data/lib/ms/msrun/mzxml.rb

@@ -0,0 +1,12 @@
+
+require 'ms/spectrum'
+require 'ms/data'
+require 'ms/data/lazy_io'
+require 'ms/msrun'
+require 'libxml'
+
+
+LibXML::XML.default_keep_blanks = false
+
+
+LibXML::XML::Reader.io(

data/lib/ms/msrun/nokogiri.rb

@@ -0,0 +1,12 @@
+
+
+module Ms
+  class Msrun
+    module Nokogiri
+      NOBLANKS = ::Nokogiri::XML::ParseOptions::DEFAULT_XML | ::Nokogiri::XML::ParseOptions::NOBLANKS
+      PARSER_ARGS = [nil,nil,NOBLANKS]
+    end
+  end
+end
+
+

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

@@ -0,0 +1,168 @@
+
+require 'nokogiri'
+require 'ms/msrun/nokogiri'
+require 'ms/msrun'
+require 'ms/spectrum'
+require 'ms/data'
+require 'ms/data/lazy_io'
+require 'ms/precursor'
+require 'ms/mzxml'
+
+
+class Ms::Msrun::Nokogiri::Mzxml
+  NetworkOrder = true
+
+  attr_accessor :msrun, :io, :version
+
+  def initialize(msrun_object, io, version)
+    @msrun = msrun_object
+    @io = io
+    @version = version
+  end
+
+  # returns the msrun
+  def parse_header(byte_length_or_header_string)
+    string = 
+      if byte_length_or_header_string.is_a? Integer
+        @io.rewind
+        @io.read(byte_length_or_header_string)
+      else
+        length_or_header_string
+      end
+    doc = Nokogiri::XML.parse(string, *Ms::Msrun::Nokogiri::PARSER_ARGS)
+    msrun_n = doc.root 
+    if @version >= '2.0'
+      msrun_n = msrun_n.child
+    end
+    @msrun.scan_count = msrun_n['scanCount'].to_i
+    @msrun.start_time = msrun_n['startTime'][2...-1].to_f
+    @msrun.end_time = msrun_n['endTime'][2...-1].to_f
+
+    filename = msrun_n.search("parentFile").first['fileName']
+    (bn, dn) = Ms::Mzxml.parent_basename_and_dir(filename)
+    @msrun.parent_basename = bn
+    @msrun.parent_location = dn
+    @msrun
+  end
+
+  # returns the ms_level as an Integer, nil if it cannot be found.
+  def parse_ms_level(start_byte, length)
+    start_io_pos = @io.pos
+    @io.pos = start_byte
+    ms_level = nil
+    total_length = 0
+    @io.each("\n") do |line|
+      if line =~ /msLevel="(\d+)"/o
+        ms_level = $1.to_i
+        break
+      end
+      total_length += line.size
+      break if total_length > length
+    end
+    @io.pos = start_io_pos
+    ms_level
+  end
+
+  # assumes that the io object has been set to the beginning of the scan
+  # element.  Returns an Ms::Scan object
+  # options: 
+  #     :spectrum => true | false (default is true)
+  #     :precursor => true | false (default is true)
+  #
+  # Note that if both :spectrum and :precursor are set to false, the basic
+  # information in the scan node *is* parsed (such as ms_level)
+  def parse_scan(start_byte, length, options={})
+    opts = {:spectrum => true, :precursor => true}.merge(options)
+    start_io_pos = @io.pos
+    @io.pos = start_byte
+
+    # read in the data keeping track of peaks start and stop
+    string = ""
+    if opts[:spectrum]
+      string = @io.read(length)
+    else
+      # don't bother reading all the peak information if we aren't wanting it
+      # and can avoid it!  This is important for high res instruments
+      # especially since the peak data is huge.
+      @io.each do |line|
+        if md = %r{<peaks}.match(line)
+          # just add the part of the string before the <peaks> tag
+          string << line.slice!(0, md.end(0) - 6)
+          break
+        else
+          string << line
+          if string.size >= length
+            if string.size > length
+              string.slice!(0,length)
+            end
+            break
+          end
+        end
+      end
+    end
+
+    doc = Nokogiri::XML.parse(string, *Ms::Msrun::Nokogiri::PARSER_ARGS)
+    scan_n = doc.root
+    scan = new_scan_from_node( scan_n )
+    prec_n = scan_n.child
+
+    peaks_n = 
+      if prec_n.name == 'precursorMz'
+        if opts[:precursor]
+          prec = Ms::Precursor.new
+          prec[1] = prec_n['precursorIntensity'].to_f
+          prec[0] = prec_n.text.to_f
+          if x = prec_n['precursorCharge']
+            prec[3] = [x.to_i]
+          end
+          scan.precursor = prec
+        end
+        prec_n.next_sibling
+      else
+        prec_n # this is a peaks node
+      end
+
+    # is this for mzData?
+    #if x = node['precursorScanNum']
+    #  prec[2] = scans_by_num[x.to_i]
+    #end
+     
+    if opts[:spectrum]
+      # all mzXML (at least versions 1--3.0) *must* be 'network' byte order!
+      # data is stored as the base64 string until we actually try to access
+      # it!  At that point the string is decoded and knows it is interleaved
+      # data.  So, no spectrum is actually decoded unless it is accessed!
+      peaks_data = Ms::Data.new_interleaved(Ms::Data::LazyString.new(peaks_n.text, Ms::Data::LazyIO.unpack_code(peaks_n['precision'].to_i, NetworkOrder)))
+      spec = Ms::Spectrum.new(peaks_data)
+      scan[8] = Ms::Spectrum.new(peaks_data)
+    end
+    scan
+  end
+
+  def start_end_from_filter_line(line)
+    # "ITMS + c NSI d Full ms3 654.79@cid35.00 630.24@cid35.00 [160.00-1275.00]"
+    /\[([^-]+)-([^-]+)\]/.match(line)[1,2].map {|v| v.to_f }
+  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
+    end
+    scan[5] = node['peaksCount'].to_i
+    scan[6] = node['totIonCurrent'].to_f
+    if fl = node['filterLine']
+      (scan[3], scan[4]) = start_end_from_filter_line(fl)
+    end
+    scan
+  end
+
+end
+
+

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

@@ -0,0 +1,126 @@
+
+require 'ms/msrun'
+require 'ms/spectrum'
+require 'ms/data'
+require 'ms/data/lazy_io'
+require 'ms/precursor'
+require 'ms/mzxml'
+
+module Ms
+  class Msrun
+    module Regexp
+    end
+  end
+end
+
+class Ms::Msrun::Regexp::Mzxml
+
+  attr_accessor :msrun, :io, :version
+
+  def initialize(msrun_object, io, version)
+    @msrun = msrun_object
+    @io = io
+    @version = version
+  end
+
+  # returns the msrun
+  def parse_header
+    while line = @io.gets
+      if line =~ %r{\s+fileName=['"](.*?)['"]}
+        (bn, dn) = Ms::Mzxml.parent_basename_and_dir($1)
+        @msrun.parent_basename = bn
+        @msrun.parent_location = dn
+      end
+      if line =~ /\s+scanCount=['"](\w+)['"]/
+        @msrun.scan_count = $1.to_i
+      end
+      if line =~ /startTime=['"]([\w\.]+)['"]/
+        @msrun.start_time = $1[2...-1].to_f
+      end
+      if line =~ /endTime=['"]([\w\.]+)['"]/
+        @msrun.end_time = $1[2...-1].to_f
+      end
+      if @io =~ /^\s*<scan/
+        break
+      end
+    end
+    @msrun
+  end
+
+  def self.parse_precursor(line)
+    prec = Ms::Precursor.new
+    loop do
+      if line =~ /precursorIntensity=['"]([\d\.]+)['"]/
+        prec[1] = $1.to_f
+      end
+      if line =~ /precursorCharge=["'](\d+)["']/
+        prec[3] = [$1.to_i]
+      end
+      if line =~ %r{>([\d\.]+)</precursorMz>}
+        prec[0] = $1.to_f
+        break
+      end
+      line = io.gets
+    end
+  end
+
+  def self.parse_peaks
+    precision = 32
+    byte_order = 'network'
+    while line = @io.gets
+      if line =~ /(precision|byteOrder)=["'](\w+)["']/
+        case $1
+        when 'precision'
+          $2.to_i
+        when 'byteOrder'
+          byte_order = $2
+        end
+      end
+      if line =~ %r{</peaks>}
+        first_pos = line.index('>')
+        last_pos = @io.pos + line.rindex("</peaks>")
+        Ms::Spectrum
+        break
+      end
+    end
+  end
+
+  
+  # assumes that the io object has been set to the beginning of the scan
+  # element.  Returns an Ms::Scan object
+  def self.parse_scan(start_byte, length)
+    @io.pos = start_byte
+    hash = {}
+    while line = @io.gets do
+      if line =~ /^\s*<precursorMz/
+        self.parse_precursor(line)
+        self.parse_peaks
+        break
+      end
+      if line =~ /(\w+)=["'](\w+)["']/
+        hash[$1] = $2
+      end
+    end
+    new_scan_from_hash(hash)
+  end
+
+  def new_scan_from_hash(hash)
+    scan = Ms::Scan.new  # array class creates one with 9 positions
+    scan[0] = hash['num'].to_i
+    scan[1] = hash['msLevel'].to_i
+    if x = hash['retentionTime']
+      scan[2] = x[2...-1].to_f
+    end
+    if x = hash['startMz']
+      scan[3] = x.to_f
+      scan[4] = hash['endMz'].to_f
+      scan[5] = hash['peaksCount'].to_i
+      scan[6] = hash['totIonCurrent'].to_f
+    end
+    scan
+  end
+
+
+end
+
+