mspire 0.4.9 → 0.5.0

data/lib/gi.rb

@@ -1,124 +0,0 @@
-require 'open-uri'
-require 'rexml/document'
-require 'rexml/streamlistener'
-
-$ANNOTS = []
-
-class GIListener
-  include REXML
-  include StreamListener
-
-  attr_accessor :annotations
-
-  def initialize
-    @get_title = false
-    @annotations = []
-  end
-
-  def tag_start(name, attributes)
-    #puts "NAME" + name
-    #p attributes
-    if name == "Item" && attributes["Name"] == "Title"
-      @get_title = true 
-    end
-  end
-
-  def text(text)
-    #puts "TEXT: " + text + @get_title.to_s
-    if @get_title
-      #puts "GETTING TITLE!"
-      @annotations.push text.chomp
-      @get_title = false
-    end
-  end
-
-end
-
-
-
-class GI
-  BATCH_SIZE = 500
-  # takes an array of gi numbers and returns an array of annotation
-  # This allows use of the batch search mode on NCBI
-  # returns nil if no internet connection
-  def self.gi2annot(list_of_gi_numbers) 
-    annots = []
-    loop do
-      batch = list_of_gi_numbers.slice!(0..BATCH_SIZE)
-      if batch.size == 0 then break end
-      string = batch.join(",")
-      url = "http://eutils.ncbi.nlm.nih.gov/entrez/eutils/esummary.fcgi?db=protein&retmode=xml&id=#{string}"
-      #puts url
-      begin
-        open(url) do |handle|
-          if handle.is_a? StringIO 
-            io_input = handle
-          else
-            io_input = handle.read
-          end
-          annots.push( *(parse_etool_output(io_input)) )
-        end
-      rescue SocketError
-        return nil
-      end
-    end
-    annots
-  end
-
-  protected
-  # Returns a list of Annotation strings
-  def self.parse_etool_output(handle)
-    listener = GIListener.new
-    parser = REXML::Parsers::StreamParser.new(handle, listener)
-    parser.parse 
-    listener.annotations
-  end
-
-
-end
-
-
-
-=begin
-
-<?xml version="1.0" encoding="ISO-8859-1"?>
-<!DOCTYPE eSummaryResult PUBLIC "-//NLM//DTD eSummaryResult, 11 May 2002//EN" "http://www.ncbi.nlm.nih.gov/entrez/query/DTD/eSummary_041029.dtd">
-<eSummaryResult>
-
-<DocSum>
-<Id>24115498</Id>
-<Item Name="Caption" Type="String">NP_710008</Item>
-<Item Name="Title" Type="String">chaperonin GroEL [Shigella flexneri 2a str. 301]</Item>
-<Item Name="Extra" Type="String">gi|24115498|ref|NP_710008.1|[24115498]</Item>
-<Item Name="Gi" Type="Integer">24115498</Item>
-<Item Name="CreateDate" Type="String">2002/10/16</Item>
-
-<Item Name="UpdateDate" Type="String">2006/04/03</Item>
-<Item Name="Flags" Type="Integer">512</Item>
-<Item Name="TaxId" Type="Integer">198214</Item>
-<Item Name="Status" Type="String">live</Item>
-<Item Name="ReplacedBy" Type="String"></Item>
-<Item Name="Comment" Type="String"><![CDATA[  ]]></Item>
-</DocSum>
-
-
-<DocSum>
-<Id>434011</Id>
-<Item Name="Caption" Type="String">CAA24741</Item>
-
-<Item Name="Title" Type="String">unnamed protein product [Escherichia coli]</Item>
-<Item Name="Extra" Type="String">gi|434011|emb|CAA24741.1|[434011]</Item>
-<Item Name="Gi" Type="Integer">434011</Item>
-<Item Name="CreateDate" Type="String">1983/12/06</Item>
-<Item Name="UpdateDate" Type="String">2005/04/18</Item>
-<Item Name="Flags" Type="Integer">0</Item>
-<Item Name="TaxId" Type="Integer">562</Item>
-<Item Name="Status" Type="String">live</Item>
-<Item Name="ReplacedBy" Type="String"></Item>
-
-<Item Name="Comment" Type="String"><![CDATA[  ]]></Item>
-</DocSum>
-
-</eSummaryResult>
-
-=end

