mspire 0.4.9 → 0.5.0

data/script/mascot_fix_pepxml.rb

@@ -1,123 +0,0 @@
-#!/usr/bin/ruby
-
-require 'rubygems'
-require 'ms/msrun'
-gem 'axml', '= 0.0.2'
-
-# returns an array containing one or two pairs of [cycle_num, time] that
-# represent the lowest and highest cycle numbers coupled to lowest and highest
-# time (in seconds) and the lowest and highest associated experiment numbers
-def get_cycle_exp_time_triplets(string)
-  hash = {}
-  cycle_index = nil
-  ssplit = string.split(', ')
-  ssplit.each_with_index do |piece,i|
-    if piece =~ /^Cycle\(s\):/
-      cycle_index = i
-      break
-    end
-  end
-  cycle_info = ssplit[cycle_index..-1].join(", ")
-  #Cycle(s): 663, 675 (Experiment 2), 667 (Experiment 4)
-  (header, info) = cycle_info.split(': ')
-  cycles = []
-  cycle_exp_pairs = []
-  info.split('), ').each do |a| 
-    (nums, exp_num) = a.split('(')
-    nums = nums.split(', ').map {|v| v.to_i }
-    exp_num = exp_num.split(' ').last.sub(/\)$/,'').to_i
-    nums.each {|v| cycle_exp_pairs << [v, exp_num] }
-  end
-
-  min = cycle_exp_pairs.min
-  max = cycle_exp_pairs.max
-
-  elution = ssplit.select {|v| v.match(/^Elution:(.*)/) }.first
-  times = elution.split(': ').last
-  times.sub!(/ min$/,'')
-  times = times.split(' to ')
-  times.map! do |v| 
-    (minutes, minute_decimals) = v.split('.')
-    seconds = minutes.to_f * 60
-    seconds + ( minute_decimals.to_f * 60 / 100 )
-  end
-
-  if max == min
-    [[min.first, min.last, times.first]]
-  else
-    [[min.first, min.last, times.first], [max.first, max.last, times.last]]
-  end
-end
-
-def get_scan_num(cycle, cycle_time, time_to_scan_num)
-  # grossly inefficient, but guaranteed to get right answer!
-  below_scan = nil
-  time_to_scan_num.each do |scan_time, scan_num| 
-    if scan_time < cycle_time 
-      below_scan = scan_num
-    else
-      break  # scan_time > cycle_time
-    end
-  end
-  below_scan
-end
-
-#####################################################
-# MAIN:
-#####################################################
-
-additional_ext = ".with_scan_nums"
-
-if ARGV.size != 2
-  puts "usage: #{File.basename(__FILE__)} <file>.pepXML <file>.mzXML"
-  puts ""
-  puts "uses information from the mzXML file to fix the pepXML file"
-  puts "(adds in msms_run_summary: 'base_name' and 'raw_data' attributes;"
-  puts " adds scan numbers based on cycle and experiment times)"
-  puts ""
-  puts "outputs: <file>#{additional_ext}.pepXML"
-  exit
-end
-
-# get time_to_scan_num for msLevel=1 from the mzXML file
-(pepxml, mzxml) = ARGV
-mzxml_basename = File.basename(mzxml).sub(/\.mzxml$/i, '')
-
-ext = File.extname(pepxml)
-output = pepxml.sub(Regexp.new(Regexp.escape(ext)), additional_ext + ext)
-
-ms = MS::MSRun.new(mzxml, :lazy => :no_spectra)
-time_to_scan_num = ms.scans.select {|scan| scan.ms_level == 1 }.map do |scan|
-  [scan.time, scan.num]
-end
-
-# update spectrum queries based on scan number
-
-root = AXML.parse_file(pepxml)
-# fix the basename stuff:
-msms_r_summary_n = root.child
-atts = msms_r_summary_n.attrs
-atts['base_name'] = mzxml_basename
-atts['raw_data'] = '.mzXML'
-
-root.child.find("child::spectrum_query").each do |sq|
-  triplets = get_cycle_exp_time_triplets(sq['spectrum'])
-  triplets.map! do |triplet|
-    [get_scan_num(triplet[0], triplet[2], time_to_scan_num), *triplet]
-  end
-  # [scan_num, cycle, exp, time]
-  quad = triplets.first
-  first_scan_num = (quad[0] + quad[2] - 1)
-  sq.attrs['start_scan'] = first_scan_num.to_s
-  sq.attrs['end_scan'] = 
-    if triplets.size > 1
-      quad = triplets.last
-      (quad[0] + quad[2] - 1).to_s
-    else
-      first_scan_num.to_s
-    end
-end
-
-xml_header = '<?xml version="1.0" encoding="UTF-8"?>'
-File.open(output, 'w') {|out| out.puts(xml_header); out.print root.to_s }
-

