mspire 0.2.4 → 0.3.0

data/lib/ms/parser/mzdata/dom.rb

@@ -0,0 +1,160 @@
+require 'xml_style_parser'
+require 'ms/spectrum'
+require 'ms/scan'
+
+module MS::Parser::MzData ; end
+
+class MS::Parser::MzData::DOM
+  include XMLStyleParser
+  include MS::Parser::MzData
+
+  def initialize(parse_type=:msrun, version='1.0')
+    @method = parse_type
+    @version = version
+  end
+
+  # true if there is a node <dataProcessing><software><name>Bioworks Browser</...>
+  # otherwise false
+  def is_bioworks33?(description_node)
+    begin
+      software_node = description_node.find_first('child::dataProcessing').find_first('child::software')
+      name = software_node.find_first('child::name').content 
+      version = software_node.find_first('child::version').content 
+      ((name == 'Bioworks Browser') and (version == '3.3'))
+    rescue
+      false
+    end
+  end
+
+  # OPTIONS:
+  #   :msrun => MSRun    # use this object instead of creating one
+  #   :spectra => *true|false   # if false don't get spectra
+  def msrun(file, opts={})
+    unless opts.key?(:spectra)
+      opts[:spectra] = true
+    end
+    msrun_obj = 
+      if x = opts[:msrun]
+        msrun_obj = x
+      else
+        MS::MSRun.new
+      end
+    # should ensure that parsing is not counting spaces...
+
+    # a string we'd parse like this:
+    # doc = XML::Parser.string(st).parse
+
+    # WE NEED TO GET scan_count, start_time and end_time!!!!
+    id_to_scan_hash = {}
+
+    #    0   1       2             3       4     5          6
+    # %w(num msLevel retentionTime startMz endMz precursors spectrum)
+
+    root = get_root_node_from_file(file)
+    scan_count = 0
+    description = root.find_first('child::description')
+    bioworks33 = is_bioworks33?(description)  
+    spectrum_list = description.next
+    scans =
+    if bioworks33
+      [] #bioworks33 gives incorrect scan numbers!
+    else
+      Array(spectrum_list['count'].to_i)
+    end
+
+    # if I move from node to node, it means I've checked that it's a sequence
+    # and that the elements are req'd
+    if spectrum_list.child?
+      spectrum_n = spectrum_list.child
+      loop do
+        scan_count += 1
+        scan = MS::Scan.new(9)
+        id = spectrum_n["id"].to_i
+        id_to_scan_hash[id] = scan
+        spec_desc_n = spectrum_n.child   # required in sequence
+        spec_settings_n = spec_desc_n.child # required in sequence
+        if acq_n = spec_settings_n.find_first('descendant::acquisition')
+          scan[0] = acq_n['acqNumber'].to_i
+        else
+          scan[0] = id
+        end
+        spec_inst_n = spec_settings_n.find_first('child::spectrumInstrument')
+        scan[1] = spec_inst_n['msLevel'].to_i
+
+        if bioworks33
+          scans << scan # we can't trust the scan count!
+        else
+          scans[scan_count] = scan
+        end
+
+        scan[3] = spec_inst_n['mzRangeStart'].to_f
+        scan[4] = spec_inst_n['mzRangeStop'].to_f
+        spec_inst_n.find('child::cvParam').each do |cv_param|
+          if cv_param['name'] == 'TimeInMinutes'
+            scan[2] = cv_param['value'].to_f * 60 #convert to seconds
+          end
+        end
+        if scan[1] > 1  # precursormz info
+          prec_list_n = spec_settings_n.next
+          abort('can only process one precursor m/z right now!') if prec_list_n['count'] != '1'
+          precursors = prec_list_n.find('child::precursor').map do |prec_n|
+            # %w(mz inten parent ms_level parent charge_states)
+            prec = MS::Precursor.new
+            unless bioworks33  # bioworks33 points to the wrong scan!!!
+              prec[2] = id_to_scan_hash[prec_n['spectrumRef'].to_i]
+            end
+            prec[3] = prec_n['msLevel'].to_i
+            charges = []
+            prec_n.find('descendant::cvParam').each do |cv_param_n|
+              case cv_param_n['name']
+              when 'MassToChargeRatio'
+                prec[0] = cv_param_n['value'].to_f
+                # find the prec intensity
+                unless bioworks33
+                  prec[1] = prec[2].spectrum.intensity_at_mz(prec[0])
+                end
+              when 'ChargeState'
+                charges << cv_param_n['value'].to_i
+              end
+            end
+            prec[5] = charges
+            prec
+          end
+          scan[5] = precursors
+        else  # no precursors
+          scan[5] = []
+        end
+        # here's the one line way of doing it, but it's probably more clear in
+        # the loop
+        #while ((mz_array_bin_n = spec_desc_n.next).name != 'mzArrayBinary') do
+        if opts[:spectra]
+          mz_array_bin_n = nil
+          loop do
+            mz_array_bin_n = spec_desc_n.next
+            break if mz_array_bin_n.name == 'mzArrayBinary'
+          end
+          data_n = mz_array_bin_n.child
+          mz = MS::Spectrum.base64_to_array(data_n.content, data_n['precision'].to_i, ((data_n['endian']=='little') ? false : true))
+          inten_array_bin_n = mz_array_bin_n.next
+          data_n = inten_array_bin_n.child
+          inten = MS::Spectrum.base64_to_array(data_n.content, data_n['precision'].to_i, ((data_n['endian']=='little') ? false : true))
+          scan[6] = MS::Spectrum.new(mz, inten)
+        end
+
+        # set up the next loop
+        break unless spectrum_n = spectrum_n.next
+      end
+    end
+    if bioworks33
+      MS::MSRun.add_parent_scan(scans, opts[:spectra])
+    end
+    msrun_obj.scans = scans
+    msrun_obj.scan_count = scan_count
+    msrun_obj.start_time = msrun_obj.scans.first.time
+    msrun_obj.end_time = msrun_obj.scans.last.time
+  end
+
+end
+
+
+