data/lib/group_by.rb

@@ -1,10 +0,0 @@
-
-#taken from rails, will be in Ruby 1.9
-module Enumerable
-  def group_by
-    inject({}) do |groups, element|
-      (groups[yield(element)] ||= []) << element
-      groups
-    end
-  end
-end

data/lib/index_by.rb

@@ -1,11 +0,0 @@
-
-# taken from rails (will be in Ruby 1.9??)
-
-module Enumerable
-  def index_by
-    inject({}) do |accum, elem|
-      accum[yield(elem)] = elem
-      accum
-    end
-  end
-end

data/lib/merge_deep.rb

@@ -1,21 +0,0 @@
-
-class Hash
-
-  # any hashes within the hash will also be merged to the level specifid
-  def merge_deep(hash2, level=1)
-    if level == 1
-      tmp_opts = {}
-      self.each do |k,v|
-        if (v.is_a?(Hash) and hash2[k].is_a?(Hash))
-          tmp_opts[k] = v.merge(hash2[k])
-        end
-      end
-      opts = self.merge(hash2)
-      opts.merge!(tmp_opts)
-      opts
-    else
-      raise NotImplementedError, "need to implement level > 1"
-    end
-  end
-end
-

data/lib/ms/converter/mzxml.rb

@@ -1,77 +0,0 @@
-
-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

@@ -1,170 +0,0 @@
-
-# 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

@@ -1,244 +0,0 @@
-
-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
-
-  MSRunDefaultOpts = { :lazy => :string }
- 
-  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
-
-
-  #### # [note: precursor intensities not guaranteed to exist unless :
-  # TODO: may need to eliminate unavailable precursor intensities if they
-  # doing lazy evaluation??  or it becomes lazy too??
-
-  # OPTIONS:
-  #   :lazy => :string | :not | :no_spectra | :io
-  #            :string = (default) stores each spectrum as a base64 decoded
-  #            string that is further processed into Arrays of Floats when m/z
-  #            or intensity information is access.  This lazy evaluation
-  #            should work on most files.
-  #            :not = all information is read into memory and parsed into
-  #            objects.  Should only be used for small-medium files (< 80MB on
-  #            a machine with 2GB memory)
-  #            :no_spectra = if no peak information is required use this to
-  #            avoid the overhead of parsing and creating spectra.
-  #            :io = stores the io object and indices into spectrum data.
-  #            When spectral information is requested (m/z or intensity
-  #            information) then the spectrum is read from the io object and
-  #            evaluated (requires an open io object when spectrum information
-  #            is requested)
-  def initialize(file_or_io=nil, opts={})
-    if opts[:lazy] == :io
-      if !file_or_io.is_a?(IO)
-        raise ArgumentError, "Caller must provide an IO object (rather than filename) if using {:lazy => :io}"
-      end
-    end
-    myopts = MSRunDefaultOpts.merge(opts)
-    myopts[:msrun] = self
-    if file_or_io
-      filetype_and_version = MS::Parser.filetype_and_version(file_or_io)
-      parser = MS::Parser.new(filetype_and_version, :msrun, myopts)
-      parser.parse(file_or_io, myopts)
-      #MS::Parser.new(filetype_and_version, :msrun).parse(file, myopts)
-      (@filetype, @version) = filetype_and_version
-    end
-  end
-
-  # This will automatically use :lazy => :io, open the file, and close it
-  # after the block returns.
-  #     MS::MSRun.open("file.mzXML") do |ms|
-  #       ms.scans.each {|scan| ... do something }
-  #     end
-  def self.open(filename, opts={})
-    File.open(filename) do |fh|
-      ms = MS::MSRun.new(fh, {:lazy => :io}.merge(opts))
-      yield(ms)
-    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_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 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.precursor
-        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, :lazy => :no_spectra, :fix_bad_tags => true).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
-        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
-    #puts "TOOK #{Time.now - start} secs"
-  end
-
-end
-
-
-