mspire 0.4.9 → 0.5.0

data/bin/raw_to_mzXML.rb

@@ -1,55 +0,0 @@
-#!/usr/bin/ruby -w
-
-require 'optparse'
-require 'ms/converter/mzxml'
-require 'fileutils'
-
-progname = File.basename(__FILE__)
-
-
-opt = {}
-opts = OptionParser.new do |op|
-  op.banner = "usage: #{progname} [OPTIONS] <file>.RAW ..."
-  op.separator ""
-  op.on("-p", "--profile", "uses profile output instead of centroid (default)") {|v| opt[:profile] = v}
-end
-
-opts.parse!
-
-if ARGV.size == 0
-  puts opts
-  exit
-end
-
-converter = MS::Converter::MzXML.find_mzxml_converter
-if converter
-  $stderr.puts "using #{converter} to convert files"
-else
-  puts "cannot find [#{MS::Converter::MzXML::Potential_mzxml_converters.join(', ')}] in the paths:"
-  puts ENV['PATH'].split(/[:;]/).join(", ")
-  abort
-end
-
-files = ARGV.to_a
-files.each do |file|
-  puts "******************************************"
-  puts "Converting: #{file}"
-  if converter =~ /readw/
-    centroid_or_profile = 'c'
-    if opt[:profile] 
-      centroid_or_profile = 'p'
-    end
-    outfile = file.sub(/\.RAW$/i, '.mzXML') 
-    cmd = "#{converter} #{file} #{centroid_or_profile} #{outfile}"
-    puts "Performing: '#{cmd}'"
-    puts `#{cmd}`
-  else
-    ## t2x only outputs in cwd!
-    Dir.chdir(File.dirname(file)) do |dir|
-      puts "Performing: '#{cmd}' in #{dir}"
-      puts `#{cmd}`
-      system "#{converter} #{File.basename(file)}"
-    end
-  end
-  puts "******************************************"
-end

data/bin/run_percolator.rb

