mspire 0.2.4 → 0.3.0

data/lib/{spec → ms/converter}/mzxml.rb

@@ -1,109 +1,77 @@
-
-require 'base64'
-
-module Spec; end
-
-module Spec::MzXML
-  Potential_mzxml_converters = %w(readw.exe readw t2x)
-
-  # takes PT2.7500000S and returns it as 2.700000 (no PT or S)
-  def strip_time(time)
-    return time[2...-1]
-  end
-
-   # first, converts backslash to forward slash in filename.
-  # if .mzXML returns the filename
-  # if .raw or .RAW converts the file to .mZXML and returns mzXML filename
-  # if no recognized extension, looks for .mzXML file, then .RAW file (and
-  # converts)
-  # aborts if file was not able to be converted
-  # returns nil if a file that can be converted or used was not found
-  def self.file_to_mzxml(file)
-    file.gsub!("\\",'/')
-    old_file = file.dup
-    if file =~ /\.mzXML$/
-      return file
-    elsif file =~ /\.RAW$/i
-      old_file = file.dup
-      ## t2x outputs in cwd (so go to the directory of the file!)
-      dir = File.dirname(file)
-      basename = File.basename(file)
-      converter = Spec::MzXML.find_mzxml_converter
-      Dir.chdir(dir) do 
-        if converter =~ /readw/
-          cmd = "#{converter} #{basename} c #{basename.sub(/\.RAW$/i, '.mzXML')}"
-        else
-          cmd = "#{converter} #{basename}"
-        end
-        #puts cmd
-        #puts `#{cmd}`
-        reply = `#{cmd}`
-        puts reply if $VERBOSE
-      end
-      file.sub!(/\.RAW$/i, '.mzXML')
-      unless File.exist? file
-        abort "Couldn't convert #{old_file} to #{file}"
-      end
-      return file
-    else 
-      if File.exist?( file + '.mzXML' )
-        return file_to_mzxml(file + '.mzXML')
-      elsif File.exist?( file + '.RAW' )
-        return file_to_mzxml(file + '.RAW')
-      elsif File.exist?( file + '.raw' )
-        return file_to_mzxml(file + '.raw')
-      else
-        return nil
-      end
-    end
-      
-  end
-
-
-
-  # takes a base64 peaks string and returns an array of [m/z,intens] doublets
-  # mzXML as network ordered
-  def base64_peaks_to_pairs(string, precision=32)
-    data = base64_peaks_to_array(string, precision)
-    ndata = []
-    data.each_with_index do |dat,ind|
-      if (ind % 2) == 0  # even
-        arr = Array.new(2)
-        arr[0] = dat
-        ndata.push( arr )
-      else
-        ndata.last[1] = dat 
-      end
-    end
-    ndata
-  end
-
-  # takes a base64 peaks string and returns an array of alternating m/z and
-  # intensity mzXML as network ordered
-  def base64_peaks_to_array(string, precision=32)
-    b64d = Base64.decode64(string) 
-    if precision == 32
-      unpack_code = "g*"
-    elsif precision == 64
-      unpack_code = "G*"
-    end
-    b64d.unpack(unpack_code)
-  end
-
-  # Searchs each path element and returns the first one it finds
-  # returns nil if none found
-  def self.find_mzxml_converter
-    ENV['PATH'].split(/[:;]/).each do |path|
-      Dir.chdir(path) do
-        Potential_mzxml_converters.each do |pc|
-          if File.exist? pc
-            return File.join(path, pc)
-          end
-        end
-      end
-    end
-    nil
-  end
-
- 
-end
+
+module MS ; end
+module MS::Converter ; end
+module MS::Converter::MzXML
+  Potential_mzxml_converters = %w(readw.exe readw t2x)
+
+  # takes PT2.7500000S and returns it as 2.700000 (no PT or S)
+  #def strip_time(time)
+  #  return time[2...-1]
+  #end
+
+   # first, converts backslash to forward slash in filename.
+  # if .mzXML returns the filename
+  # if .raw or .RAW converts the file to .mZXML and returns mzXML filename
+  # if no recognized extension, looks for .mzXML file, then .RAW file (and
+  # converts)
+  # aborts if file was not able to be converted
+  # returns nil if a file that can be converted or used was not found
+  def self.file_to_mzxml(file)
+    file.gsub!("\\",'/')
+    old_file = file.dup
+    if file =~ /\.mzXML$/
+      return file
+    elsif file =~ /\.RAW$/i
+      old_file = file.dup
+      ## t2x outputs in cwd (so go to the directory of the file!)
+      dir = File.dirname(file)
+      basename = File.basename(file)
+      converter = MS::MzXML.find_mzxml_converter
+      Dir.chdir(dir) do 
+        if converter =~ /readw/
+          cmd = "#{converter} #{basename} c #{basename.sub(/\.RAW$/i, '.mzXML')}"
+        else
+          cmd = "#{converter} #{basename}"
+        end
+        #puts cmd
+        #puts `#{cmd}`
+        reply = `#{cmd}`
+        puts reply if $VERBOSE
+      end
+      file.sub!(/\.RAW$/i, '.mzXML')
+      unless File.exist? file
+        abort "Couldn't convert #{old_file} to #{file}"
+      end
+      return file
+    else 
+      if File.exist?( file + '.mzXML' )
+        return file_to_mzxml(file + '.mzXML')
+      elsif File.exist?( file + '.RAW' )
+        return file_to_mzxml(file + '.RAW')
+      elsif File.exist?( file + '.raw' )
+        return file_to_mzxml(file + '.raw')
+      else
+        return nil
+      end
+    end
+      
+  end
+
+
+  # Searchs each path element and returns the first one it finds
+  # returns nil if none found
+  def self.find_mzxml_converter
+    ENV['PATH'].split(/[:;]/).each do |path|
+      Dir.chdir(path) do
+        Potential_mzxml_converters.each do |pc|
+          if File.exist? pc
+            return File.join(path, pc)
+          end
+        end
+      end
+    end
+    nil
+  end
+ 
+end
+

