mspire 0.2.4 → 0.3.0

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

@@ -0,0 +1,122 @@
+require 'strscan'
+
+module MS::Parser::MzXML ; end
+
+class MS::Parser::MzXML::Regexp
+  @@first_scan_regexp = /<scan /o
+  include MS::Parser::MzXML
+
+  def initialize(method=:msrun, version='1.0')
+    @method = method
+    @version = version
+  end
+
+  def parse(file)
+    send(@method, file) 
+  end
+
+  # returns a MS::MsRun Object
+  def msrun(file)
+    fh = File.open(file) 
+    get_header(fh)
+
+    fh.close
+  end
+
+  #def msrun(file, opts={})
+  #end
+
+  @@scan_re = /<scan.*?num="(\d+)"(.*?)<\/scan>/mo
+  def self.precursor_mz_and_intensity_by_scan(file)
+    prec_re = /msLevel="2".*?<precursorMz precursorIntensity="([\d\.]+)".*?>([\d\.]+)<\/precursorMz>/mo
+    self.by_scan_num(file, prec_re) {|match_obj| match_obj.captures.reverse}
+  end
+
+  # (array will likely start at 1!)
+  def self.by_scan_num(file, regex)
+    arr = []
+    File.open(file) do |fh|
+      string = fh.read 
+      matches = string.scan(@@scan_re)
+      matches.each do |matched|
+        if inner_match = regex.match(matched[1])
+          index = matched[0].to_i
+          arr[index] = yield(inner_match)
+        end
+      end
+    end
+    arr
+  end
+
+  # Returns array where array[scan_num] = precursorMz
+  # Parent scans armme not arrayed
+  # Values are strings.  Array index likely starts at 1!
+  # @TODO: replace the use of a yield block
+  def self.precursor_mz_by_scan(file)
+    prec_re = /msLevel="2".*?<precursorMz.*?>([\d\.]+)<\/precursorMz>/mo
+    self.by_scan_num(file, prec_re) {|match_obj| match_obj.captures[0]}
+  end
+
+end
+
+
+class MS::Parser::MzXML::Regexp::MsRun
+  @@scan_count_regexp = /scanCount="(\d+)"/o
+  @@start_time_regexp = /startTime="PT([\d\.]+)S"/o
+  @@end_time_regexp = /endTime="PT([\d\.]+)S"/o
+  @@first_scan_regexp = /<scan /
+
+  def initialize(version='1.0')
+    @version = version
+  end
+
+  def parse(io, msrun_object)
+    atts = {}
+    [:scan_count, :start_time, :end_time].zip(get_header_info(io)) {|v,k| atts[k] = v }
+    ###
+    # HERE <------------------------------------
+    abort "NEED TO FINISH WRITING SCANS EXTRACTOR!"
+    get_scans(io)
+    # HERE <------------------------------------
+
+    # set the attributes
+    atts.each do |k,v|
+      msrun_object.send(k,v)
+    end
+    # need to fill in the scan_counts array
+  end
+
+  # assumes the attributes are each on a line
+  def get_scans(io)
+    io.each do |line|
+    end
+  end
+
+  # returns [total_num_scans, start_time, end_time] and positions the handle
+  # so that the next 'gets' will call a scan
+  def get_header_info(io)
+    scan_count = nil
+    start_time = nil
+    end_time = nil
+
+    previous_position = nil
+    io.each do |line|
+      if line =~ @@scan_count_regexp
+        scan_count = $1.dup
+      end
+      if line =~ @@start_time_regexp
+        start_time = $1.dup
+      end
+      if line =~  @@end_time_regexp
+        end_time = $1.dup
+      end
+      if line =~ @@first_scan_regexp
+        io.pos = previous_position
+        break
+      end
+      previous_position = io.pos
+    end
+    [scan_count, start_time, end_time]
+  end
+
+end

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