@@ -1,122 +0,0 @@
-#!/usr/bin/ruby
-
-perc_cmd = 'percolator'
-
-require 'optparse'
-require 'spec_id/srf'
-
-# percolator_v1.02_32bit_linux -o reverse_meta.sqm normal_NOCYS/meta.sqm reverse_NOCYS/meta.sqm
-# percolator_v1.02_32bit_linux -o reverse_cat_meta.sqm -P INV_ reverse_cat_NOCYS/meta.sqm &
-
-file_hash = { 
-  :srg => "bioworks.srg",
-  :sqg_in => "bioworks.sqg",
-  :sqg_decoy => "decoy.sqg",
-  :perc_out => "perc.sqg",
-  :perc_stdout => "perc.stdout",
-  :perc_stderr => "perc.stderr",
-  :perc_ext => ".psqt",
-}
-(default_srg, sqg_in, perc_out, sqg_decoy, perc_stdout, perc_stderr, perc_ext) = file_hash.values_at(:srg, :sqg_in, :perc_out, :sqg_decoy, :perc_stdout, :perc_stderr, :perc_ext)
-
-opt = {}
-toclean = []
-opts = OptionParser.new do |op|
-  op.banner =  "usage: #{File.basename(__FILE__)} -d PATTERN <file>.srf ..."
-  op.separator "       #{File.basename(__FILE__)} -d PATTERN <file>.srg"
-  op.separator "       #{File.basename(__FILE__)} <normal>.srg <decoy>.srg"
-  op.separator ""
-  op.separator "  creates necessary meta files in current working directory and"
-  op.separator "  runs command '#{perc_cmd}'"
-  op.separator ""
-  op.separator "  (all in current working directory)"
-  op.separator "  1) (if given .srf files) creates file: #{default_srg}"
-  op.separator "  2) creates .sqt file for each srf file (placed in dir with srf file)"
-  op.separator "  3) creates percolator (meta) input file(s): #{sqg_in}"
-  op.separator "                  [and for separate searches: #{sqg_decoy}]"
-  op.separator "  4) creates a percolator (meta) output file: #{perc_out}"
-  op.separator "  5) runs percolator which creates a  a #{perc_ext} for each .srf file"
-  op.separator "  6) captures stdout in #{perc_stdout} and stderr in #{perc_stderr}"
-  op.separator ""
-  op.separator "  .srg files are text files with full paths to .srf files"
-  op.separator "  create with command 'srf_group.rb'"
-  op.separator ""
-  op.on("-d", "--decoy <pattern>", "decoy pattern, eg.: -d REVERSE_") {|v| opt[:decoy] = v }
-  op.on("-c", "--clean", "removes ALL generated files except #{perc_ext}") {|v| opt[:clean] = v }
-  op.on("-v", "--verbose", "spits out info") {|v| $VERBOSE = v }
-end
-opts.parse!
-
-if ARGV.size == 0 or (!opt[:decoy] && (ARGV.size != 2))
-  puts opts.to_s
-  exit
-end
-
-#raise RunTimeError, "command #{perc_cmd} must be callable!" unless `#{perc_cmd}`.match(/Usage/)
-
-files = ARGV.to_a
-
-# create srg file:
-srg_files = 
-  if files[0] =~ /\.srf$/i
-    obj = SRFGroup.new
-    obj.filenames = files.to_a
-    puts("CREATING: #{default_srg}") if $VERBOSE
-    obj.to_srg(default_srg)
-    toclean << default_srg
-    [default_srg]
-  elsif files[0] =~ /\.srg$/i
-    files
-  else
-    abort "files must have proper extensions"
-  end
-
-# create the sqt files:
-all_sqt_filenames = srg_files.map do |srg_file|
-  srf_filenames = SRFGroup.srg_to_paths(srg_file)
-  srf_filenames.map do |file|
-    new_filename = file.sub(/\.srf$/i, '.sqt')
-    puts("CREATING: #{new_filename}") if $VERBOSE
-    SRFGroup.new([file], opt['filter']).srfs.first.to_sqt(new_filename)
-    toclean << new_filename
-    new_filename
-  end
-end
-
-# create the percolator input file:
-all_sqt_filenames.zip(file_hash.values_at(:sqg_in, :sqg_decoy)) do |sqt_filenames,filename|
-  puts("CREATING: #{filename}") if $VERBOSE
-  File.open(filename, 'w') {|fh| fh.puts(sqt_filenames.join("\n")) }
-  toclean << filename 
-end
-
-# create the percolator output file:
-psqt_filenames = all_sqt_filenames[0].map do |file|
-  file.sub(/\.sqt$/, perc_ext)
-end
-
-puts("CREATING: #{perc_out}") if $VERBOSE
-File.open(perc_out, 'w') {|fh| fh.puts(psqt_filenames.join("\n")) }
-toclean << perc_out
-
-# run percolator
-to_run = 
-  if opt[:decoy]
-  "#{perc_cmd} -o #{perc_out} -P #{opt[:decoy]} #{sqg_in} 1>#{perc_stdout} 2>#{perc_stderr}"
-  else
-  "#{perc_cmd} -o #{perc_out} #{sqg_in} #{sqg_decoy} 1>#{perc_stdout} 2>#{perc_stderr}"
-  end
-
-puts("RUNNING: #{to_run}") if $VERBOSE
-`#{to_run}`
-
-toclean << perc_stdout
-toclean << perc_stderr
-
-if opt[:clean]
-  toclean.each do |file|
-    puts("REMOVING: #{file}") if $VERBOSE
-    File.unlink(file) if File.exist?(file)
-  end
-end
-

data/bin/sqt_group.rb