data/lib/ms/gradient_program.rb

@@ -0,0 +1,171 @@
+require 'array_class'
+
+# This is modeled after the Thermo gradient
+class GradientProgram
+  attr_accessor :time_points
+  attr_accessor :pump_type
+  # array of solvents parallel to TimePoint percentages array
+  attr_accessor :solvents
+
+  def initialize(pump_type, time_points=[], solvents=[])
+    @pump_type = pump_type
+    @time_points = time_points
+    @solvents = solvents
+  end
+
+  def ==(other)
+    self.class == other.class and @pump_type==other.pump_type and @solvents == other.solvents and @time_points == other.time_points
+  end
+
+  # gets the first gradient program encountered in the filehandle
+  def self.get_gradient_program(fh)
+    thermo_newline = "\n\000"
+    #gtable = "g\000r\000a\000d\000i\000e\000n\000t\000 \000t\000a\000b\000l\000e"
+    gradient = "[Gg]\000r\000a\000d\000i\000e\000n\000t\000 \000"
+    
+    
+    xcal_2x = gradient + "t\000a\000b\000l\000e\000:\000"
+    xcal_1x = gradient + "P\000r\000o\000g\000r\000a\000m\000:\000"
+    xcal_2x_regexp = Regexp.new(xcal_2x)
+    xcal_1x_regexp = Regexp.new(xcal_1x)
+    find_gtable_regexp = Regexp.new(gradient)
+
+    found_one_2x = false
+    found_one_1x = false
+    pump_type = ''
+    fh.each(thermo_newline) do |line|
+      # first identify the line, then 
+      if line =~ find_gtable_regexp
+        if line =~ xcal_1x_regexp
+          pump_type = ''  ## have to look way back in file for this
+          found_one_1x = true
+          break
+        elsif line =~ xcal_2x_regexp
+          grab_pump_type_regexp = /(.*) .g.r.a.d.i.e.n.t. .t.a.b.l.e/
+          pump_type = read_thermo_string(grab_pump_type_regexp.match(line).captures[0])
+          found_one_2x = true
+          break
+        end
+      end
+    end
+    if found_one_2x
+      fh.gets(thermo_newline) # nothing
+      table_headers = fh.gets(thermo_newline)
+      time_points = []
+      while (line = fh.gets(thermo_newline)) != thermo_newline
+        # 0   0.00  95.0  5.0   0.0   0.0   38.0   x   
+        # 1   1.00  90.0  10.0  0.0   0.0   38.0   o
+
+        pieces = table_row_to_pieces(line, '2.0')
+        time_points << TimePoint.new(pieces[1].to_f, pieces[6].to_f, pieces[2,4].map{|x| x.to_f })
+      end
+      GradientProgram.new(pump_type, time_points, %w(A B C D))
+    elsif found_one_1x
+      fh.gets(thermo_newline) # nothing
+      table_headers = fh.gets(thermo_newline)
+      time_points = []
+      null_char_regexp = Regexp.new("^\000\000\000\000")
+      while (line = fh.gets(thermo_newline)) !~ null_char_regexp
+        pieces = table_row_to_pieces(line, '1.0')
+        time_points << TimePoint.new(pieces[1].to_f, pieces[6].to_f, pieces[2,4].map{|x| x.to_f })
+      end
+      GradientProgram.new(pump_type, time_points, %w(A B C D))
+    else
+      nil
+    end
+  end
+
+  # returns the elements of a gradient table row properly cast
+  # NOTE: Xcal 2.X starts index with 0, 1.X starts with 1
+  # (and this is how it will be returned!)
+  # NOTE: Xcal 1.X will be shorter by one (doesn't have the o/x string!)
+  # [(Int) index, time (Float), %A (Float), %B (Float), %C (Float), %D (Float),
+  # FlowRate (Float), o/x (String)]
+  def self.table_row_to_pieces(line,xcal_version='2.0')
+    string = read_thermo_string(line)
+    if xcal_version >= '2.0'
+      # at first, I thought you could just split on spaces, but the table is
+      # designed to have a certain number of chars per column padded with
+      # spaces.  This is hte way to do it.
+      index = string[0,4].to_i
+      (tm, a, b, c, d) = (0...5).to_a.map do |x|
+        string[(x*6)+4,6].rstrip.to_f
+      end
+      fr = string[34,7].rstrip.to_f
+      ox = string[41,4].rstrip
+      [index, tm, a, b, c, d, fr, ox]
+    else
+      index = string[0,5].lstrip.to_i # correct
+      tm = string[5,13].lstrip.to_f # correct
+      #puts "**" + string[18,16] + "**"
+      fr = string[18,16].lstrip.to_f
+      (a,b,c,d) = (0..3).to_a.map do |x|
+        string[(x*8)+34, 8].lstrip.to_f # correct
+      end
+      [index, tm, a, b, c, d, fr]
+    end
+  end
+
+  # takes a filehandle
+  # returns an array of gradient programs from a thermo filehandle.
+  # Acceptable file types include a .meth file and a .raw file
+  def self.all_from_handle(fh)
+    # 0005340: 3000 2e00 3000 3000 0a00 0a00 5300 6100  0...0.0.....S.a.
+    # 0005350: 6d00 7000 6c00 6500 2000 5000 7500 6d00  m.p.l.e. .P.u.m.
+    # 0005360: 7000 2000 6700 7200 6100 6400 6900 6500  p. .g.r.a.d.i.e.
+    # 0005370: 6e00 7400 2000 7400 6100 6200 6c00 6500  n.t. .t.a.b.l.e.
+    # 0005380: 3a00 0a00 0a00 4e00 6f00 2e00 2000 5400  :.....N.o... .T.
+    # 0005390: 6900 6d00 6500 2000 2000 4100 2500 2000  i.m.e. . .A.%. .
+    # 00053a0: 2000 2000 2000 4200 2500 2000 2000 2000   . . .B.%. . . .
+    # 00053b0: 2000 4300 2500 2000 2000 2000 2000 4400   .C.%. . . . .D.
+    # 00053c0: 2500 2000 2000 2000 2000 b500 6c00 2f00  %. . . . ...l./.
+    # 00053d0: 6d00 6900 6e00 2000 0a00 3000 2000 2000  m.i.n. ...0. . .
+    # 00053e0: 2000 3000 2e00 3000 3000 2000 2000 3000   .0...0.0. . .0.
+    # 00053f0: 2e00 3000 2000 2000 2000 3000 2e00 3000  ..0. . . .0...0.
+    # 0005400: 2000 2000 2000 3100 3000 3000 2e00 3000   . . .1.0.0...0.
+    programs = []
+    while (gp = get_gradient_program(fh))
+      programs << gp 
+    end
+    programs
+  end
+
+  def self.read_thermo_string(string)
+    chars = []
+    (0...string.size).step(2) do |i|
+      chars << string[i,1]
+    end
+    chars.join
+  end
+
+  def self.read_thermo_string_as_hex(string)
+    chars = []
+    (0...string.size).step(4) do |i|
+      chars << string[i,2]
+    end
+    [chars.join].pack('H*')
+  end
+
+
+end
+
+class GradientProgram::TimePoint
+  # time in minutes
+  attr_accessor :time
+  # flow_rate in ul/min
+  attr_accessor :flow_rate
+  # percentages
+  attr_accessor :percentages
+
+  def initialize(time=nil, flow_rate=nil, percentages=[])
+    @time = time
+    @flow_rate = flow_rate
+    @percentages = percentages
+  end
+
+  def ==(other)
+    self.class == other.class and @time==other.time and @flow_rate == other.flow_rate and @percentages == other.percentages
+  end
+end
+
+

