bahuvrihi-xcalibur 0.0.1

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/lib/xcalibur/convert/dta_to_mgf.rb

@@ -0,0 +1,86 @@
+require 'constants'
+
+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

data/lib/xcalibur/convert/raw_to_dta.rb

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

data/lib/xcalibur/convert/raw_to_mgf.rb

@@ -0,0 +1,85 @@
+require 'xcalibur/convert/raw_to_dta'
+require 'xcalibur/convert/dta_to_mgf'
+
+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::Workflow
+      
+      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 
+        # Define the workflow entry and exit points,
+        # as well as the workflow logic.
+        
+        raw_to_dta = Xcalibur::Convert::RawToDta.new
+        dta_to_mgf = Xcalibur::Convert::DtaToMgf.new
+        
+        dta_dirs = []
+        n_inputs = nil
+        self.entry_point = Tap::Task.new do |task, *input_files|
+          n_inputs = input_files.length
+          input_files.each do |input_file|
+            dta_dir = File.basename(input_file).chomp(File.extname(input_file))
+            dta_dirs << dta_dir
+            raw_to_dta.enq(input_file, dta_dir)
+          end
+        end
+        
+        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.enq(output_file, *_result._expand)
+          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._expand }.flatten
+              dta_to_mgf.enq(merge_file, *all_results)
+            end
+            
+            if remove_dta_files
+              cleanup = Tap::Task.new do |task, raw_dir|           
+                task.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
+              dta_dirs.each {|dir| cleanup.enq(dir)}
+            end
+          end
+        end
+
+        self.exit_point = dta_to_mgf
+      end
+    end
+  end
+end

data/lib/xcalibur/peak_file.rb

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

data/lib/xcalibur/peakify.rb

@@ -0,0 +1,65 @@
+require 'xcalibur/peak_file'
+
+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(filepath)
+        target = app.filepath(:data, "peak_#{File.basename(filepath)}" )
+        prepare(target) 
+        
+        # now perform the task...
+        peak_file = PeakFile.parse File.read(filepath)
+        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

data/test/tap_test_suite.rb

@@ -0,0 +1,5 @@
+$:.unshift File.join(File.dirname(__FILE__), '../lib')
+
+# runs all subsets (see Tap::Test::SubsetMethods)
+ENV["ALL"] = "true"
+Dir.glob("./**/*_test.rb").each {|test| require test}

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification 
+name: bahuvrihi-xcalibur
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Simon Chiang
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-07-08 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: tap
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.10.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: constants
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.1.0
+    version: 
+description: 
+email: simon.a.chiang@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- MIT-LICENSE
+files: 
+- lib/xcalibur/convert/dta_to_mgf.rb
+- lib/xcalibur/convert/raw_to_dta.rb
+- lib/xcalibur/convert/raw_to_mgf.rb
+- lib/xcalibur/peak_file.rb
+- lib/xcalibur/peakify.rb
+- tap.yml
+- MIT-LICENSE
+has_rdoc: true
+homepage: http://hsc-proteomics.uchsc.edu/
+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: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: xcalibur task library
+test_files: 
+- test/tap_test_suite.rb