@@ -1,26 +0,0 @@
-#!/usr/bin/ruby
-
-require 'optparse'
-require 'spec_id/sqt'
-
-$OUTFILE = 'bioworks.sqg'
-
-opts = OptionParser.new do |op|
-  op.banner = "usage: #{File.basename(__FILE__)} <file1>.sqt <file2>.sqt ..."
-  op.separator "outputs: 'bioworks.sqg'"
-  op.separator ""
-  op.separator "    A '.sqg' file is an ascii text file with a list"
-  op.separator "    of the sqt files (full path names) in that group."
-  op.separator ""
-  op.on('-o', '--output <filename>', 'a different output name') {|v| $OUTFILE }
-end
-
-if ARGV.size == 0
-  puts opts
-  exit
-end
-
-obj = SQTGroup.new
-obj.filenames = ARGV.to_a
-obj.to_sqg($OUTFILE)
-

data/bin/srf_group.rb

@@ -1,27 +0,0 @@
-#!/usr/bin/ruby
-
-
-require 'optparse'
-require 'spec_id/srf'
-
-$OUTFILE = 'bioworks.srg'
-
-opts = OptionParser.new do |op|
-  op.banner = "usage: #{File.basename(__FILE__)} <file1>.srf <file2>.srf ..."
-  op.separator "outputs: 'bioworks.srg'"
-  op.separator ""
-  op.separator "    A '.srg' file is an ascii text file with a list"
-  op.separator "    of the srf files (full path names) in that group."
-  op.separator ""
-  op.on('-o', '--output <filename>', 'a different output name') {|v| $OUTFILE }
-end
-
-if ARGV.size == 0
-  puts opts
-  exit
-end
-
-obj = SRFGroup.new
-obj.filenames = ARGV.to_a
-obj.to_srg($OUTFILE)
-

data/bin/srf_to_sqt.rb

@@ -1,40 +0,0 @@
-#!/usr/bin/ruby
-
-require 'spec_id/srf'
-require 'optparse'
-
-
-opt = {}
-opt['db-info'] = false
-opt['db-path'] = nil
-opt['filter'] = true
-opts = OptionParser.new do |op|
-  op.banner = "usage: #{File.basename(__FILE__)} [OPTIONS] <file>.srf ..."
-  op.separator "outputs: <file>.sqt ..."
-  op.separator ""
-  op.separator "OPTIONS"
-  op.on("-d", "--db-info", "calculates num aa's and md5sum on db") {|v| opt['db-info'] = v }
-  op.on("-p", "--db-path <path_to_dir>", "if your database path has changed",
-                                         "and you want db-info, then give the",
-                                         "path to the new *directory*",
-                                         "e.g. /my/new/path") {|v| opt['db-path'] = v }
-  op.on("-u", "--db-update", "update the sqt file to reflect --db-path") {|v| opt['db-update'] = v }
-  op.on("-n", "--no-filter", "by default, pephit must be within",
-                             "peptide_mass_tolerance (defined in params)",
-                             "to be displayed.  Turns this off.") {|v| opt['filter'] = false}
-  op.on("-r", "--round", "round floating point values reasonably") {|v| opt['round'] = v }
-end
-
-opts.parse!
-
-if ARGV.size == 0
-  puts opts.to_s 
-  exit
-end
-
-ARGV.each do |file|
-  abort "file #{file} must be named .srf" if file !~ /\.srf$/i
-  new_filename = file.sub(/\.srf$/i, '.sqt')
-  SRFGroup.new([file], opt['filter']).srfs.first.to_sqt(new_filename, :db_info => opt['db-info'], :new_db_path => opt['db-path'], :update_db_path => opt['db-update'], :round => opt['round'])
-end
-

data/lib/align/chams.rb