data/script/msvis.rb

@@ -1,42 +0,0 @@
-#!/usr/bin/ruby
-
-
-options_file = "local.cfg"
-
-moving_options_file = false
-mv_options_file = ""
-if File.exist?(options_file)
-  mv_options_file = options_file + ".backup"
-  File.rename(options_file, mv_options_file)
-  moving_options_file = true
-end
-
-filetype = "msmat"
-files = ARGV.to_a
-
-base = "Msvis_filename"
-
-if files.size == 0
-  puts "msvis.rb file.msmat ..."
-  puts "right now only creates a local.cfg file"
-  exit
-end
-
-File.open(options_file, "w") do |fh|
-  fh.print "Msvis_filetype = " + filetype + "\n"
-  fh.print "Msvis_num = " + files.size.to_s + "\n"
-  cnt = 0
-  files.each do |file|
-    fh.print( base + cnt.to_s + " = " + "\"#{file}\"" + "\n" )
-    cnt += 1
-  end
-end
-
-#exec "./msvis"
-
-#File.unlink options_file
-
-#if moving_options_file
-#  File.rename mv_options_file, options_file
-#end
-

data/script/mzXML2timeIndex.rb

@@ -1,25 +0,0 @@
-#!/usr/bin/ruby -w
-
-require 'spec/mzxml/parser'
-require 'spec/msrun'
-require 'rexml/document'
-include REXML
-
-if ARGV.size < 1
-  puts "usage: #{File.basename(__FILE__)} file.mzXML ..."
-  puts "  outputs 'file.mzXML.timeIndex'"
-  puts "  which contains rows of:"
-  puts "  level scan_num time (if !msLevel1:) prec_mz prec_intensity"
-end
-
-# outputs rows of:
-# level scan_num time [precursor_mz precursor_intensity(if !msLevel1)]
-
-ARGV.each do |file|
-  puts "READING: " + file
-  outfile = file + '.timeIndex'
-  obj = MS::MSRunIndex.new(file)
-  puts "WRITING: " + outfile
-  obj.to_index_file(outfile)
-end
-

data/script/peps_per_bin.rb

@@ -1,67 +0,0 @@
-#!/usr/bin/ruby -w
-
-require 'generator'
-require 'optparse'
-
-require 'fasta'
-require 'sample_enzyme'
-require 'spec_id/digestor'
-require 'spec_id/mass'
-require 'vec'
-
-opt = {}
-opt[:missed_cleavages] = 0 # ~ parts per million
-opt[:bin_size] = 0.001  # ~ parts per million
-opt[:min] = 300.0
-opt[:max] = 4500.0
-opt[:h_plus] = 1.0
-
-opts = OptionParser.new do |op|
-  op.banner = "usage: #{File.basename(__FILE__)} *.fasta"
-  op.separator "Outputs a close estimate of number of peptides per bin."
-  op.separator "Uses m+H+ as the peptide mass."
-  op.separator "[for speed, assumes that there is a peptide mass close to the extremes]"
-  op.on("-b", "--bin_size <F>", Float, "size of bins [#{opt[:bin_size]}]") {|v| opt[:bin_size] = v }
-  op.on("-x", "--max <F>", Float, "max mass to accept [#{opt[:max]}]") {|v| opt[:max] = v }
-  op.on("-n", "--min <F>", Float, "min mass to accept [#{opt[:min]}]") {|v| opt[:min] = v }
-  op.on("-h", "--h_plus <F>", Float, "value of H+ to use [#{opt[:h_plus]}]") {|v| opt[:h_plus] = v }
-  op.on("-m", "--missed_cleavages <N>", Integer, "num missed cleavages [#{opt[:missed_cleavages]}]") {|v| opt[:missed_cleavages] = v }
-end
-
-opts.parse!
-
-if ARGV.size == 0
-  puts opts.to_s
-  exit
-end
-
-min_mass = opt[:min]
-max_mass = opt[:max]
-
-ARGV.each do |file|
-  fasta = Fasta.new(file)
-  uniq_aaseqs = fasta.map do |prot|
-    SampleEnzyme.tryptic(prot.aaseq, opt[:missed_cleavages])
-  end.flatten.uniq
-
-  masses = Mass::Calculator.new(Mass::MONO, opt[:h_plus]).masses(uniq_aaseqs)
-  passing_masses = Mass::Calculator.new(Mass::MONO, opt[:h_plus]).masses(uniq_aaseqs).select do |mh|
-    ((mh >= min_mass) and (mh <= max_mass))
-  end
-
-  ## warn if the masses aren't close to the end points
-  if (max_mass - passing_masses.max) > 1.0
-    warn "highest mass is not that close to max: #{passing_masses.max}"
-  end
-  if (passing_masses.min - min_mass) > 1.0
-    warn "lowest mass is not that close to min: #{passing_masses.min}"
-  end
-
-  num_bins = (max_mass - min_mass) / opt[:bin_size]
-
-  (bins, freqs) = VecD.new(passing_masses).histogram(num_bins)
-
-  # report
-  puts "#{file}: #{freqs.avg}"
-
-end