data/lib/ms/msrun.rb

@@ -0,0 +1,209 @@
+
+require 'ms/scan'
+require 'ms/parser'
+require 'ms/msrun_index'
+require 'ms/converter/mzxml'
+
+#require 'ms/parser/mzxml'
+#require 'ms/parser/mzdata'
+
+module MS; end
+class MS::MSRun
+ 
+  attr_accessor :start_time, :end_time
+  attr_accessor :scans
+  # (just for reference) the type of file this is (as symbol)
+  attr_accessor :filetype
+  # (just for reference) the version string of this type of file
+  attr_accessor :version
+  # the total number of scans
+  attr_writer :scan_count
+
+  # should be able to read basic information from a variety of files
+  # this will be written in regexp's because REXML is way too slow, xmlparser
+  # is not guaranteed to be on every system, xmlib is not on win32.
+  # spectra is false, then spectra are not parsed out and included
+  # OPTIONS:
+  #   :spectra => *true|false   # whether to parse out spectra
+  # [note: precursor intensities not guaranteed to exist unless :spectra == true]
+  def initialize(file=nil, opts={})
+    myopts = opts.dup ; myopts[:msrun] = self
+    if file
+      filetype_and_version = MS::Parser.filetype_and_version(file)
+      MS::Parser.new(filetype_and_version, :msrun).parse(file, myopts)
+      (@filetype, @version) = filetype_and_version
+    end
+  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
+    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
+    ar
+  end
+
+  def scan_count(mslevel=0)
+    if mslevel == 0
+      @scan_count 
+    else
+      num = 0
+      scans.each do |sc|
+        if sc.ms_level == mslevel
+          num += 1
+        end
+      end
+      num
+    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 = sc.spectrum.mz
+          hi_mz = mz.last
+          lo_mz = mz.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 = sc.spectrum.mz
+          if mz.last > hi_mz
+            hi_mz = mz.last
+          end
+          if mz.last < lo_mz
+            lo_mz = mz.last
+          end
+        end
+      end
+    end
+    [lo_mz.floor, hi_mz.ceil]
+  end
+
+  # returns an array of precursor mz by scan number
+  # returns only the m/z of the FIRST precursor if multiple
+  def precursor_mz_by_scan_num
+    ar = Array.new(@scans.size + 1)
+    @scans.each do |scan|
+      if prec = scan.precursors.first
+        ar[scan.num] = prec.mz
+      else
+        ar[scan.num] = nil
+      end
+    end
+    ar
+  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
+
+  # same as the instance method (creates an object without spectrum and calls
+  # instance method of the same name)
+  def self.precursor_mz_by_scan_num(file)
+    self.new(file, :spectra => false).precursor_mz_by_scan_num
+  end
+
+  # only adds the parent if one is not already present!
+  def self.add_parent_scan(scans, add_intensities=false)
+    #start = Time.now
+    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
+        scan.precursors.each do |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
+      end
+      prev_level = level
+      prev_scan = scan
+    end
+    #puts "TOOK #{Time.now - start} secs"
+  end
+
+end
+
+
+