@@ -0,0 +1,72 @@
+require 'rexml/document'
+require 'rexml/streamlistener'
+
+module MS::Parser::MzXML::REXMLStreamListener; end
+class MS::Parser::MzXML::REXMLStreamListener::PrecMzByNum; end
+
+module REXMLStreamListenerHelper
+  def parse_and_report(file, const, report_method=:report)
+    listener = self.const_get(const).new
+    File.open(file) do |fh|
+      REXML::Document.parse_stream(fh, listener)
+    end
+    listener.send(report_method)
+  end
+end
+
+class MS::Parser::MzXML::REXML 
+  include MS::Parser::MzXML
+
+  def initialize(version='1.0', method=:msrun)
+    @version = version
+    @method = parse_type
+  end
+
+  # returns an array indexed by scan_num that gives the precursor_mz
+  def precursor_mz_by_scan(file, opts={})
+    parse_and_report(file, PrecMzByNum)
+  end
+
+end
+
+
+
+
+# for REXML
+class MS::Parser::MzXML::REXML::PrecMzByNum
+  include REXML::StreamListener
+
+  attr_accessor :prec_mz
+  alias_method :report, :prec_mz
+
+  def initialize
+    @prec_mz = [] 
+    @scan_num = nil
+    @get_data = false
+  end
+
+  def tag_start(name,attrs)
+    if name == "scan"
+      @scan_num = attrs["num"].to_i 
+    elsif name == "precursorMz"
+      @get_data = true
+    end
+  end
+
+  def tag_end(name)
+    if name == "precursorMz"
+      @get_data = false
+    end
+  end
+
+  def text(txt)
+    if @get_data
+      @prec_mz[@scan_num] = txt
+    end
+  end
+
+end
+
+
+
+

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

@@ -0,0 +1,248 @@
+require 'xmlparser_wrapper'
+
+# this is the wrapper class
+class MS::Parser::MzXML::XMLParser
+  include XMLStyleParser
+  include MS::Parser::MzXML
+  include XMLParserWrapper
+
+  def initialize(parse_type=:msrun, version='1.0')
+    @method = parse_type
+    @version = version
+  end
+
+  # returns: [times_arr, [m/z,inten,m/z,inten...]]
+  # where times are time strings (in seconds)
+  def times_and_spectra(file, opts={})
+    parse_and_report(file, 'TimesAndSpectra')
+  end
+
+
+  ## IN PROGRESS ...
+  # opts is actually the msrun object that will be fleshed out in the parsing
+  def msrun(file, opts={})
+    p opts
+    fh = File.open(file)
+    reply = parse_and_report_io(fh, 'MsRunHeader')
+    p reply
+    abort
+    fh.close
+  end
+
+  def prec_mz_by_scan_num(file, opts={})
+  end
+
+  # could easily do this for all these guys
+  #def method_missing(*args)
+  #  method = args.shift
+  #  parse_and_report(
+  #end
+
+end
+
+class MS::Parser::MzXML::XMLParser::MsRunHeader < XMLParser
+  def initialize(version='1.0')
+    @version = version
+    @atts = []
+  end
+
+  def startElement(name,attrs)
+    case name
+    when 'msRun'
+      @atts = attrs.values_at(%w(scanCount startTime endTime))
+    end
+  end
+
+  def endElement(name)
+    if name == 'dataProcessing'
+      done
+      reset
+    end
+  end
+end
+
+class MS::Parser::MzXML::XMLParser::Spectrum < XMLParser
+  @@scan_atts = %w(num msLevel retentionTime startMz endMz)
+  @@precursor_mz_atts = %w(precursorIntensity)
+
+
+  def initialize(version='1.0')
+    @version = version
+    @spectrum = []
+    @current_scan = nil
+  end
+
+  def report
+    @spectrum
+  end
+
+  def startElement(name,attrs)
+    if name == 'scan'
+      vals = attrs.values_at(@@scan_atts)
+      vals[2] = vals[2][2...-1].to_f  #remove PT and trailing S
+      [0, 1].each do |i| vals[i] = vals[i].to_i end # num and ms_level
+      [3, 4].each do |i| vals[i] = vals[i].to_f end # start_mz and end_mz
+      @current_scan = MS::Scan.new(vals)
+    elsif name == 'precursorMz'
+      # 5, 6, 7 are the scans indices for prec_mz prec_inten and parent
+      @current_scan[6] = attrs['precursorIntensity'].to_f
+      @current_scan[5] = ''
+      @get_precursor_mz = true
+    elsif name == 'peaks'
+      @precision = attrs['precision'].to_i
+      @get_peaks = true
+      @current_peaks_string = ''
+    end
+  end
+
+  def endElement(name)
+    if name == 'peaks'
+      @get_peaks = false
+      @spectrum << Spectrum.new(@current_peaks_string, @precision)
+      @spectrum.context = @current_scan
+    elsif name == 'precursorMz'
+      @current_scan[5] = @current_scan[5].to_f
+      @get_precursor_mz = false
+    end
+  end
+
+  def character(data)
+    if @get_peaks
+      @current_peaks_string << data 
+    elsif @get_precursor_mz
+      @current_scan[5] << data
+    end
+  end
+
+end
+
+
+
+
+class MS::Parser::MzXML::XMLParser::PrecMzByNum < XMLParser
+  @scan_num = nil
+  @get_data = false
+
+  attr_accessor :prec_mz
+  alias_method :report, :prec_mz
+
+  def initialize
+    @prec_mz = [] 
+  end
+
+  def startElement(name,attrs)
+    if name == "scan"
+      @scan_num = attrs["num"].to_i
+    elsif name == "precursorMz"
+      @current_prec_mz = ""
+      @get_data = true
+    end
+  end
+
+  def endElement(name)
+    if name == "precursorMz"
+      @get_data = false
+      @prec_mz[@scan_num] = @current_prec_mz.to_f
+    end
+  end
+
+  def character(data)
+    if @get_data
+      @current_prec_mz << data
+    end
+  end
+
+end
+
+
+=begin
+
+
+# Returns parallel arrays (times, spectra) where each spectra is an array
+# containing alternating mz and intensity (MS1 scans only)
+# and times are strings with the time in seconds
+class MS::Parser::MzXML::XMLParser::TimesAndSpectra < XMLParser
+  include MS::Parser::MzXML
+  @@get_data = false
+  @@get_peaks = false
+  @@precision = 32 # @TODO: set dynamic
+
+  attr_accessor :times, :spectra
+  def times_and_spectra
+    [@times, @spectra]
+  end
+
+  alias_method :report, :times_and_spectra
+
+  def initialize(ms_level=1)
+    @ms_level = "#{ms_level}"
+    @times = []
+    @spectra = []
+  end
+
+  def startElement(name,attrs)
+    if name == "scan" && attrs["msLevel"] == @ms_level
+      @times << attrs["retentionTime"][2...-1]  # strip PT and S: "PTx.xxxxS"
+      @@get_peaks = true
+    elsif name == "peaks" && @@get_peaks
+      @@get_data = true
+      @data = ""
+    end
+  end
+
+  def character(data)
+    if @@get_data
+      @data << data
+    end
+  end
+
+  def endElement(name)
+    if name == "peaks" && @@get_peaks
+      @spectra << base64_peaks_to_array(@data, @@precision)
+      @@get_data = false
+      @@get_peaks = false
+    end
+  end
+
+end
+
+
+class MS::Parser::MzXML::XMLParser::TimeMzIntenIndexer < XMLParser
+
+  @@scan_num = nil
+  @@get_data = false
+
+  attr_accessor :scans_by_num
+  alias_method :report, :scans_by_num
+
+  def initialize
+    @current_scan = nil
+    @scans_by_num = []
+  end
+
+  def startElement(name,attrs)
+    if name == "scan"
+      num = attrs["num"].to_i
+      @current_scan = MS::Scan.new(num, attrs["msLevel"].to_i, attrs["retentionTime"].gsub(/^PT/,'').gsub(/S$/,'').to_f)
+      scans_by_num[num] = @current_scan
+    elsif name == "precursorMz"
+      @current_scan.prec_inten = attrs["precursorIntensity"].to_f
+      @@get_data = true
+    end
+  end
+
+  def endElement(name)
+    if name == "precursorMz"
+      @@get_data = false
+    end
+  end
+
+  def character(data)
+    if @@get_data
+      @current_scan.prec_mz = data
+    end
+  end
+
+end
+
+=end