data/lib/ms/parser/mzdata/libxml.rb

@@ -0,0 +1,7 @@
+
+class MS::Parser::MzData::LibXML < MS::Parser::MzData::DOM
+  def get_root_node_from_file(file)
+    XML::Document.file(file).root
+  end
+end
+

data/lib/ms/parser/mzdata.rb

@@ -0,0 +1,25 @@
+require 'ms/msrun'
+
+module MS; end
+
+module MS::Parser::MzData
+  Base_dir_for_parsers = 'ms/parser/mzdata'
+
+  # inherits XMLStyleParser and version
+  include MS::Parser
+  include XMLStyleParser
+ 
+  # returns a specific parser MS::Parser::MzXML::#{ParserType}
+  # based on choose_parser from xml_style_parser
+  def self.new(parse_type=:msrun, version='1.05')
+    @version = version
+    @method = parse_type
+    #p self.methods.grep /choose_parser/
+    XMLStyleParser.require_parse_files(Base_dir_for_parsers)
+    parser_class = XMLStyleParser.choose_parser(self, parse_type)
+    parser = parser_class.new(parse_type, version)
+  end
+
+end
+
+

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

@@ -0,0 +1,11 @@
+require 'ms/parser/mzxml/dom'
+
+class MS::Parser::MzXML::AXML < MS::Parser::MzXML::DOM
+  def get_root_node_from_string(string)
+    ::AXML.parse(string)
+  end
+  def get_root_node_from_file(file)
+    ::AXML.parse_file(file)
+  end
+end
+

data/lib/ms/parser/mzxml/dom.rb