data/script/prep_dir.rb

@@ -1,121 +0,0 @@
-#!/usr/bin/ruby -w
-
-
-## Assumes the same base
-module Kernel
-
-  @@remove_raw = [/flush/, /equil/, /To_sequest/, /to_sequest/, /TempSequence/]
-  @@seqext = '.sequest.zip'
-  @@rawext = ['.RAW.zip', '.raw.zip']
-
-## gets the basename of a file like this filename.RAW.zip or filename.raw.zip
-  def get_basename(zip_file)
-    basename = ""
-    try1 = File.basename(zip_file, @@rawext[0])
-    try2 = File.basename(zip_file, @@rawext[1])
-
-    if try1.size < try2.size
-      basename = try1 
-    elsif try1.size > try2.size
-      basename = try2 
-    else #they are equal
-      puts "something wrong at the basename"
-      exit(1)
-    end
-    basename
-  end
-  def remove_extra_raw
-    Dir.new(Dir.getwd).each do |test|
-      @@remove_raw.each do |try|
-        if test =~ try
-          puts "removing " + test
-          File.unlink test
-        end
-      end
-    end
-  end
-
-  def raw2mzXML
-    system "raw2mzXML.pl *.RAW"
-  end
-
-  def get_sequest_params(seqfile)
-    unless File.exist?(seqfile)
-      puts "couldn't find #{seqfile}"
-      exit
-    end
-    basename = get_seq_basename(seqfile)
-    extracted = basename + "/sequest.params"
-    system "unzip #{seqzip} #{extracted}"
-    return extracted
-  end
-
-  def get_seq_basename(file)
-    File.basename(file, @@seqext)
-  end
-
-end
-
-if ARGV.size < 1
-  puts "usage: #{File.basename(__FILE__)} file.raw.zip"
-  puts "This is specific to Peng's data to prepare it for OPD"
-  exit
-end
-
-rawfiles = []
-seqfiles = []
-ARGV.each do |try|
-  if try =~ /\.raw\.zip/
-    rawfiles.push(try)
-  elsif try =~ /\.sequest\.zip/
-    seqfiles.push(try)
-  else
-    puts "skipping " + try
-  end
-end
-
-
-## depends on them being alphebetical
-(0..(rawfiles.size)).each do |cnt|
-  rawfile = rawfiles[cnt]
-  seqfile = seqfiles[cnt]
-  break unless rawfile
-  raw_basename = get_basename(rawfile)
-  system("unzip #{rawfile}")
-  puts "Basename: " + raw_basename
-  current_dir = Dir.getwd
-  unless Dir.chdir(raw_basename)
-    puts "can't change to #{raw_basename}"
-    exit
-  end
-  remove_extra_raw
-  raw2mzXML
-  system("mkdir raw")
-  system("mkdir mzxml")
-  system('mv *.RAW raw/')
-  system('mv *.mzXML mzxml/')
-  Dir.chdir(current_dir)
-  rawzip = raw_basename + '.raw.zip'
-  mzxmlzip = raw_basename + '.mzxml.zip'
-  system("zip -r #{rawzip} #{raw_basename}/raw/*")
-  system("zip -r #{mzxmlzip} #{raw_basename}/mzxml/*")
-  system("mv #{rawzip} #{raw_basename}")
-  system("mv #{mzxmlzip} #{raw_basename}")
-  Dir.chdir(raw_basename)
-  if (Dir.glob("*.zip").size == 2)
-    system("rm -rf raw") 
-    system("rm -rf mzxml") 
-  end
-  Dir.chdir current_dir
-
-  ## get the sequest.params file:
-  extracted = get_sequest_params(seqfile)
-  system("mv #{extracted} #{raw_basename}")
-
-  ## move the sequest file in
-  system("chmod 664 #{seqfile}")
-  system("mv #{seqfile} #{raw_basename}")
-
-end
-
-

data/script/simple_protein_digestion.rb