@@ -1,78 +0,0 @@
-
-require 'ms/msrun'
-
-module Align; end
-class Align::CHAMS
-
-  # Avg_score	0.52559
-  # Scan1	Scan2	Edge_cost	Path_cost	Edge_direction
-  attr_accessor :avg_score, :time_mscans, :time_nscans, :mscans, :nscans, :edge_costs, :path_costs, :directions
-  
-  # requires an object that will respond to [<scan_num>] to give time
-  # (seconds) for each file
-  def initialize(chams_file, time_by_scan_num1, time_by_scan_num2)
-    @time_mscans = []
-    @time_nscans = []
-    @mscans = []
-    @nscans = []
-    @edge_costs = []
-    @path_costs = []
-    @directions = []
-    read_chams_file(chams_file)
-    @mscans.each_with_index do |scan,i|
-      @time_mscans[i] = time_by_scan_num1[scan]
-    end
-    @nscans.each_with_index do |scan,i|
-      @time_nscans[i] = time_by_scan_num2[scan]
-    end
-  end
-
-  def read_chams_file(chams_file)
-    File.open(chams_file).each do |line|
-      if line =~ /[\d\w]/
-        if line =~ /^# Avg_score ([\.\d])/
-          @avg_score = $1.to_f
-          next
-        end
-      end
-      if line =~ /^#/
-        next
-      end
-      arr = line.chomp.split(/\s+/)
-      @mscans.push arr[0].to_i
-      @nscans.push arr[1].to_i
-      @edge_costs.push arr[2].to_f
-      @path_costs.push arr[3].to_f
-      @directions.push arr[4].to_f
-    end
-    @mscans.reverse!
-    @nscans.reverse!
-    @edge_costs.reverse!
-    @path_costs.reverse!
-    @directions.reverse!
-  end
-
-  def write_my_chams_file(filename)
-    File.open(filename, "w") do |fh|
-      ## As columns:
-      #(0...@mscans.size).each do |i|
-      #  fh.print @time_mscans[i].to_s + " " 
-      #  fh.print @time_nscans[i].to_s + " " 
-      #  fh.print @mscans[i].to_s + " " 
-      #  fh.print @nscans[i].to_s + " " 
-      #  fh.print @edge_costs[i].to_s + "\n" 
-      #end
-
-      # As rows:
-      fh.print @time_mscans.join(" ") + "\n" 
-      fh.print @time_nscans.join(" ") + "\n" 
-      fh.print @mscans.join(" ") + "\n" 
-      fh.print @nscans.join(" ") + "\n" 
-      fh.print @edge_costs.join(" ") + "\n" 
-    end
-  end
-
-end
-
-
-

data/lib/align.rb

