ms-xcalibur 0.1.0

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2006-2008, Regents of the University of Colorado.
+Developer:: Simon Chiang, Biomolecular Structure Program, Hansen Lab
+Support:: CU Denver School of Medicine Deans Academic Enrichment Fund
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this
+software and associated documentation files (the "Software"), to deal in the Software
+without restriction, including without limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
+to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,22 @@
+= {Ms-Xcalibur}[http://mspire.rubyforge.org/projects/ms-xcalibur]
+
+An {Mspire}[http://mspire.rubyforge.org] library supporting {Xcalibur}[http://www.thermo.com/com/cda/product/detail/1,,1000001009250,00.html].
+
+== Description
+
+* Lighthouse[http://bahuvrihi.lighthouseapp.com/projects/16692-mspire/tickets]
+* Github[http://github.com/bahuvrihi/ms-xcalibur/tree/master]
+* {Google Group}[http://groups.google.com/group/mspire-forum]
+
+== Installation
+
+Ms-Xcalibur is available as a gem on RubyForge[http://rubyforge.org/projects/mspire].  Use:
+
+  % gem install ms-xcalibur
+
+== Info 
+
+Copyright (c) 2006-2008, Regents of the University of Colorado.
+Developer:: {Simon Chiang}[http://bahuvrihi.wordpress.com], {Biomolecular Structure Program}[http://biomol.uchsc.edu/], {Hansen Lab}[http://hsc-proteomics.uchsc.edu/hansenlab/] 
+Support:: CU Denver School of Medicine Deans Academic Enrichment Fund
+Licence:: {MIT-Style}[link:files/MIT-LICENSE.html]

data/lib/ms/xcalibur/convert/dta_to_mgf.rb

@@ -0,0 +1,88 @@
+require 'constants'
+
+module Ms
+  module Xcalibur
+    module Convert
+      # :startdoc::manifest convert dta files to mgf format
+      # Converts a set of .dta files (Sequest format) into an .mgf (Mascot format) 
+      # file.  The conversion is straightforward.  
+      #
+      # dta format:
+      #   [input_file.dta]
+      #   353.128 1 
+      #   85.354 2.2
+      #   87.302 2.8
+      #   ...
+      #
+      # mgf format:
+      #   [output_file.mgf]
+      #   BEGIN IONS
+      #   TITLE=input_file
+      #   CHARGE=1
+      #   PEPMASS=<calculated>
+      #   85.354 2.2
+      #   87.302 2.8
+      #   ...
+      #   END IONS
+      #
+      # The first line of the dta file specifies the M+H (mh) and charge state (z) of 
+      # the  precursor ion.  To convert this to PEPMASS, use (mh + (z-1) * H)/ z) where
+      # H is the mass of a proton, ie hydrogen - electron.  The mass of a proton is
+      # calculated from the {constants}[bioactive.rubyforge.org/constants] gem to be 
+      # ~ 1.007276 Da
+      #
+      class DtaToMgf < Tap::FileTask
+        include Constants::Libraries
+
+        # Returns the unrounded mass of a proton (H - e) as calculated
+        # from the {constants}[bioactive.rubyforge.org/constants] gem.
+        config :proton_mass, Element['H'].mass - Particle['Electron'].mass, &c.num_or_nil        # allows specification of an alternate proton mass
+
+        def process(output_file, *inputs)
+          return output_file if inputs.empty?
+
+          dta_files = inputs.collect do |file| 
+            if File.directory?(file)
+              Dir.glob(File.expand_path(File.join(file, "*.dta")))
+            else
+              raise "Not a .dta file: #{file}" unless file =~ /\.(dta)$/
+              file
+            end
+          end
+
+          prepare(output_file) 
+          File.open(output_file, "wb") do |target|
+            h = proton_mass
+
+            dta_files.flatten.each do |file|
+              #log_basename(:merging, file)
+              lines = File.read(file).split(/\r?\n/)
+
+              # get the mh and z
+              mh, z = lines.shift.split(/\s+/)
+              mh = mh.to_f
+              z = z.to_i
+
+              # add a trailing empty line
+              lines << ""
+
+              # make the output
+              target << %Q{BEGIN IONS
+TITLE=#{File.basename(file)}
+CHARGE=#{z}+
+PEPMASS=#{(mh + (z-1) * h)/ z}
+#{lines.join("\n")}
+END IONS
+
+}
+            end
+          end
+          log(:made, output_file)
+
+          output_file
+        end
+      end
+      
+    end
+  end
+end

data/lib/ms/xcalibur/convert/raw_to_dta.rb

@@ -0,0 +1,143 @@
+module Ms
+  module Xcalibur
+    module Convert
+      # :startdoc::manifest convert RAW files to dta format
+      # Converts a .RAW file to dta files using extract_msn.exe 
+      #
+      # extract_msn.exe is an Xcalibur/BioWorks tool that extracts spectra from .RAW
+      # files into .dta (Sequest) format and must be installed for RawToDta to work.
+      # RawToDta was developed against extract_msn version 4.0.  You can check if
+      # extract_msn is installed at the default location, as well as determine the  
+      # version of your executable using:
+      #
+      #   % tap run -- xcalibur/convert/raw_to_dta  --extract_msn_help
+      #
+      class RawToDta < Tap::FileTask
+        config :extract_msn, 'C:\Xcalibur\System\Programs\extract_msn.exe' # the full path to the extract_msn executable
+        config :first_scan, nil, &c.integer_or_nil              # (-F)
+        config :last_scan, nil, &c.integer_or_nil               # (-L)
+        config :lower_MW, nil, &c.num_or_nil                    # (-B)
+        config :upper_MW, nil, &c.num_or_nil                    # (-T)
+        config :precursor_mass_tol, 1.4, &c.num                 # (-M)
+        config :num_allowed_intermediate_scans_for_grouping, 1, &c.integer # (-S)
+        config :charge_state, nil, &c.integer_or_nil            # (-C)
+        config :num_required_group_scans, 1, &c.integer_or_nil  # (-G)
+        config :num_ions_required, 0, &c.integer_or_nil         # (-I)
+        config :intensity_threshold, nil, &c.integer_or_nil     # (-E)
+        config :use_unified_search_file, nil, &c.flag           # (-U)
+        config :subsequence, nil                                # (-Y)
+        config :write_zta_files, nil, &c.flag                   # (-Z)
+        config :perform_charge_calculations, nil, &c.flag       # (-K)
+        config :template_file, nil                              # (-O)
+        config :options_string, nil                             # (-A)
+        config :minimum_signal_to_noise, 3, &c.num              # (-R)
+        config :minimum_number_of_peaks, 5, &c.integer          # (-r)
+
+        config_attr(:extract_msn_help, nil, :arg_type => :flag) do |value|  # Print the extract_msn help         
+          if value
+            sh(extract_msn)
+            exit
+          end
+        end
+
+        CONFIG_MAP = [
+          [:first_scan, 'F'],
+          [:last_scan, 'L'],
+          [:lower_MW, 'B'],
+          [:upper_MW, 'T'],
+          [:precursor_mass_tol, 'M'],
+          [:num_allowed_intermediate_scans_for_grouping, 'S'],
+          [:charge_state, 'C'],
+          [:num_required_group_scans, 'G'],
+          [:num_ions_required, 'I'],
+          [:output_path, 'D'],
+          [:intensity_threshold, 'E'],
+          [:use_unified_search_file, 'U'],
+          [:subsequence, 'Y'],
+          [:write_zta_files, 'Z'],
+          [:perform_charge_calculations, 'K'],
+          [:template_file, 'O'],
+          [:options_string, 'A'],
+          [:minimum_signal_to_noise, 'R'],
+          [:minimum_number_of_peaks, 'r']
+        ]
+
+        # Expands the input path and converts all forward slashes (/) 
+        # to backslashes (\) to make it into a Windows-style path.
+        def normalize(path)
+          File.expand_path(path).gsub(/\//, "\\")
+        end
+
+        # Formats command options for extract_msn.exe using the current configuration.
+        # Configurations are mapped to their single-letter keys using CONFIG_MAP.
+        #
+        # A default output_dir can be specified for when config[:output_path] is not 
+        # specified.
+        def cmd_options(output_dir=nil)
+          options = CONFIG_MAP.collect do |key, flag|
+            value = (flag == "D" ? output_dir : config[key])
+            next unless value
+
+            # formatting consists of stringifying the value argument, or
+            # in escaping the value if the arguement is a path
+            formatted_value = case key
+            when :use_unified_search_file, :perform_charge_calculations, :write_zta_files
+              "" # no argument
+            when :output_path, :template_file 
+              # path argument, escape
+              "\"#{normalize value}\""  
+            else 
+              # number or string, simply stringify
+              value.to_s
+            end
+
+            "-#{flag}#{formatted_value}"
+          end
+
+          options.compact.join(" ")
+        end
+
+        # Formats the extract_msn.exe command using the specified input_file,
+        # and the current configuration.  A default output directory can be 
+        # specified using output_dir; it will not override a configured output
+        # directory.
+        #
+        # Note that output_dir should be an EXISTING filepath or relative 
+        # filepath.   execute_msn.exe will not generate .dta files if the  
+        # output_dir doesn't exist.
+        def cmd(input_file, output_dir=nil)
+          args = []
+          args << "\"#{normalize extract_msn}\""
+          args << cmd_options(output_dir)
+          args << "\"#{normalize input_file}\""
+
+          args.join(' ')
+        end
+
+        def process(input_file, output_dir=nil)
+          extname = File.extname(input_file)
+          raise "Expected .RAW file: #{input_file}" unless  extname =~ /\.RAW$/i
+
+          # Target the output to a directory with the same basename 
+          # as the raw file, unless otherwise specified.
+          output_dir = input_file.chomp(File.extname(input_file)) if output_dir == nil
+
+          mkdir(output_dir)
+          command = cmd(input_file, output_dir)
+
+          log :sh, command
+          if app.quiet
+            capture_sh(command, true)
+          else
+            sh(command)
+            puts ""  # add extra line to make logging nice
+          end
+
+          # This may select additional .dta files that existed before raw_to_dta
+          # TODO - maybe read lcq_dta for files? 
+          Dir.glob( File.expand_path(File.join(output_dir, "*.dta")) ) 
+        end
+      end
+    end
+  end
+end

data/lib/ms/xcalibur/convert/raw_to_mgf.rb

@@ -0,0 +1,86 @@
+require 'ms/xcalibur/convert/raw_to_dta'
+require 'ms/xcalibur/convert/dta_to_mgf'
+
+module Ms
+  module Xcalibur
+    module Convert
+      # :startdoc::manifest convert RAW files to mgf format
+      # Extracts spectra from a .RAW file and formats them as mgf (Mascot
+      # Generic Format).  RawToMgf is a workflow that uses the RawToDta
+      # and DtaToMgf tasks, and can be configured through these tasks
+      # using the following configuration files:
+      #
+      #   config/xcalibur/convert
+      #   |- raw_to_mgf.yml               # configures RawToMgf
+      #   `- raw_to_mgf
+      #    |- raw_to_dta.yml              # configures RawToDta
+      #    `- dta_to_mgf.yml              # configures DtaToMgf
+      #
+      # Mgf files are named after the RAW file they represent; the group
+      # merge file is named 'merge.mgf' although an alternate merge file
+      # name can be specified in the options.
+      #
+      class RawToMgf < Tap::Task
+        
+        define :raw_to_dta, Xcalibur::Convert::RawToDta
+        define :dta_to_mgf, Xcalibur::Convert::DtaToMgf
+        define :cleanup  do |raw_dir|           
+          log :rm, raw_dir
+
+          # take this stepwise to be a little safer...
+          FileUtils.rm Dir.glob(raw_dir + "/*.dta")
+          FileUtils.rm ["#{raw_dir }/lcq_dta.txt", "#{raw_dir }/lcq_profile.txt"]
+          FileUtils.rmdir raw_dir
+        end
+                
+        config :merge_file, 'merge.mgf'            # the group merge file
+        config :merge_individual, true, &c.switch  # merge the dta's for each RAW file
+        config :merge_group, true, &c.switch       # merge the dta's for all RAW files
+        config :remove_dta_files, true, &c.switch  # clean up dta files upon completion
+        
+        def workflow
+          group_results = []
+          raw_to_dta.on_complete do |_result|
+            if merge_individual
+              input_file = _result._original[0]
+              output_file = File.join( File.dirname(merge_file), File.basename(input_file).chomp(File.extname(input_file)) + ".mgf")
+              dta_to_mgf.execute(output_file, *_result._iterate)
+            end
+
+            # collect _results to determine when all the input
+            # files have been processed by raw_to_dta
+            group_results << _result
+
+            # When all the input files have been converted, merge the
+            # group and enque a task to cleanup the dta files, as specified.
+            if group_results.length == @n_inputs
+              if merge_group
+                all_results = group_results.collect {|_result| _result._iterate }.flatten
+                dta_to_mgf.execute(merge_file, *all_results)
+              end
+            end
+          end
+        end
+        
+        def process(*input_files)
+          @n_inputs = input_files.length
+          
+          dta_dirs = []
+          input_files.each do |input_file|
+            dta_dir = File.basename(input_file).chomp(File.extname(input_file))
+            dta_dirs << dta_dir
+            raw_to_dta.execute(input_file, dta_dir)
+          end
+          
+          if remove_dta_files
+            dta_dirs.each {|dir| cleanup.process(dir) }
+          end
+              
+          @n_inputs = nil
+          nil
+        end
+        
+      end
+    end
+  end
+end

data/lib/ms/xcalibur/peak_file.rb

@@ -0,0 +1,92 @@
+module Ms
+  module Xcalibur
+    # A simple representation of a peak file exported from Xcalibur Qual 
+    # Browser (v 2.0).  The expected format of a peak file is as shown below:
+    #
+    #  [peak_file.txt]
+    #   SPECTRUM - MS
+    #   GSE_T29K_080703143635.raw
+    #   ITMS + c ESI Full ms [300.00-2000.00]
+    #   Scan #: 11
+    #   RT: 0.07
+    #   Data points: 1490
+    #   Mass	Intensity
+    #   300.516479	2000.0
+    #   301.392487	1000.0
+    #   302.465759	3000.0
+    #   ...
+    #
+    # Any headers matching the pattern 'key: value' will be parsed as a 
+    # header, while other lines (ex: SPECTRUM - MS) are parsed into the
+    # description.
+    #
+    class PeakFile
+
+      class << self
+
+        # Parses the input string into a PeakFile
+        def parse(str)
+          peak_file = PeakFile.new
+          mode = :header
+          str.each_line do |line|
+            case mode
+            when :header
+
+              case line
+              when /^(.*?): (.*)$/
+                peak_file.headers[$1] = $2.strip
+              when /Mass\sIntensity/
+                mode = :data
+              else
+                peak_file.desc << line.strip
+              end
+
+            when :data
+              peak_file.data << line.split(/\s/).collect {|mz| mz.to_f }
+            end
+          end
+
+          peak_file
+        end
+      end
+
+      # The order of headers observed in export files
+      HEADER_ORDER = [
+        "Scan #",
+        "RT",
+        "Mass defect",
+        "Data points"
+      ]
+
+      # An array of description lines
+      attr_accessor :desc
+
+      # A hash of headers
+      attr_accessor :headers
+
+      # An array of (mz, intensity) values
+      attr_accessor :data
+
+      def initialize(desc=[], headers={}, data=[])
+        @desc = desc
+        @headers = headers
+        @data = data
+      end
+
+      # Recreates the peak file
+      def to_s(sep="\r\n")
+        lines = desc + 
+        HEADER_ORDER.collect do |key|
+          next nil unless headers.has_key?(key)
+          "#{key}: #{headers[key]}"
+        end.compact +
+        ["Mass\tIntensity"] +
+        data.collect do |point|
+          point.join("\t")
+        end
+
+        lines.join(sep) + sep
+      end
+    end
+  end
+end

data/lib/ms/xcalibur/peakify.rb

@@ -0,0 +1,65 @@
+require 'ms/xcalibur/peak_file'
+
+module Ms
+  module Xcalibur
+    # :startdoc::manifest adds graph data to an exported peak file
+    # Peakify adds points to signify the relative intensity 
+    # (ie the rounded intensity/max_intensity) of peaks in 
+    # an exported peak list.  This can be useful as a visual aid. 
+    #
+    #   [a_sample_result.txt]
+    #   SPECTRUM - MS
+    #   GSE_T29K_080703143635.raw
+    #   ITMS + c ESI Full ms [300.00-2000.00]
+    #   Scan #: 11
+    #   RT: 0.07
+    #   Data points: 1490
+    #   Mass	Intensity
+    #   300.516479	2000.0	.................................
+    #   301.392487	1000.0	.................
+    #   302.465759	3000.0	..................................................
+    #   ...
+    #
+    # Options can be specified to filter out points within a
+    # range of relative intensities.  Peakify can handle exported 
+    # peak lists from Xcalibur Qual  Browser (v 2.0).
+    #
+    class Peakify < Tap::FileTask
+
+      config :point_char, '.'           # a character used for each intensity point
+      config :min, 0, &c.num            # min relative intenisty
+      config :max, 100, &c.num          # max relative intenisty
+      config :sort, false, &c.flag      # sort by intensity
+
+      def process(source, target=basepath(source, 'peaks.txt'))
+        prepare(target)
+
+        # now perform the task...
+        peak_file = PeakFile.parse File.read(source)
+        max_intensity = peak_file.data.inject(0) do |max, (mz, intensity)|
+          intensity > max ? intensity : max
+        end
+
+        range = min..max
+        peak_file.data = peak_file.data.collect do |(mz, intensity)|
+          percent = (intensity / max_intensity * 100)
+          next unless range.include?(percent)
+
+          [mz, intensity, point_char * percent.round]
+        end.compact
+
+        if sort
+          peak_file.data = peak_file.data.sort_by do |(mz, intensity)|
+            intensity
+          end.reverse
+        end
+
+        File.open(target, "wb") do |file|
+          file << peak_file.to_s
+        end
+
+        target
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: ms-xcalibur
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Simon Chiang
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-12-03 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: tap
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0.11"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: constants
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0.1"
+    version: 
+description: 
+email: simon.a.chiang@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- MIT-LICENSE
+files: 
+- lib/ms/xcalibur/convert/dta_to_mgf.rb
+- lib/ms/xcalibur/convert/raw_to_dta.rb
+- lib/ms/xcalibur/convert/raw_to_mgf.rb
+- lib/ms/xcalibur/peak_file.rb
+- lib/ms/xcalibur/peakify.rb
+- tap.yml
+- README
+- MIT-LICENSE
+has_rdoc: true
+homepage: http://mspire.rubyforge.org/projects/ms-xcalibur/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: mspire
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: An Mspire library supporting Xcalibur.
+test_files: []
+