@@ -1,27 +0,0 @@
-#!/usr/bin/ruby -w
-
-require 'fasta'
-require 'sample_enzyme'
-
-if ARGV.size < 2
-  puts "usage: #{File.basename(__FILE__)} missed_cleavages <file>.fasta ..."
-  puts "       returns <file>.missed_cleavages_<missed_cleavages>.peptides"
-  abort
-end
-
-missed_cleavages = ARGV.shift.to_i
-
-ARGV.each do |file|
-  
-  if file !~ /\.fasta/
-    abort "must be a fasta file with extension fasta"
-  end
-  new_filename = file.sub(/\.fasta$/, '')
-  new_filename << ".missed_cleavages_#{missed_cleavages}.peptides"
-  File.open(new_filename, "w") do |fh|
-    peptides = []
-    Fasta.new.read_file(file).prots.each do |prot|
-      fh.puts( prot.header.split(/\s+/).first.sub(/^>/,'') + "\t" + SampleEnzyme.tryptic(prot.aaseq, missed_cleavages).join(" ") )
-    end
-  end
-end

data/script/smriti_final_analysis.rb

@@ -1,103 +0,0 @@
-#!/usr/bin/ruby -w
-
-require 'spec_id'
-require 'fasta'
-require 'optparse'
-
-$top = false
-opts = OptionParser.new do |op|
-  op.banner = "usage: #{File.basename(__FILE__)} bioworks.xml <file>.fasta|prefix"
-  op.separator "outputs stdout (tab del sorted by probability) probability, file:aaseq:charge T/F"
-  op.separator "hashes on file+aaseq+charge"
-  op.on("-t", "--top", "only top peptide (by prob) per scan+charge") do
-    $top = true
-  end
-end
-
-opts.parse!
-
-if ARGV.size < 2
-  puts opts.to_s  
-  exit
-end
-
-specid_file = ARGV.shift
-file_or_prefix = ARGV.shift
-
-specid = SpecID.new(specid_file)
-
-indicator = 
-  if File.exist? file_or_prefix
-    Fasta.new.read_file(file_or_prefix)
-  else
-    file_or_prefix
-  end
-
-
-# returns an array containing the min prob peptides (in case of a tie)
-def lowest_peps(ar)
-  min_prob = ar.min {|a,b| a.probability.to_f <=> b.probability.to_f }.probability.to_f
-  ar.select {|v| v.probability.to_f == min_prob }
-end
-
-peps = specid.peps
-if $top
-  top_by_scan = []
-  peps.hash_by(:base_name, :first_scan).each do |k,v|
-    low_peps = lowest_peps(v)
-    top_by_scan.push( *low_peps )
-  end
-end
-
-results = top_by_scan.hash_by(:base_name, :aaseq, :charge).map do |k,v|
-  low_peps = lowest_peps(v)
-  #min_pep = v.min {|a,b| a.probability.to_f <=> b.probability.to_f }
-  all_prots = []
-  low_peps.each do |pep|
-    all_prot_references.push( *(pep.prots.map {|v| v.reference }) )
-  end
-  all_prot_references.uniq!
-  is_true =
-    if indicator.is_a? Fasta
-      all_prot_references.any? do |ref|
-        indicator.included_in_header?(ref)
-      end
-    else
-      !(all_prot_references.all? {|ref| ref.include?( indicator )})
-    end
-  [min_pep.probability.to_f, k, is_true]
-end
-
-results.sort.each do |result|
-  report = [result[0], result[1].join(':'), (result[2] ? 'T' : 'F')]
-  puts report.join("\t")
-end
-
-=begin
-# ORIGINAL CODE
-peps = specid.peps
-if $top
-  peps = peps.hash_by(:base_name, :first_scan).map do |k,v|
-    v.min {|a,b| a.probability.to_f <=> b.probability.to_f } 
-  end
-end
-
-results = peps.hash_by(:base_name, :aaseq, :charge).map do |k,v|
-  min_pep = v.min {|a,b| a.probability.to_f <=> b.probability.to_f }
-  references = min_pep.prots.map {|v| v.reference }.uniq
-  is_true =
-    if indicator.is_a? Fasta
-      references.any? do |ref|
-        indicator.included_in_header?(ref)
-      end
-    else
-      !(references.all? {|ref| ref.include?( indicator )})
-    end
-  [min_pep.probability.to_f, k, is_true]
-end
-
-results.sort.each do |result|
-  report = [result[0], result[1].join(':'), (result[2] ? 'T' : 'F')]
-  puts report.join("\t")
-end
-=end

data/script/sqt_to_meta.rb