data/lib/{spec/msrun.rb → ms/msrun_index.rb}

@@ -1,11 +1,7 @@
+require 'ms/scan'
+require 'ms/parser'
 
-require 'spec/scan'
-require 'spec/mzxml/parser'
-require 'spec/mzdata/parser'
-
-module Spec; end
-
-class Spec::MSRunIndex
+class MS::MSRunIndex
   # basename_noext is the base name of the file (with NO extensions)
   attr_accessor :scans_by_num
   attr_reader :basename_noext
@@ -32,7 +28,7 @@ class Spec::MSRunIndex
   # index_file has one row for each scan:
   # ms_level scan_num time [prec_mz prec_inten]
   # also consider getting this data directly from the mzXML file
-  # via the Spec::MzXML::Parser.get_msrun_index command
+  # via the MS::MzXML::Parser.get_msrun_index command
   def set_from_index_file(index_file)
     self.basename_noext = index_file
     @scans_by_num = []
@@ -41,7 +37,7 @@ class Spec::MSRunIndex
         next if line !~ /\d/ || line =~ /^#/
         line.chomp!
         arr = line.split(" ")
-        scan = Spec::Scan.new(arr[1].to_i, arr[0].to_i, arr[2].to_f) 
+        scan = MS::Scan.new(arr[1].to_i, arr[0].to_i, arr[2].to_f) 
         if scan.ms_level > 1
           scan.prec_mz = arr[3].to_f
           scan.prec_inten = arr[4].to_f