@@ -1,154 +0,0 @@
-
-#require 'ms/parser'
-#require 'ms/parser/mzxml'
-require 'ms/msrun'
-require 'spec_id/proph'
-require 'vec'
-
-require 'pp'
-
-class Align
-
-  # Returns an array of peptides where each peptide passes threshold criteria
-  # and each has been updated with scans, and dta filenames dependent on
-  # matching with the basename_noext of the mztimes files.
-  # Each peptide is guaranteed unique by sequence+charge
-  # mztimes is an array of mzXML or .timeIndex files
-  # if a peptide has no scans in the given mztimes set, it is discarded
-  def peps_with_scans(mztimes, prot_xml, pep_proph_xml, prot_prob=1.0, pep_init_prob=1.0, pep_nsp_prob=1.0)
-
-    ## Create scan indices on msrun name
-    if mztimes.class != Array ; mztimes = [mztimes] end
-    msrun_indices = mztimes.collect do |file| MS::MSRunIndex.new(file) end
-    scanindex_by_basename_noext = {}
-    msrun_indices.each do |runindex|
-      scanindex_by_basename_noext[runindex.basename_noext] = runindex.scans_by_num
-    end
-
-    dta_filenames = Proph::Pep::Parser.new.dta_filenames_by_seq_charge(pep_proph_xml, "regex")
-
-    parser = Proph::Prot::Parser.new
-    parser.get_prots_and_peps(prot_xml, prot_prob, pep_init_prob, pep_nsp_prob, "regex")
-    peptides = parser.peps
-    peptides = Proph::Pep.uniq_by_seqcharge(peptides)
-    ## we update each peptide with a list of dtafilenames
-    ## then we update with a parallel list of scans (one for each dtafn...
-    ## unless there are multiple scans associated with each filename
-    ## in which case it will be an array
-    _update_filenames(peptides, dta_filenames)
-    peptides = _update_and_filter_by_scans(peptides, scanindex_by_basename_noext)
-    return peptides
-  end
-
-  # takes the list of filenames for each peptide, and adds a scan
-  # indexed from by scanindex
-  # If keys are not in scanindex_by_basename_noext, then the scan is not
-  # in the peptide!
-  # if a peptide has no scans, it is not returned
-  # if a filename is not recognized, it is dropped from the list
-  def _update_and_filter_by_scans(peptides, scanindex_by_basename_noext)
-    newpeps = []
-    peptides.each do |pep|
-      newfilenames = []
-      pep.filenames.each do |dtafilename|
-        (dtabase,first,last,charge) = dtafilename.split('.')
-        if scanindex_by_basename_noext.key?(dtabase)
-          newfilenames << dtafilename
-          if first == last
-            pep.scans << scanindex_by_basename_noext[dtabase][first.to_i]
-          else
-            scans = (first.to_i...last.to_i).collect do |index|
-              scanindex_by_basename_noext[dtabase].scans_by_num[index]
-            end
-            pep.scans << scans
-          end
-        else
-        end
-      end
-      pep.filenames = newfilenames
-      if pep.scans.size > 0
-        newpeps << pep
-      end
-    end
-    newpeps
-  end
-
-  # takes an array of peptide arrays
-  # will find the overlapping set
-  # returns an array of peptide arrays
-  # assumes that each pep_group is unique on sequence+charge
-  def overlapping_peps_by_seqcharge(pep_groups)
-    ## CREATE overlapping set:
-    hashes = pep_groups.collect do |group|
-      group.hash_uniq_by(:sequence, :charge)
-    end
-    pep_keys = hashes.collect do |hash|
-      hash.collect do |k,v| k end
-    end
-    olapping_keys = pep_keys.inject do |olap,obj|
-      olap & obj
-    end
-    pep_arrays = hashes.collect do |hash|
-      pep_array = olapping_keys.collect do |k|
-        hash[k]
-      end
-    end
-  end
-
-  # tosses out any peptides from pep_groups where the
-  # arithmetic_avg_scan_by_parent_time.time is greater than 'deviations' from
-  # the least squares regression line assumes that each peptide is parallel
-  # (performed iteratively)
-  def toss_outliers(pep_groups, deviations=0.0)
-    arr_of_vecs = pep_groups.collect do |peps|
-      time_arr = peps.collect do |pep| 
-        pep.arithmetic_avg_scan_by_parent_time.time
-      end
-      VecD.new(time_arr)
-    end
-
-    # in the future this could be expanded for multiple dimensions
-    indices = arr_of_vecs.first.outliers_iteratively(deviations, arr_of_vecs[1])
-
-    # remove the peptides that are outliers
-    #pep_groups.each do |peps| puts peps.size.to_s end
-    pep_groups.each do |peps|
-      indices.each do |i| peps.delete_at(i) end
-    end
-    #pep_groups.each do |peps| puts peps.size.to_s end
-    pep_groups
-  end
-
-  # max_dups will toss out any peptides having > max_dups dtafilenames
-  # Currently, this will only take 2 groups of peptides
-  def overlapping_peps_by_seqcharge_with_filter(pep_groups, max_dups=nil, outlier_cutoff=0.0)
-    pep_groups.collect! do |pep_group|
-      pep_group.first.class.filter_by_max_dup_scans(max_dups, pep_group)
-    end
-    pep_groups = overlapping_peps_by_seqcharge(pep_groups)
-    toss_outliers(pep_groups, outlier_cutoff)
-    pep_groups
-  end
-
-  def _update_filenames(peptides, dta_filenames_by_seq_charge)
-    peptides.each do |pep|
-      pep.filenames = dta_filenames_by_seq_charge[[pep.sequence, pep.charge]]
-    end
-  end
-
-  # Returns a hash[dtabase] -> [pep, ...]
-  # Proteins must have peptides
-  def _peps_by_dtabase(peptides)
-    ## organize peptides based on filenames
-    peptides_by_dtabase = Hash.new{|h,k| h[k] = [] }
-    peptides.each do |k,pep|
-      pep.filenames.each do |fn|
-        file = fn.split(".")[0]
-        peptides_by_file[file] << pep
-      end
-    end
-    peptides_by_dtabase
-  end
-
-
-end