@@ -1,24 +0,0 @@
-#!/usr/bin/ruby -s
-
-require 'optparse'
-
-$outfile = 'meta.sqm'
-opts = OptionParser.new do |op|
-  op.banner = "usage: #{File.basename(__FILE__)} <file>.sqt ..."
-  op.separator "outputs meta.sqm (a sqt meta file)"
-  op.on("-o", "--outfile <file>", "currently: #{$outfile}") {|v| $outfile = v}
-end
-
-opts.parse!
-
-if ARGV.size == 0
-  puts opts.to_s
-  exit
-end
-
-File.open($outfile, 'w') do |out|
-  ARGV.each do |file|
-    out.puts File.expand_path(file)
-  end
-end
-

data/script/top_hit_per_scan.rb

@@ -1,67 +0,0 @@
-#!/usr/bin/ruby -w
-
-###################################################################
-cats = %w(base_name sequence xcorr deltacn first_scan last_scan)
-###################################################################
-
-require 'spec_id'
-require 'hash_by'
-
-extension_top = '.top_per_scan.txt'
-extension_all = '.all_peps_per_scan.txt'
-
-if ARGV.size < 1
-  puts "usage: #{File.basename(__FILE__)} <file>.xml"
-  puts "output: <file>#{extension}"
-  puts ""
-  puts "Generates top hit (highest xcorr) per scan."
-  exit
-end
-
-def print_doc(outfile, headers, table_a_of_a)
-  document =  table_a_of_a.map do |line|
-    line.join("\t")
-  end.join("\n")
-  File.open(outfile, 'w') do |out|
-    out.print headers.join("\t") + "\n"
-    out.print document
-  end
-end
-
-
-def pep_array_to_table(peps, send_to)
-  arr_of_arr = peps.map do |pep|
-    arr = send_to.map {|sym| pep.send(sym) }
-    arr.unshift( pep.prot.reference )  # hacked on
-  end
-end
-
-###############################################
-# MAIN:
-###############################################
-
-file = ARGV[0]
-outfile_top = file.sub(/\.xml$/, extension_top)
-outfile_all = file.sub(/\.xml$/, extension_all)
-
-sp = SpecID.new(file)
-
-# The old (incorrect version)
-# pep_hash = sp.peps.hash_by(:first_scan, :last_scan)
-# The correct version:
-pep_hash = sp.peps.hash_by(:base_name, :first_scan, :last_scan)
-top_per_scan = pep_hash.map {|k,v| v.sort_by {|ob| ob.xcorr.to_f }.last }
-top_per_scan = top_per_scan.sort_by {|pep| pep.first_scan.to_i }
-
-all_peps = sp.peps.sort_by do |pep| [pep.first_scan.to_i, -1.0 * pep.xcorr.to_f] end
-
-cats_sym = cats.map {|v| v.to_sym }
-
-a_of_a_top = pep_array_to_table(top_per_scan, cats_sym)
-a_of_a_all = pep_array_to_table(all_peps, cats_sym)
-
-cats.unshift "protein_reference"
-
-print_doc(outfile_top, cats, a_of_a_top)
-print_doc(outfile_all, cats, a_of_a_all)
-

data/script/toppred_to_yaml.rb

@@ -1,47 +0,0 @@
-#!/usr/bin/ruby -w
-
-
-require 'optparse'
-
-opt = {}
-opt[:probability] = 1.0
-opts = OptionParser.new do |op|
-  op.banner = "USAGE: #{File.basename(__FILE__)} toppred.out"
-  op.separator "Outputs toppred.yaml"
-  op.separator "takes the highest probability structure"
-  op.separator "for best structures of equal probability, takes first given"
-  op.separator "Each line contains:"
-  op.separator "<identifier>: String :"
-  op.separator "                      num_found: Int"
-  op.separator "                      num_certain_transmembrane_segments: Int"
-  op.separator "                      num_putative_transmembrane_segments: Int"
-  op.separator "                      best_structure_probability: Float"
-  op.separator "                      transmembrane_segments:"
-  op.separator "                        - probability: Float"
-  op.separator "                          start: Int"
-  op.separator "                          stop: Int"
-  op.separator "                          aaseq: String"
-  op.separator ""
-  op.separator "OPTIONS:"
-  op.on("-p", "--probability", Float, "min structure prob threshold (default #{opt[:probability]})") {|v| opt[:probability] = v}
-end
-
-opts.parse!
-
-
-if ARGV.size == 0
-  puts opts
-  exit
-end
-
-file = ARGV.shift
-
-File.open(file) do |fh|
-  hash = Transmem.read_toppred(fh)
-end
-
-puts hash.to_yaml
-
-
-
-