data/lib/ms/parser/mzxml.rb

@@ -0,0 +1,175 @@
+require 'ms/msrun'
+
+module MS; end
+
+module MS::Parser::MzXML
+  Base_dir_for_parsers = 'ms/parser/mzxml'
+  # 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.0')
+    @version = version
+    @method = parse_type
+    XMLStyleParser.require_parse_files(Base_dir_for_parsers)
+    parser_class = XMLStyleParser.choose_parser(self, parse_type)
+    parser = parser_class.new(parse_type, version)
+  end
+
+  # Returns an array of scans indexed by scan number
+  # NOTE that the first scan (zero indexed) will likely be nil!
+  # accepts an optional parse_type = 'xmlparser' | 'rexml'
+  def scans_by_num(mzXML_file, parse_type=nil)
+    unless parse_type
+      parse_type = default_parser
+    end
+    scans = []
+    case parse_type
+    when 'xmlparser' 
+      parser = MS::MzXML::XMLParser::TimeMzIntenIndexer.new
+      parser.parse(IO.read(mzXML_file))
+      scans = parser.scans_by_num
+    when 'rexml' # use REXML
+      # This is really too slow for files of this size
+      doc = REXML::Document.new File.new(mzXML_file)
+      doc.elements.each('msRun/scan') do |scan|
+        rt = scan.attributes['retentionTime']  ## like PT0.154000S"
+        level = scan.attributes['msLevel']
+        to_print = []
+        prec_mz = nil
+        prec_int = nil
+        if level.to_i != 1
+          scan.elements.each("precursorMz") do |prec|
+            prec_mz = prec.text.to_f
+            prec_int = prec.attributes["precursorIntensity"].to_f
+          end
+        end
+        # remove the leading PT and trailing S on the retention time!
+        rt = rt[2...-1]
+
+        num = scan.attributes['num'].to_i
+        scans[num] = MS::Scan.new(num, scan.attributes['msLevel'].to_i, rt.to_f, prec_mz, prec_int) 
+      end #doc.elements
+    else
+      throw ArgumentError, "invalid parse type: #{parse_type}"
+    end
+    ## update the scans for parents
+    MS::Scan.add_parent_scan(scans)
+    scans
+  end
+
+  # Returns a Hash indexed by filename (with no extension) for a given path
+  # extension = glob (string) or regex
+  # The basename is given as: file.split('.').first
+  def precursor_mz_by_scan_for_path(path, extension, parse_type=nil)
+    hash = {}
+    Dir.chdir path do
+      files = []
+      if extension.class == String
+        files = Dir[extension]
+      elsif extension.class == Regexp
+        files = Dir.entries(".").find_all do |dir|
+          dir =~ extension
+        end
+      else
+        puts "extension: #{extension} not a String or Regexp!"
+      end
+      files.each do |file|
+        base = file.split('.').first
+        hash[base] = precursor_mz_by_scan(file, parse_type)
+      end
+    end
+    hash
+  end
+
+  # Returns hash where hash[scan_num] = [precursorMz, precursorIntensity]
+  # Parent scans are not hashed
+  # Keys and values are both strings
+  def precursor_mz_and_inten_by_scan(file)
+    # in progress
+  end
+
+  # Returns array where array[scan_num] = precursorMz
+  # precursorMz are Floats
+  # Array index likely starts at 1!
+  def precursor_mz_by_scan_num(file)
+    ## THIS SHOULD BE CREATED IN specific XML LIBS
+  end
+
+  # Returns a hash of basic info on an mzXML run:
+  #   *mzXML_elemt*   *hash keys (symbols)*
+  #   scanCount       scan_count
+  #   startTime       start_time
+  #   endTime         end_time
+  #   startMz         start_mz
+  #   endMz           end_mz
+  def basic_info(mzxml_file)
+    puts "parsing: #{mzxml_file} #{File.exist?(mzxml_file)}" if $VERBOSE
+    hash = {}
+    scan_count_tmp = []
+    (1..5).to_a.each do |n| scan_count_tmp[n] = 0 end
+    @fh = File.open(mzxml_file)
+    @line = ""
+    scan_count_tmp[0] = _el("scanCount").to_i
+    hash[:start_time] = _el("startTime").sub(/^PT/, "").sub(/S$/,"").to_f
+    hash[:end_time] = _el("endTime").sub(/^PT/, "").sub(/S$/,"").to_f
+    hash[:ms_level] = _el("msLevel").to_i
+    scan_count_tmp[1] = 1
+    if hash[:ms_level] == 1
+      hash[:start_mz] = _el("startMz").to_f
+      hash[:end_mz] = _el("endMz").to_f
+    end
+
+    while !@fh.eof?
+      @line = @fh.readline 
+      ms_level = _el("msLevel")
+      if ms_level
+        scan_count_tmp[ms_level.to_i] += 1
+      else
+        break
+      end
+    end
+    scan_count = []
+    scan_count_tmp.each do |cnt|
+      if cnt != 0
+        scan_count.push cnt
+      else
+        break
+      end
+    end
+    hash[:scan_count] = scan_count
+    @fh.close
+    hash
+  end
+  
+  # returns [start_mz, end_mz] of the first full scan (ms_level == 1)
+  def start_and_end_mz(mzxml_file)
+    @fh = File.open(mzxml_file)
+    ms_level = 0
+    @line = ""
+    while ms_level != 1
+      ms_level = _el("msLevel").to_i
+    end
+    start_mz = _el("startMz").to_f
+    end_mz = _el("endMz").to_f
+    @fh.close
+    [start_mz, end_mz]
+  end
+
+  def _el(name)
+    re = /#{name}="(.*)"/
+    while @line !~ re && !@fh.eof?
+      @line = @fh.readline
+    end
+    if $1
+      return $1.dup
+    else
+      return nil
+    end
+  end
+
+end
+
+