data/lib/archive/targz.rb

@@ -1,94 +0,0 @@
-
-
-require 'archive/tar/minitar'
-
-require 'stringio'
-
-module Archive::Tar::Minitar
-
-  # entry may be a string (the name), or it may be a hash specifying the
-  # following: 
-  #   :name    (REQUIRED)
-  #   :mode    33188 (rw-r--r--) for files, 16877 (rwxr-xr-x) for dirs
-  #           (0O100644)                   (0O40755)
-  #   :uid    nil
-  #   :gid    nil
-  #   :mtime  Time.now
-  #
-  # if data == nil, then this is considered a directory!
-  # (use an empty string for a normal empty file)
-  # data should be something that can be opened by StringIO
-  def self.pack_as_file(entry, data, outputter) #:yields action, name, stats:
-    outputter = outputter.tar if outputter.kind_of?(Archive::Tar::Minitar::Output)
-
-    stats = {}
-    stats[:uid] = nil
-    stats[:gid] = nil
-    stats[:mtime] = Time.now
-
-    if data.nil?
-      # a directory
-      stats[:size] = 4096   # is this OK???
-      stats[:mode] = 16877  # rwxr-xr-x
-    else
-      stats[:size] = data.size
-      stats[:mode] = 33188  # rw-r--r--
-    end
-
-    if entry.kind_of?(Hash)
-      name = entry[:name]
-
-      entry.each { |kk, vv| stats[kk] = vv unless vv.nil? }
-    else
-      name = entry
-    end
-    
-    if data.nil?  # a directory
-      yield :dir, name, stats if block_given?
-      outputter.mkdir(name, stats)
-    else          # a file
-      outputter.add_file_simple(name, stats) do |os|
-        stats[:current] = 0
-        yield :file_start, name, stats if block_given?
-        StringIO.open(data, "rb") do |ff|
-          until ff.eof?
-            stats[:currinc] = os.write(ff.read(4096))
-            stats[:current] += stats[:currinc]
-            yield :file_progress, name, stats if block_given?
-          end
-        end
-        yield :file_done, name, stats if block_given?
-      end
-    end
-  end
-end
-
-
-require 'zlib'
-file_names = ['wiley/dorky1', 'dorky2', 'an_empty_dir']
-file_data_strings = ['my data', 'my data also', nil]
-
-
-module Archive ; end
-
-# usage:
-#     require 'archive/targz'
-#     Archive::Targz.archive_as_files("myarchive.tgz", %w(file1 file2 dir),
-#          ['data for file1', 'data for file2', nil])
-module Archive::Targz
-  # requires an archive_name (e.g., myarchive.tgz) and parallel filename and
-  # data arrays:
-  #     filenames = %w(file1 file2 empty_dir)
-  #     data_ar = ['stuff in file 1', 'stuff in file2', nil]
-  # nil as an entry in the data_ar means that an empty directory will be
-  # created
-  def self.archive_as_files(archive_name, filenames=[], data_ar=[])
-    tgz = Zlib::GzipWriter.new(File.open(archive_name, 'wb'))
-
-    Archive::Tar::Minitar::Output.open(tgz) do |outp|
-      filenames.zip(data_ar) do |name, data|
-        Archive::Tar::Minitar.pack_as_file(name, data, outp)
-      end
-    end
-  end
-end