mspire 0.1.7 → 0.2.0

data/lib/spec_id/filter.rb

@@ -0,0 +1,794 @@
+
+require 'spec_id'
+require 'optparse'
+require 'ostruct'
+require 'spec_id/aa_freqs'
+require 'shuffle'
+require 'vec'
+require 'table'
+
+
+########################################################
+WRITE_CYS_FIND = false
+########################################################
+
+
+module SpecID
+  attr_accessor :orig_peps, :passed_peps, :passed_prots
+  # The filename passed in for filtering
+  attr_accessor :passed_in_filename
+
+  # returns the top peptide hits per file dta (first_scan + charge)
+  # all hits with same score as top score are returned
+  # assumes that all fields are strings...
+  # converts xcorr, deltacn, deltamass, mass, and charge into numerical types
+  # deletes the protein array (but not relevant proteins)
+  # hashes on [pep.basename, pep.first_scan.to_i, pep.charge.to_i]
+  # sets the @orig_peps attribute to those passing
+  def top_peps_prefilter!
+    ## Bioworks peps are text based and need to be transformed first
+    if peps.first.is_a? Bioworks::Pep 
+      peps.each do |pep|
+        pep.xcorr = pep.xcorr.to_f
+        pep.deltacn = pep.deltacn.to_f
+        pep.deltamass = pep.deltamass.to_f
+        pep.mass = pep.mass.to_f
+        pep.charge = pep.charge.to_i
+        pep.first_scan = pep.first_scan.to_i
+      end
+    end
+    ## Srf Peps need no transformation!
+
+    # get the top peptide by firstscan/charge (equivalent to .out files)
+    top_peps = []
+    self.peps.hash_by {|pep| [pep.base_name, pep.first_scan, pep.charge]}.values.map do |v|
+      #self.peps.hash_by {|pep| [pep.aaseq, pep.charge]}.values.map do |v|
+      best_to_worst = v.sort_by {|pep| pep.xcorr}.reverse
+      top_score = best_to_worst.first.xcorr
+      best_to_worst.each do |pep|
+        if pep.xcorr == top_score
+          top_peps << pep
+        else ; break
+        end
+      end
+    end
+    @orig_peps = top_peps
+  end
+
+  # (xcorr1, xcorr2, xcorr3, deltacn, ppm)
+  # interface very unstable.  For now, keeping it very loose...
+  # assumed that peptide xcorr, deltacn, deltamass, mass, ppm are Floats
+  # assumed that peptide charge is Integer
+  # returns peps_passed
+  # must respond to 'peps'
+  # DOES NOT UPDATE the prot.peps attribute!!
+  def filter_sequest(args, include_deltacnstar=false)
+    (x1, x2, x3, deltacn, ppm) = args
+    self.peps.select do |pep|
+      # have to add the upper limit to deltacn because the lowest score is often
+      # assigned a 1.10 in bioworks!
+      pep_deltacn = pep.deltacn
+      pep_charge = pep.charge
+
+      ## The outer parentheses are critical to getting the correct answer!
+      passing = ( (pep_deltacn >= deltacn) and ((pep_charge == 1 && pep.xcorr >= x1) or (pep_charge == 2 && pep.xcorr >= x2) or (pep_charge == 3 && pep.xcorr >= x3)) and ( pep.ppm <= ppm ))
+
+      if passing
+        if !include_deltacnstar && pep_deltacn > 1.0
+          false
+        else
+          true
+        end
+      else
+        false
+      end
+    end
+  end
+
+
+  # given some list of SpecID::Pep based objects, finds the list of proteins
+  # associated with those peptides
+  # update_prot_peps => when true, updates prot.peps attribute given the list
+  # of pephits
+  # kind = 
+  # :no_update (current proteins are returned, but their peps attribute
+  # is not updated)
+  # :update (current proteins returned with peps attribute updated)
+  # :new (new proteins are created complete with peps attribute)
+  def self.passing_proteins(pephits, kind=:no_update)
+
+    orig_pephits_prts = []
+    if kind == :new
+      new_prots = {}
+      pephits.each_with_index do |pep,i|
+        orig_pephits_prts[i] = pep.prots
+        peps_new_prts = pep.prots.map do |prt|
+          if new_prots.key? prt.reference
+            already_exists = new_prots[prt.reference]
+          else
+            np = prt.dup
+            np.peps = []
+            new_prots[np.reference] = np
+            np
+          end
+        end
+        pep.prots = peps_new_prts
+      end
+    end
+
+    if kind == :update
+      pephits.each do |pep|
+        pep.prots.each do |prt|
+          prt.peps = []
+        end
+      end
+    end
+
+    prot_set = {}
+    pephits.each do |pep|
+      prts = pep.prots
+      prts.each do |prt|
+        prot_set[ prt.reference ] = prt 
+      end
+      if (kind == :update || kind == :new)
+        prts.each do |prt|
+          prt.peps << pep
+        end
+      end
+    end
+
+    ## Reset the original protein hits
+    if kind == :new
+      pephits.each_with_index do |pep,i|
+        pep.prots = orig_pephits_prts[i]
+      end
+    end
+
+    prot_set.values
+  end
+end
+
+
+class SpecID::Filter
+
+  NUM_PROT_FPPR_ITERATIONS = 10
+
+  def self.run_from_argv(argv)
+    obj = self.new
+    obj.run_from_argv(argv)
+  end
+
+  def run_from_argv(argv)
+    reply = get_options(argv) 
+    return unless reply
+    files, opt = reply
+
+    #files = ARGV.map {|file| file }
+    #ARGV.clear
+
+    $stderr.puts "reading files (can take a minute or two for large files)..." if $VERBOSE
+    spec_ids = files.map do |file|
+      spec_id = file_to_prefiltered_spec_id(file, opt)
+      spec_id
+    end
+
+    ## the options hash
+    hash = {} 
+    if opt.cys
+      if opt.cys[1]
+        opt.cys[1] = opt.cys[1].to_f
+      else
+        opt.cys[1] = 0.0
+      end
+      hash[:cys] = opt.cys
+    end
+
+
+    hash[:tps] = 
+      if opt.tps
+        Fasta.new.read_file(opt.tps).prots.map do |prot|
+          prot.aaseq.chomp
+        end
+      end
+
+    hash[:dcy] = 
+      if opt.false
+        new_spec_ids = []
+        prefixes_or_files = SpecID.extend_args(opt.false, files.size)
+        false_spec_ids = spec_ids.zip(prefixes_or_files).map do |spec_id, prefix_or_file|
+          if File.exist? prefix_or_file
+            new_spec_ids << spec_id
+            file_to_prefiltered_spec_id(prefix_or_file, opt)
+          else 
+            (tps, fps) = spec_id.classify_by_prefix(:peps, prefix_or_file)
+            fps_specid = spec_id.class.new
+            tps_specid = spec_id.class.new
+
+            fps_specid.peps = fps
+            tps_specid.peps = tps
+            new_spec_ids << tps_specid
+            fps_specid
+          end
+        end
+        spec_ids = new_spec_ids
+        false_spec_ids 
+      end
+
+    defaults = {
+      :dcy => nil, # { spec_id => false_spec_id }
+      :cys => nil, # [cys_background_freq, cys_containing_freq]
+      :tps => nil,
+      :tmm => nil,
+      :occams_razor => opt.occams_razor,
+    }
+    args = defaults.merge hash
+
+
+    base_args = [opt.x1, opt.x2, opt.x3, opt.c, opt.ppm]
+
+    #################################################### <-- 
+    @fppr_methods = [:tmm, :tps, :cys, :dcy].select do |x|
+      args[x]
+    end
+    @groups_reporting = [:pephits, :aaseq, :prothits]
+    @groups_reporting.push( :occams_razor ) if args[:occams_razor]
+
+    @cat_labels = {
+      :pephits => 'pep_hits', 
+      :prothits => 'prot_hits',
+      :aaseq => 'uniq_aa_hits',
+      :occams_razor => 'occams_prot_hits',
+    }
+    #################################################### <-- 
+
+    if opt.log
+      @logfh = File.open(opt.log, 'w')
+    else
+      @logfh = nil
+    end
+    #########################################
+    # PRINT FILTER LEGEND
+    out filter_legend(@fppr_methods)
+    #########################################
+
+    if opt.filters_file
+      lines = IO.readlines(opt.filters_file)
+      lines.each do |line|
+        line.chomp!
+        answer = prep_reply(line, base_args)
+        next if answer == false
+        base_args = answer
+        filter_round(spec_ids, base_args, args)
+      end
+    elsif opt.i
+      ## CLEAR ARGV (since otherwise, gets reads it!)
+      ARGV.clear
+      out interactive_help
+      reply = "nil"
+      loop do
+        b = base_args
+        out "#{b[0]} #{b[1]} #{b[2]} dcn:#{b[3]} ppm:#{b[4]}"
+        loop do
+          reply = gets.chomp
+          answer = prep_reply(reply, base_args)
+          if answer == false
+            out interactive_help
+          else
+            base_args = answer
+            filter_round(spec_ids, base_args, args)
+            break
+          end
+        end
+      end
+    else
+      filter_round(spec_ids, base_args, args)
+    end
+
+    if opt.log
+      @logfh.close
+    end
+
+  end
+
+  def out(string)
+    puts string
+    if @logfh
+      @logfh.puts string
+    end
+  end
+
+  # takes a fasta file or a string ( to be cast as a float )
+  def get_cys_freq(arg)
+    if File.exist? arg
+      SpecID::AAFreqs.new(arg).aafreqs[:C]
+    else
+      arg.to_f
+    end
+  end
+
+  # prints shortened number for display
+  def short(num)
+    sprintf( "%.3f",num)
+  end
+
+  # if good arguments, returns [files_array, options]
+  # else prints an error argument and returns nil
+  def get_options(argv)
+    dup_argv = argv.dup
+
+    opt = OpenStruct.new
+    opt.x1 = 1.0
+    opt.x2 = 1.5
+    opt.x3 = 2.0
+    opt.c = 0.1
+    opt.ppm = 1000.0
+    opt.false = false
+
+    opts = OptionParser.new do |op|
+      op.banner = "usage: #{File.basename(__FILE__)} [OPTS] <bioworks.xml | bioworks.srg>"
+      op.separator("prints number of peptides/proteins ID'd at given thresholds")
+      op.separator "only top hit (by xcorr) per scan+charge is considered"
+
+      #op.separator("** 'dcn*' is the number of peptides with deltacn == 1.1")
+      #op.separator("   (these are peptides who are the only hit with xcorr > 0)")
+      op.separator ""
+      op.on("-1", "--xcorr1 N", Float, "xcorr for +1 charge  d: #{opt.x1}") {|v| opt.x1 = v}
+      op.on("-2", "--xcorr2 N", Float, "xcorr for +2 charge  d: #{opt.x2}") {|v| opt.x2 = v}
+      op.on("-3", "--xcorr3 N", Float, "xcorr for +3 charge  d: #{opt.x3}") {|v| opt.x3 = v}
+      op.on("-c", "--deltacn N", Float, ">= deltacn  d: #{opt.c}") {|v| opt.c = v} 
+      op.on("-p", "--ppm N", Float,     "<= ppm               d: #{opt.ppm}") {|v| opt.ppm = v} 
+      op.separator "                                     if bioworks.xml, = 10^6deltamass/mass"
+      op.on("-i", "--interactive", "interactive filtering") {|v| opt.i = v} 
+      op.on("-f", "--false a,b,c", Array, "prot prefixes or filenames of decoys") {|v| opt.false = v} 
+      op.separator("                                     last given will apply to remaining files")
+      op.on("-y", "--cys <fasta_file|freq,[bkg]>", Array, "report fpr by expected cysteine freq") do |v| 
+        v[0] = get_cys_freq(v[0])
+        opt.cys = v
+      end
+      op.separator("                                     freq = freq of cysteine as amino acid")
+      op.separator("                                     [bkg] = freq of cys containing peps  d: 0.0")
+      op.on("--filters_file <file>", "(no -i) file with list of interactive input") {|v| opt.filters_file = v}
+      op.on("-t", "--tps <fasta>", "fasta file containing true hits") {|v| opt.tps = v }
+      #op.on("--tmm <toppred.out>", "toppred.out file with transmembr. topology") {|v| opt.tps = v }
+      op.on("--yaml", "spits out yaml-ized data") {|v| opt.tabulate = v }
+      op.on("--combined_score", "shows the combined score") {|v| opt.combined_score = v }
+      op.on("--marshal", "will write marshaled data or read existing") {|v| opt.marshal = v }
+      op.on("--log <file>", "also writes all output to file") {|v| opt.log = v }
+      op.on("--protein_summary", "writes passing proteins to .summary.html files") {|v| opt.protein_summary = v }
+      op.on("-z", "--occams_razor", "will show minimal set of proteins") {|v| opt.occams_razor = v }
+    end
+
+    opts.parse!(dup_argv)
+
+    if dup_argv.size < 1
+      puts opts
+      return nil
+    end
+
+    [dup_argv, opt]
+  end
+
+  # (actual # with cys, expected # with cys, total#peptides,
+  # mean_fraction_of_cysteines_true, std)
+  # PepHit(C) = Peptide containing cysteine
+  #   # Total PepHit(C)                   # Observed Bad Pep (C)
+  #   ------------------ proportional_to  ---------------------- 
+  #   # Total PepHit                      # Total Bad PepHit (X)
+  #  returns the fppr and the total number false
+  def fppr_by_cysteines(ac_num_with_cys, exp_num_with_cys, total_peptides, mean_fraction_true_cys=nil, std_fraction_true_cys=nil) 
+
+    # the number of bona fide BAD cysteine hits
+    # (some of the cysteine hits (~5%) are true positives)
+
+    ac_num_with_cys -= exp_num_with_cys * mean_fraction_true_cys if mean_fraction_true_cys
+    if ac_num_with_cys < 0.0 ; ac_num_with_cys = 0.0 end
+    total_number_false = (ac_num_with_cys * total_peptides).to_f/exp_num_with_cys
+    fppr = total_number_false / total_peptides
+    [fppr, total_number_false]
+  end
+
+  # num_peps_per_protein is an array of the number of peptides per protein hit
+  # (these are the true hits)
+  # assumes that the number follows a gaussian distribution (binomial
+  # distributions tend toward gaussians, I believe, at large N)
+  # returns [mean_num_wrong, mean_fppr, stdev_num_wrong, stdev_fppr] fppr
+  def protein_fppr( num_peps_per_protein, number_false_peptides, num_iterations=10)
+
+    ## Check for more false peptides than peptides in our proteins:
+    total_protein_peps = 0
+    contained = num_peps_per_protein.each do |num|
+      total_protein_peps += num
+    end
+    ## All peptides will be wrong every time!
+    ## which means all proteins will be wrong every time!
+    if number_false_peptides >= total_protein_peps
+      # [all proteins wrong, fppr=1.0
+      return [num_peps_per_protein.size, 1.0, 0.0, 0.0]
+    end
+
+
+    num_prots = num_peps_per_protein.size
+    sample = VecD.new(num_iterations)
+    # indexed by peptide_number, pointing to a protein's peptide_count
+    # we shuffle the indices and then walk along until we are finished
+    # then we count how many proteins still have peptides
+
+    # we create an array to hold the peptide number for each protein, then we
+    # can reference the same entity when subtracting the peptides in the
+    # algorithm
+    cont_pep_num_per_prot_ars = (0...num_iterations).map do |i|
+      total_protein_peps = 0
+      contained = num_peps_per_protein.map do |num|
+        [num]
+      end
+    end
+
+    cont_num_by_pep_index_ars = cont_pep_num_per_prot_ars.map do |ar|
+      index_count = 0
+      pc_ar = []
+      ar.each do |contained_num|
+        contained_num.first.times do
+          pc_ar[index_count] = contained_num
+          index_count += 1
+        end
+      end
+      pc_ar
+    end
+
+    indices = (0...(cont_num_by_pep_index_ars.first.size)).map {|x| x }
+     
+
+    (0...num_iterations).each do |i|
+      num_false = 0
+      indices.shuffle!
+      pc = cont_num_by_pep_index_ars[i]
+      number_false_peptides.times do |shuffle_index|
+        #big_i = indices[shuffle_index]
+        pc[indices[shuffle_index]][0] -= 1
+      end
+      cont_pep_num_per_prot_ars[i].each do |contained_pep_count|
+        if contained_pep_count.first == 0
+          num_false += 1
+        end
+      end
+      sample[i] = num_false
+    end
+    (mean_num_wrong, stdev) = sample.sample_stats
+    mean_fppr = mean_num_wrong / num_prots
+    stdev_fppr = stdev / num_prots
+    [mean_num_wrong, mean_fppr, stdev, stdev_fppr]
+  end
+
+  # returns [total_number_false, fppr, fraction_expected]
+  # also takes a hash of pephits keyed on :aaseq
+  def fraction_false_by_cysteines(pephits, cys_bg_freq, cys_containing_freq)
+    (ac, exp) = SpecID::AAFreqs.new.actual_and_expected_number_containing_cysteines(pephits, cys_bg_freq)
+    fraction_of_expected = ac.to_f/exp
+
+    (cys_fprate, total_num_false) = fppr_by_cysteines(ac, exp, pephits.size, cys_containing_freq)
+    [total_num_false, cys_fprate, fraction_of_expected]
+  end
+
+  def report_cysteines
+    #### UNDERWAY:::
+    cys_tps = pep_nums[i] - total_num_false
+
+    puts "CYSTEINE FPR: "
+    puts "  (# peps containing >= 1 cysteines)"
+    puts "              actual: #{ac}"
+    puts "fraction of expected: #{short(fraction_of_expected)}"
+    puts "     expected # FP's: " + short(total_num_false)
+    puts "      estimated  FPR: " + short( 100.0*cys_fprate ) + " % "
+
+    puts "combined_score = x1 + x2 + x3 + 20.0*deltacn + 4000.0*(1.0/ppm)"
+    puts "Combined Score & FPR"
+    puts "#{combined_score}\t#{cys_fprate}"
+    puts "Combined Score & fraction of expected"
+    #puts "#{combined_score} #{fraction_of_expected}"
+    to_write_cys_find = ["WRITE_CYS_FIND:", combined_score, fraction_of_expected]
+    puts to_write_cys_find.join("\t") if WRITE_CYS_FIND
+    puts(['TABULATE:', combined_score, pep_tps, pep_fpr, cys_tps, cys_fprate, '', x1, x2, x3, deltacn, ppm].join("\t")) if opt.tabulate
+
+  end
+
+  def filter_legend(fppr_methods)
+    lines = []
+    lines << "Note: protein FPPR values are probably optimistic"
+    lines << "[this implementation assumes an equal likelihood that a false peptide"
+    lines << " comes from a protein with more hits as one with less (which is probably"
+    lines << " not the case)]"
+    lines << "* = deltacn_star = peptides with deltacn > 1.0 (no sibling hits)"
+    if fppr_methods.size > 0
+      lines << "Following are methods for determining false identification rate:"
+      lines << ['dcy=decoy', 'cys=cysteine', 'tps=known_true_positives'].join(" ")
+      ## when tmm is implemented:
+      #lines << ['dcy=decoy', 'cys=cysteine', 'tmm=transmembrane', 'tps=known_true_positives'].join(" ")
+    end
+    lines.join("\n")
+  end
+
+  # does this give aafreq from a fasta file?
+  #      freq = cysteines.aafreqs[:C]
+
+  # returns  [total_number_false, fppr]
+  # pephits can be an array or a hash of peptides keyed on :aaseq
+  def fraction_false_by_true_pos(pephits, true_pos_aaseqs_ar)
+    if pephits.is_a? Hash
+      seqs = pephits.keys
+    else
+      seqs = pephits.map do |v|
+        v.aaseq
+      end
+    end
+    real_tps = 0
+    real_fps = 0
+    # could also do with partition
+    seqs.each do |pep_aaseq|
+      if true_pos_aaseqs_ar.any? {|prot_aaseq| prot_aaseq.include? pep_aaseq}
+        real_tps += 1
+      else
+        real_fps += 1
+      end
+    end
+    real_fppr = real_fps.to_f/pephits.size
+    [real_fps, real_fppr]
+  end
+
+  def filter_spec_id(spec_id, filter_args, args)
+    results_hash = {}
+    # that second argument is to update protein peptides
+    pephits = spec_id.filter_sequest(filter_args)
+
+    results_hash[:prothits] = SpecID.passing_proteins(pephits, :no_update)
+    results_hash[:pephits] = pephits
+    results_hash[:dcn_cnt] = pephits.select{|v| v.deltacn > 1.0}.size
+    # be aware that this is a hash keyed by aaseq and values of arrays of
+    # peptides sharing the same aaseq!
+    results_hash[:aaseq] = pephits.hash_by(:aaseq)
+    results_hash
+  end
+
+  # returns [#FP, FPPR]
+  def dcy_fppr(pephits, false_pephits)
+    fps = false_pephits.size
+    [fps, fps.to_f/pephits.size]
+  end
+
+  def tmm_fppr(pephits)
+    abort "NEED TO IMPLEMENT"
+  end
+
+  # returns [#FP, FPPR]
+  def cys_fppr(pephits, cys_bg_freq, cys_containing_freq)
+    (total_num_false, cys_fprate, fraction_of_expected) = fraction_false_by_cysteines(pephits, cys_bg_freq, cys_containing_freq)
+    [total_num_false, cys_fprate]
+  end
+
+  def tps_fppr(pephits, true_pos_aaseqs_ar)
+    fraction_false_by_true_pos(pephits, true_pos_aaseqs_ar)
+  end
+
+  ## methods should be passed in like this 'cysteine' for cysteine_fppr
+  ## all methods should return [number_false, fppr]
+  ## returns a hash (by method) for each set of pephits 
+  ## if :dcy is given as a method, then expects the false pephits array
+  def calculate_pep_fppr(pephits_ar, methods, args, false_pephits_ar=nil)
+    cnt = 0
+    pephits_ar.map do |ph|
+      hash = {}
+      methods.each do |mth|
+        case mth
+        when :dcy
+          hash[mth.to_sym] = send("#{mth}_fppr".to_sym, ph, false_pephits_ar[cnt])  
+        when :cys
+          hash[mth.to_sym] = send("#{mth}_fppr".to_sym, ph, *(args[:cys]) )
+        when :tps
+          hash[mth.to_sym] = send("#{mth}_fppr".to_sym, ph, (args[:tps]) )
+        else
+          hash[mth.to_sym] = send("#{mth}_fppr".to_sym, ph)  
+        end
+      end
+      cnt += 1
+      hash
+    end
+  end
+
+  # fpr is a SpecID obj that is the false positives
+  # cysteines holds an aafreqs object or nil
+  def filter_round(spec_ids, filter_args, args)
+
+    # push fpr on the end for the calculations
+    ## FILTER the NORMAL spec_id objects
+    little_tables = []
+    spec_ids.each_with_index do |spec_id, i|
+      normal_results = filter_spec_id(spec_id, filter_args, args)
+
+      ## FILTER the FALSE objects (if given)
+      false_results = 
+        if args[:dcy]
+          little_args_hash = args.dup
+          false_results = filter_spec_id(args[:dcy][i], filter_args, little_args_hash)
+        end
+
+      ## HOW TO CALCULATE FPPR FOR EVERYTHING:
+      # pephits     Fpephits C/Tpephits  TPpephits
+      # uniqaa      Funiqaa  C/Tuniqaa   TPuniqaa
+      # prothits    ProtFPR(Fpephits, prothits)   ProtFPR(C/Tpephits, prothits)   ProtFPR(total-TPpephits, prothits)
+      # OccProthits ProtFPR(Funiqaa, OccProthits) ProtFPR(C/Tuniqaa, OccProthits) ProtFPR(total-TPuniqaa, OccProthits)
+      # C/T = cystein or Transmembrane method
+
+      ## set up false results array
+      if args[:dcy]
+        fr_ar = [false_results[:pephits], false_results[:aaseq]]
+      else
+        fr_ar = nil
+      end
+      (pephits_fppr_results, aaseq_fppr_results) = calculate_pep_fppr([normal_results[:pephits], normal_results[:aaseq]], @fppr_methods, args, fr_ar)
+
+      ## NORMAL prothits
+      ## update prothits peptides
+      updated_proteins = SpecID.passing_proteins(normal_results[:pephits], :update)
+      pep_cnt_arr = updated_proteins.map {|v| v.peps.size }
+
+      ## update occams prothits
+      if args[:occams_razor]
+        updated_occams_protein_triplets = SpecID::occams_razor(updated_proteins, true)
+        occams_pep_cnt_arr = updated_occams_protein_triplets.map {|v| v[1].size }
+        occams_prots = updated_occams_protein_triplets.map {|v| v[0] }
+        normal_results[:occams_razor] = occams_prots
+      end
+
+      ## note that the original prot.peps arrays are obliterated by this.
+      ## we would need to re-update if someone wanted these
+
+      prothits_fppr_results = {}
+      occams_results = {}
+      @fppr_methods.each do |mth|
+        prothits_fppr_results[mth] = protein_fppr(pep_cnt_arr, pephits_fppr_results[mth].first.ceil.to_i, NUM_PROT_FPPR_ITERATIONS)
+        occams_results[mth] = protein_fppr(occams_pep_cnt_arr, aaseq_fppr_results[mth].first.ceil.to_i, NUM_PROT_FPPR_ITERATIONS) if args[:occams_razor]
+      end
+
+      fppr_results = {
+        :pephits => pephits_fppr_results,
+        :aaseq => aaseq_fppr_results,
+        :prothits => prothits_fppr_results,
+      }
+      fppr_results[:occams_razor] = occams_results if args[:occams_razor]
+
+      ## CHANGE ALL RESULTS INTO PERCENTAGES:
+      fppr_results.each do |bk,hash|
+        hash.each do |k,val|
+          hash[k][1] = 100.0 * val[1] 
+        end
+      end
+      little_tables[i] = to_table( spec_id, args, normal_results, fppr_results, @groups_reporting, @fppr_methods, @cat_labels)
+    end
+
+    out filter_params_string(filter_args, @fppr_methods)
+    little_tables.each do |tbl|
+      out tbl.to_formatted_string(nil, '  ')
+      out "-----------------------------------------------\n"
+    end
+    #big_table(spec_ids, filter_args, args, normal_results, groups_reporting, fppr_results, cat_labels)
+    
+  end
+
+  
+
+  def filter_params_string(filter_args, fppr_methods)
+    (x1, x2, x3, deltacn, ppm) = filter_args
+    st = []
+    st << "=========================================================================="
+    st << " xcorr(1,2,3) >= #{x1},#{x2},#{x3} || deltacn >= #{deltacn} || ppm <= #{ppm} "
+    st << ''
+    st.join("\n")
+    #st = []
+    #st << ["xcorr(1,2,3) >= #{x1},#{x2},#{x3}", "deltacn >= #{deltacn}", "ppm <= #{ppm}"].join("\t")
+    #st
+  end
+
+  def to_table(spec_id, args, normal_results, fppr_results, groups_reporting, fppr_methods, cat_labels)
+    #table is in the form: { column heading => [ values ] }
+    
+    title = spec_id.passed_in_filename
+    col_labels = ['num', *(fppr_methods.map{|v| "#{v}%" })]
+
+    row_labels = groups_reporting.map {|grp| cat_labels[grp]}
+    dt = groups_reporting.map do |grp|
+      line = [normal_results[grp].size]
+      fppr_methods.each do |mth|
+        line << fppr_results[grp][mth][1]
+      end
+      line
+    end
+
+    Table.new(dt, row_labels, col_labels, title)
+    #puts(['TABULATE:', combined_score, pep_tps, pep_fppr, real_tps, real_fppr, '', x1, x2, x3, deltacn, ppm].join("\t")) if opt.tabulate
+  end
+
+  def combined_score(filter_args)
+    (x1, x2, x3, deltacn, ppm) = filter_args
+    combined_score = x1 + x2 + x3 + 20.0*deltacn + 4000.0*(1.0/ppm)
+  end
+
+  # assumes its already chomped
+  # updates the 5 globals
+  def prep_reply(reply, base)
+    if reply == 'q' ; exit ; end
+    if reply =~ /^\s*$/
+      base
+    elsif reply
+      arr = reply.split(/\s+/)
+      to_change = []
+      to_change_hash = {}
+      arr.each do |it|
+        if it.include? ':'
+          (k,v) = it.split(':')
+          to_change_hash[k] = v
+        else
+          to_change << it
+        end
+      end
+      to_change.each_with_index do |tc,i|
+        begin
+          base[i] = tc.to_f
+        rescue NoMethodError
+          out "BAD ARG: #{tc}"
+          return false
+        end
+      end
+      to_change_hash.each do |k,v|
+        case k
+        when 'x1' ; base[0] = v
+        when 'x2' ; base[1] = v
+        when 'x3' ; base[2] = v
+        when 'dcn' ; base[3] = v
+        when 'ppm' ; base[4] = v
+        else
+          out "BAD ARG: #{k}:#{v}"
+        end
+      end
+      base.map {|v| v.to_f }
+    else
+      false
+    end
+  end
+
+  def file_to_prefiltered_spec_id(file, opt)
+    spec_id = nil
+    marshal_file = file + ".prefiltered.msh"
+    if File.exist?(marshal_file)
+      File.open(marshal_file) do |fh|
+        spec_id = Marshal.load(fh)
+      end
+    else
+      spec_id = SpecID.new(file)
+      spec_id.passed_in_filename = file
+      spec_id.top_peps_prefilter!
+      ## marshal it!
+      if opt.marshal
+        File.open(marshal_file, "w") do |fh|
+          Marshal.dump(spec_id,fh)
+        end
+      end
+    end
+    spec_id
+  end
+
+  def interactive_help
+    string = []
+    string << "********************************************************"
+    string << "INTERACTIVE FILTERING HELP:"
+    string << "enter: <x1> <x2> <x3> <dcn> <ppm>"
+    string << "or   : x1:<x1> x2:<x2> x3:<x3> dcn:<dcn> ppm:<ppm>"
+    string << "or   : dcn:<dcn>"
+    string << "or   : <x1> <x2> ppm:<ppm>"
+    string << "etc..."
+    string << "<enter> to (re)run current values"
+    string << "'q' to quit"
+    string << "********************************************************"
+    string.join("\n")
+  end
+
+
+end