@@ -0,0 +1,159 @@
+require 'xml_style_parser'
+require 'ms/spectrum'
+require 'ms/scan'
+
+
+class MS::Parser::MzXML::DOM
+  include XMLStyleParser
+  include MS::Parser::MzXML
+
+  #@@scan_atts = %w(num msLevel retentionTime startMz endMz precursors spectrum)
+
+  def initialize(parse_type=:msrun, version='1.0')
+    @method = parse_type
+    @version = version
+  end
+
+  def new_scan_from_hash(node)
+    scan = MS::Scan.new  # array class creates one with 9 positions
+    scan[0] = node['num'].to_i
+    scan[1] = node['msLevel'].to_i
+    scan[2] = node['retentionTime'][2...-1].to_f
+    if x = node['startMz']
+      scan[3] = x.to_f
+      scan[4] = node['endMz'].to_f
+    end
+    scan
+  end
+
+  # takes a scan node and creates a scan object
+  # the parent scan is the one directly above it in mslevel
+  # if the 
+  def create_scan(scan_n, scans_by_num, get_spectra=true)
+    if @version < '3.0'
+      scan = new_scan_from_hash(scan_n)
+      precs = []
+      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|
+          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
+          precs << prec
+        when 'peaks'
+          next unless get_spectra
+          # SHOULD be able to do this!!
+          #peaks_n = scan_n.find_first('child::peaks')
+          scan[6] = MS::Spectrum.from_base64_peaks(node.content, node['precision'].to_i)
+        end
+      end
+      scan[5] = precs
+      scan
+    else  # for version > 3.0 
+      abort 'not supporting version 3.0 just yet'
+      # 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
+  end
+
+
+  # returns an array of msrun objects
+  def msruns(file)
+    raise NotImplementedError
+  end
+
+  # returns a string with double </scan></scan> tags into single and missing
+  # </scan> tags after peaks added in
+  # we do this in windows style since these are generated off a windows
+  # machine only
+  def fix_bad_scan_tags(file)
+    IO.read(file).gsub(/<\/scan>\s+<\/scan>/m, '</scan>').gsub(/<\/peaks>\s+<scan/m, "</peaks>\r\n  </scan>\r\n  <scan")
+  end
+
+  # right now cannot parse multiple runs out of an mzXML version 2 file since
+  # this is built around a single run per file
+  # OPTIONS:
+  #   :msrun => MSRun    # use this object instead of creating one
+  #   :spectra => *true|false   # if false don't get spectra
+  def msrun(file, opts={})
+    unless opts.key?(:spectra)
+      opts[:spectra] = true
+    end
+
+    msrun_obj = 
+      if x = opts[:msrun]
+        msrun_obj = x
+      else
+        MS::MSRun.new
+      end
+
+    root = 
+      if @version == '2.0'
+        string = fix_bad_scan_tags(file)
+        get_root_node_from_string(string)
+      else
+        get_root_node_from_file(file)
+      end
+
+    # right now we are only finding the first msRun (probably a rare case of
+    # multiple runs in an mzXML file...)
+    msrun_n = 
+      if @version >= '2.0' 
+        kids = root.children.select {|v| v.name == 'msRun' }
+        raise(NotImplementedError, "one msrun per doc right now" ) if kids.size > 1
+        kids.first
+      else
+        root
+      end
+    if msrun_n.name != 'msRun'
+      raise RuntimeError, "extra node slipped in somehow"
+    end
+
+    ## 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
+
+    # we should be able to do this, but it's not working!!!
+    #scan_n = msrun_n.find_first('scan')
+    #while (scn_index < scan_count)
+    get_spectra = opts[:spectra]
+
+    msrun_n.each do |scan_n|
+      next unless scan_n.name == 'scan'
+      scan = create_scan(scan_n, scans_by_num, get_spectra)
+      scans[scn_index] = scan
+      #sc = scan_n.next
+      scans_by_num[scan[0]] = scan 
+      scn_index += 1
+    end
+
+
+    ## update the scan's parents
+    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...
+    # 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
+
+end
+
+
+