@@ -49,7 +45,7 @@ class Spec::MSRunIndex
         @scans_by_num[scan.num] = scan
       end
     end
-    Spec::Scan.add_parent_scan(@scans_by_num)
+    MS::Scan.add_parent_scan(@scans_by_num)
   end
 
   # Takes a .mzXML file or .timeIndex file (currently)
@@ -73,7 +69,7 @@ class Spec::MSRunIndex
   # returns a new 
   def set_from_mzxml(file)
     self.basename_noext = file
-    @scans_by_num = Spec::MzXML::Parser.new.scans_by_num(file)
+    @scans_by_num = MS::Parser.new(file, :scans_by_num).parse(file)
   end
 
   # writes the index to filename
@@ -109,33 +105,4 @@ class Spec::MSRunIndex
 end
 
 
-class Spec::MSRun
-
-  # scan_count is an array [0] is all the scans, [1] is mslevel 1, [2] is mslevel 2, etc
-  attr_accessor :scan_count, :start_time, :end_time, :start_mz, :end_mz
-
-  # returns an array indexed by scan number where the precursor mz is recorded
-  # for each fragment (ms2) ion
-  # The precursor mz will be a String!
-  def self.precursor_mz_by_scan(file)
-    extname = File.extname(file)
-    case extname
-    when '.mzXML' || '.timeIndex'
-      klass = Spec::MzXML::Parser
-    when '.xml'
-      klass = Spec::MzData::Parser
-    when ''  # they want us to figure out the right extension
-      if File.exist? file + '.xml'
-        klass = Spec::MzData::Parser
-      else
-        # This will cover .timeIndex, .mzXML and .RAW
-        klass = Spec::MzXML::Parser
-      end
-    else
-      abort "files of extension #{extname} are not currently supported"
-    end
-    klass.new.precursor_mz_by_scan(file)
-  end
-
-end
 

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

@@ -0,0 +1,12 @@
+require 'ms/parser/mzdata/dom'
+
+class MS::Parser::MzData::AXML < MS::Parser::MzData::DOM
+  def get_root_node_from_file(file)
+    ::AXML.parse_file(file)
+  end
+end
+
+
+
+
+