data/lib/ms/parser/mzxml/hpricot.rb

@@ -0,0 +1,253 @@
+
+require 'xml_style_parser'
+require 'ms/spectrum'
+require 'ms/scan'
+
+
+class MS::Parser::MzXML::Hpricot
+  include XMLStyleParser
+  include MS::Parser::MzXML
+
+  @@scan_atts = %w(num msLevel retentionTime startMz endMz precursors spectrum)
+
+  def initialize(parse_type=:msrun, version='1.0')
+    @method = parse_type
+    @version = version
+  end
+
+  def new_scan_from_hash(node)
+    scan = MS::Scan.new  # array class creates one with 9 positions
+    scan[0] = node['num'].to_i
+    scan[1] = node['msLevel'].to_i
+    scan[2] = node['retentionTime'][2...-1].to_f
+    if x = node['startMz']
+      scan[3] = x.to_f
+      scan[4] = node['endMz'].to_f
+    end
+    scan
+  end
+
+  # takes a scan node and creates a scan object
+  # the parent scan is the one directly above it in mslevel
+  # if the 
+  def create_scan(scan_n, scans_by_num, get_spectra=true)
+    if @version < '3.0'
+      scan = new_scan_from_hash(scan_n)
+      precs = []
+      scan_n.each_child do |node|
+        case node.name
+        when 'precursorMz'
+          # should be able to do this!!!
+          #scan[5] = scan_n.find('child::precursorMz').map do |prec_n|
+          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
+          precs << prec
+        when 'peaks'
+          next unless get_spectra
+          # SHOULD be able to do this!!
+          #peaks_n = scan_n.find_first('child::peaks')
+          scan[6] = MS::Spectrum.from_base64_peaks(node.content, node['precision'].to_i)
+        end
+      end
+      scan[5] = precs
+      scan
+    else  # for version > 3.0 
+      abort 'not supporting version 3.0 just yet'
+      # 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
+  end
+
+
+  # returns an array of msrun objects
+  def msruns(file)
+    raise NotImplementedError
+  end
+
+  # returns a string with double </scan></scan> tags into single and missing
+  # </scan> tags after peaks added in
+  # we do this in windows style since these are generated off a windows
+  # machine only
+  def fix_bad_scan_tags(file)
+    IO.read(file).gsub(/<\/scan>\s+<\/scan>/m, '</scan>').gsub(/<\/peaks>\s+<scan/m, "</peaks>\r\n  </scan>\r\n  <scan")
+  end
+
+  # right now cannot parse multiple runs out of an mzXML version 2 file since
+  # this is built around a single run per file
+  # OPTIONS:
+  #   :msrun => MSRun    # use this object instead of creating one
+  #   :spectra => *true|false   # if false don't get spectra
+  def msrun(file, opts={})
+    unless opts.key?(:spectra)
+      opts[:spectra] = true
+    end
+
+    msrun_obj = 
+      if x = opts[:msrun]
+        msrun_obj = x
+      else
+        MS::MSRun.new
+      end
+
+    doc = File.open(file) {|fh| ::Hpricot.XML(fh) }
+      #if @version == '2.0'
+      #  # may not be necessary in hpricot!
+      #  #string = fix_bad_scan_tags(file)
+      #  #XML::Parser.string(string).parse
+      #else
+      #  XML::Document.file(file)
+      #end
+    msrun_n = doc.at('msRun')
+
+    ## 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
+
+    # we should be able to do this, but it's not working!!!
+    #scan_n = msrun_n.find_first('scan')
+    #while (scn_index < scan_count)
+    get_spectra = opts[:spectra]
+
+    msrun_n.each_child do |scan_n|
+      p scan_n 
+      abort
+
+      next unless scan_n.name == 'scan'
+      scan = create_scan(scan_n, scans_by_num, get_spectra)
+      scans[scn_index] = scan
+      sc = scan_n.next
+      scans_by_num[scan[0]] = scan 
+      scn_index += 1
+    end
+
+
+    ## update the scan's parents
+    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...
+    # 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
+
+end
+
+
+
+=begin
+## THIS IS THE SAX PARSER VERSION.  IT NEEDS A BIT OF BRUSH UP AND IT WOULD
+## WORK.  I THINK THE default guy is probably faster
+
+  def msrun(file, msrun_obj)
+    # Figure out where the first scan is at in the file:
+    pos_after_first_scan = nil
+    File.open(file) do |fh|
+      fh.each do |line|
+        if line =~ /<scan/
+          pos_after_first_scan = fh.pos
+        end
+      end
+    end
+
+    # Get only the header:
+    header_string = IO.read(file, pos_after_first_scan)
+
+    @msrun_obj = msrun_obj
+    # Parse out the header info:
+    parser = XML::SaxParser.new
+    parser.string = header_string
+    parser.on_start_element do |name, attrs|
+      if name == 'msRun'
+        @msrun_obj.scan_count = attrs['scanCount'].to_i
+        @msrun_obj.start_time = attrs['startTime'][2...-1].to_f
+        @msrun_obj.end_time = attrs['endTime'][2...-1].to_f
+      end
+    end
+    parser.parse
+
+    
+    # Parse the scans out:
+    scan_st = 'scan'
+    prec_st = 'precursorMz'
+    peaks_st = 'peaks'
+    prec_inten_st = 'precursorIntensity'
+    precision_st = 'precision'
+
+    #parser = MS::Parser::MzXML::Hpricot::SaxParser::MSRun.new
+    parser = XML::SaxParser.new
+    parser.filename = file
+    parser.on_start_document do
+      @scans = []
+      @current_scan = nil
+      @get_peaks = false
+      @get_prec_mz = false
+    end
+
+    parser.on_characters do |chars|
+      if @get_peaks
+        @get_peaks << chars
+      elsif @get_prec_mz
+        @get_prec_mz << chars
+      end
+    end
+
+    parser.on_end_element do |el|
+      case el
+      when 'peaks'
+        @current_scan.spectrum = Spectrum.from_base64_peaks(@get_peaks, @precision, true)
+        @get_peaks = false
+      when 'precursorMz'
+        @current_scan[5] = [Precursor.new([@get_prec_mz.to_f])]
+        @get_prec_mz = false
+      end
+    end
+
+    parser.on_start_element do |name, attr_hash|
+      case name
+      when scan_st
+        @current_scan = new_scan_from_hash(attr_hash)
+        sz = @scans.size 
+        @scans << @current_scan
+      when prec_st
+        @current_scan[5].first[1] = attr_hash[prec_inten_st].to_f
+        @get_prec_mz = ''
+      when peaks_st
+        @precision = attr_hash[precision_st].to_i
+        case @version[0,1].to_ip
+        when 3
+          if ch['pairOrder'] != 'm/z-int' # only version 3.0 has others
+            abort "cannot yet read anything but 'm/z-int' pair order"
+          end
+        end
+        @get_peaks = ''
+      end
+    end
+    parser.parse
+
+    @msrun_obj.scans = @scans
+    @msrun_obj.scans.each_with_index do |sc,i|
+      if sc.spectrum.mz == nil
+        abort "INDEX: #{i}"
+      end
+    end
+    @msrun_obj
+  end
+=end
+
+
+

data/lib/ms/parser/mzxml/libxml.rb

@@ -0,0 +1,15 @@
+
+require 'ms/parser/mzxml/dom'
+
+class MS::Parser::MzXML::LibXML < MS::Parser::MzXML::DOM
+  def goot_root_node_from_string(string)
+    XML::Parser.string(string).parse.root
+  end
+  def get_root_node_from_file(file)
+    XML::Document.file(file).root
+  end
+end
+
+
+
+