miga-base 0.7.25.2 → 0.7.25.3

data/utils/enveomics/Scripts/ogs.mcl.rb

@@ -1,186 +0,0 @@
-#!/usr/bin/env ruby
-
-#
-# @author: Luis M. Rodriguez-R
-# @update: Sep-11-2015
-# @license: artistic license 2.0
-#
-
-$:.push File.expand_path(File.dirname(__FILE__) + "/lib")
-require 'enveomics_rb/og'
-require 'optparse'
-require 'tmpdir'
-
-o = {q:false, f:"(\\S+)-(\\S+)\\.rbm", mcl:"", inflation:1.5, blind:false,
-   evalue:false, thr:2, identity:false, bestmatch:false}
-ARGV << "-h" if ARGV.size==0
-OptionParser.new do |opts|
-   opts.banner = "
-Identifies Orthology Groups (OGs) in Reciprocal Best Matches (RBM)
-between all pairs in a collection of genomes, using the Markov Cluster
-Algorithm.
-
-Requires MCL (see http://www.micans.org/mcl).
-
-Usage: #{$0} [options]"
-   opts.separator ""
-   opts.separator "Mandatory"
-   opts.on("-o", "--out FILE",
-      "Output file containing the detected OGs."){ |v| o[:out]=v }
-   opts.on("-d", "--dir DIR",
-      "Directory containing the RBM files.",
-      "Becomes optional iff --abc is set to a non-empty file."){ |v| o[:dir]=v }
-   opts.separator ""
-   opts.separator "Other Options"
-   opts.on("-f", "--format STRING",
-      "Format of the filenames for the RBM files (within -d), using regex " +
-      "syntax.", "By default: '#{o[:f]}'."){ |v| o[:f]=v }
-   opts.on("-I", "--inflation FLOAT",
-      "Inflation parameter for MCL clustering. By default: #{o[:inflation]}."
-      ){ |v| o[:inflation]=v.to_f }
-   opts.on("-b", "--blind",
-      "If set, computes clusters without taking bitscore into account."
-      ){ |v| o[:blind]=v }
-   opts.on("-e", "--evalue",
-      "If set, uses the e-value to weight edges, instead of the default " +
-      "Bit-Score."){ |v| o[:evalue]=v }
-   opts.on("-i", "--identity",
-      "If set, uses the identity to weight edges, instead of the default " +
-      "Bit-Score."){ |v| o[:identity]=v }
-   opts.on("-B", "--best-match",
-      "If set, it assumes best-matches instead reciprocal best matches."
-      ){ |v| o[:bestmatch]=v }
-   opts.on("-m", "--mcl-bin DIR",
-      "Path to the directory containing the mcl binaries.",
-      "By default, assumed to be in the PATH."){ |v| o[:mcl]=v+"/" }
-   opts.on("--abc FILE",
-      "Use this abc file instead of a temporal file."){ |v| o[:abc] = v }
-   opts.on("-t", "--threads INT",
-      "Number of threads to use. By default: #{o[:thr]}."){ |v| o[:thr]=v.to_i }
-   opts.on("-q", "--quiet", "Run quietly (no STDERR output)."){ o[:q] = true }
-   opts.on("-h", "--help", "Display this screen.") do
-      puts opts
-      exit
-   end
-   opts.separator ""
-end.parse!
-abort "-o is mandatory" if o[:out].nil?
-o[:evalue] = false if o[:identity]
-o[:evalue] = false if o[:blind]
-o[:identity] = false if o[:blind]
-
-##### MAIN:
-begin
-   Dir.mktmpdir do |dir|
-      o[:abc] = "#{dir}/rbms.abc" if o[:abc].nil?
-      abort "-d must exist and be a directory" unless
-	 File.size?(o[:abc]) or
-	 (!o[:dir].nil? and File.exists?(o[:dir]) and File.directory?(o[:dir]))
-      # Traverse the whole directory
-      if File.size? o[:abc]
-	 $stderr.puts "Reusing existing abc file '#{o[:abc]}'." unless o[:q]
-      else
-	 file_i = 0
-	 ln_i = 0
-	 $stderr.puts "Reading RBM files within '#{o[:dir]}'." unless o[:q]
-	 abc = File.open(o[:abc] + ".tmp", "w")
-	 Dir.entries(o[:dir]).each do |rbm_file|
-	    next unless File.file?(o[:dir]+"/"+rbm_file)
-	    # Parse the filename to identify the genomes
-	    m = /#{o[:f]}/.match(rbm_file)
-	    if m.nil? or m[2].nil?
-	       warn "Ignoring #{rbm_file}: doesn't match /#{o[:f]}/."
-	       next
-	    end
-	    file_i += 1
-	    # Read the RBMs list
-	    f = File.open(o[:dir]+"/"+rbm_file, "r")
-	    while ln = f.gets
-	       # Add the RBM to the abc file
-	       row = ln.split(/\t/)
-	       abc.puts [m[1]+">"+row[0], m[2]+">"+row[1],
-		  (o[:blind] ? "1" :
-		  (o[:evalue] ? row[10] :
-		  (o[:identity] ? row[2] : row[11])))].join("\t")
-	       ln_i += 1
-	    end
-	    f.close
-	    $stderr.print " Scanned files: #{file_i}. " +
-	       "Found RBMs: #{ln_i}.   \r" unless o[:q]
-	 end
-	 abc.close
-	 File.rename(o[:abc] + ".tmp", o[:abc])
-	 $stderr.print "\n" unless o[:q]
-      end # if File.size? o[:abc] ... else
-
-      # Build .mci file (mcxload) and compute .mccl file (mcl)
-      $stderr.puts "Markov-Clustering" unless o[:q]
-      `'#{o[:mcl]}mcxload' #{"--stream-mirror" unless o[:bestmatch]} \
-	 -abc '#{o[:abc]}' -o '#{dir}/rbms.mci' --write-binary \
-	 -write-tab '#{dir}/genes.tab' #{"--stream-neg-log10" if o[:evalue]} \
-	 &>/dev/null`
-      `'#{o[:mcl]}mcl' '#{dir}/rbms.mci' -V all -I #{o[:inflation].to_s} \
-	 -o '#{dir}/ogs.mcl' -te #{o[:thr].to_s}`
-
-      # Load .tab as Gene objects
-      $stderr.puts "Loading gene table from '#{dir}/genes.tab'." unless o[:q]
-      genes = []
-      tab = File.open("#{dir}/genes.tab", "r")
-      while ln = tab.gets
-	 ln.chomp!
-	 r = ln.split /\t|>/
-	 genes[ r[0].to_i ] = Gene.new(r[1], r[2])
-      end
-      tab.close
-      $stderr.puts " Got " + genes.size.to_s + " genes in " +
-	 Gene.genomes.size.to_s + " genomes." unless o[:q]
-      
-      # Load .mcl file as OGCollection
-      $stderr.puts "Loading clusters from '#{dir}/ogs.mcl'." unless o[:q]
-      collection = OGCollection.new
-      mcl = File.open("#{dir}/ogs.mcl", "r")
-      in_matrix = false
-      my_genes = nil
-      while ln = mcl.gets
-         ln.chomp!
-	 if ln =~ /^\(mclmatrix$/
-	    in_matrix = true
-	    next
-	 end
-	 next if ln =~ /^begin$/
-	 if in_matrix
-	    break if ln =~ /^\)$/
-	    if ln =~ /^\d+\s+/
-	       ln.sub!(/^\d+\s+/, "")
-	       my_genes = []
-	    end
-	    ln.sub!(/^\s+/, "")
-	    raise "Incomplete mcl matrix, offending line: #{$.}: #{ln}" if
-	       my_genes.nil?
-	    my_genes += ln.split(/\s/)
-	    if my_genes.last == "$"
-	       my_genes.pop
-	       og = OG.new
-	       my_genes.each{|i| og << genes[ i.to_i ]}
-	       collection << og
-	       my_genes = nil
-	    end
-	 end
-      end
-      mcl.close
-      $stderr.puts " Got #{collection.ogs.size} clusters." unless o[:q]
-      
-      # Save the output matrix
-      $stderr.puts "Saving matrix into '#{o[:out]}'." unless o[:q]
-      f = File.open(o[:out], "w")
-      f.puts collection.to_s
-      f.close
-      $stderr.puts "Done.\n" unless o[:q] 
-   end
-rescue => err
-   $stderr.puts "Exception: #{err}\n\n"
-   err.backtrace.each { |l| $stderr.puts l + "\n" }
-   err
-end
-
-

data/utils/enveomics/Scripts/ogs.rb

@@ -1,104 +0,0 @@
-#!/usr/bin/env ruby
-
-#
-# @author: Luis M. Rodriguez-R
-# @update: Apr-29-2015
-# @license: artistic license 2.0
-#
-
-$:.push File.expand_path(File.dirname(__FILE__) + '/lib')
-require 'enveomics_rb/og'
-require 'optparse'
-
-o = {:q=>FALSE, :f=>"(\\S+)-(\\S+)\\.rbm", :consolidate=>TRUE, :pre=>[]}
-ARGV << '-h' if ARGV.size==0
-OptionParser.new do |opts|
-   opts.banner = "
-***IMPORTANT NOTE***
-This script suffers from chaining effect and is very sensitive to spurious connections,
-because it applies a greedy clustering algorithm. For most practical purposes, the use
-of this script is discouraged and `ogs.mcl.rb` should be preferred. [ Apr-29-2015 ]
-
-Identifies Orthology Groups (OGs) in Reciprocal Best Matches (RBM)
-between all pairs in a collection of genomes.
-
-Usage: #{$0} [options]"
-   opts.separator ""
-   opts.separator "Mandatory"
-   opts.on("-o", "--out FILE", "Output file containing the detected OGs."){ |v| o[:out]=v }
-   opts.separator ""
-   opts.separator "Other Options"
-   opts.on("-d", "--dir DIR", "Directory containing the RBM files."){ |v| o[:dir]=v }
-   opts.on("-p", "--pre-ogs FILE1,FILE2,...", Array, "Pre-computed OGs file(s), separated by commas."){ |v| o[:pre]=v }
-   opts.on("-n", "--unchecked", "Do not check internal redundancy in OGs."){ o[:consolidate]=FALSE }
-   opts.on("-f","--format STRING", "Format of the filenames for the RBM files (within -d), using regex syntax. By default: '#{o[:f]}'."){ |v| o[:f]=v }
-   opts.on("-q", "--quiet", "Run quietly (no STDERR output)."){ o[:q] = TRUE }
-   opts.on("-h", "--help", "Display this screen.") do
-      puts opts
-      exit
-   end
-   opts.separator ""
-end.parse!
-abort "-o is mandatory" if o[:out].nil?
-
-##### MAIN:
-begin
-   # Initialize the collection of OGs.
-   collection = OGCollection.new
-   # Read the pre-computed OGs (if -p is passed).
-   o[:pre].each do |pre|
-      $stderr.puts "Reading pre-computed OGs in '#{pre}'." unless o[:q]
-      f = File.open(pre, 'r')
-      h = f.gets.chomp.split /\t/
-      while ln = f.gets
-	 collection << OG.new(h, ln.chomp.split(/\t/))
-      end
-      f.close
-      $stderr.puts " Loaded OGs: #{collection.ogs.length}." unless o[:q]
-   end
-   # Read the RBM files in the directory (if -d is passed).
-   unless o[:dir].nil?
-      abort "-d must exist and be a directory" unless File.exists?(o[:dir]) and File.directory?(o[:dir])
-      # Traverse the whole directory.
-      file_i = 0
-      $stderr.puts "Reading RBM files within '#{o[:dir]}'." unless o[:q] 
-      Dir.entries(o[:dir]).each do |rbm_file|
-	 next unless File.file?(o[:dir]+"/"+rbm_file)
-	 # Parse the filename to identify the genomes.
-	 m = /#{o[:f]}/.match(rbm_file)
-	 if m.nil? or m[2].nil?
-	    warn "Cannot parse filename: #{rbm_file} (doesn't match /#{o[:f]}/)."
-	    next
-	 end
-	 file_i += 1
-	 # Read the RBMs list
-	 f = File.open(o[:dir]+"/"+rbm_file, "r")
-	 while ln = f.gets
-	    # Add the RBM to the collection of OGs. Only the first two columns are used.
-	    row = ln.split(/\t/)
-	    collection.add_rbm( Gene.new(m[1],row[0]), Gene.new(m[2],row[1]) )
-	 end
-	 f.close
-	 $stderr.print " Scanned files: #{file_i}. Found OGs: #{collection.ogs.length}.   \r" unless o[:q]
-      end
-      $stderr.print "\n" unless o[:q]
-   end
-   # Evaluate internal consistency merging linked OGs (unless -n is passed).
-   if o[:consolidate]
-      $stderr.puts "Evaluating internal consistency." unless o[:q] 
-      collection.consolidate!
-      $stderr.puts " Final OGs: #{collection.ogs.length}." unless o[:q]
-   end
-   # Save the output matrix
-   $stderr.puts "Saving matrix into '#{o[:out]}'." unless o[:q]
-   f = File.open(o[:out], "w")
-   f.puts collection.to_s
-   f.close
-   $stderr.puts "Done.\n" unless o[:q] 
-rescue => err
-   $stderr.puts "Exception: #{err}\n\n"
-   err.backtrace.each { |l| $stderr.puts l + "\n" }
-   err
-end
-
-

data/utils/enveomics/Scripts/ogs.stats.rb

@@ -1,131 +0,0 @@
-#!/usr/bin/env ruby
-
-#
-# @author: Luis M. Rodriguez-R
-# @license: Artistic-2.0
-#
-
-$:.push File.expand_path(File.dirname(__FILE__) + '/lib')
-require 'enveomics_rb/og'
-require 'optparse'
-require 'json'
-
-o = {q:false, a:false}
-ARGV << '-h' if ARGV.size==0
-OptionParser.new do |opts|
-  opts.banner = "
-Estimates some descriptive statistics on a set of Orthology Groups (OGs).
-
-Usage: #{$0} [options]"
-  opts.separator ""
-  opts.separator "Mandatory"
-  opts.on("-o", "--ogs FILE",
-    "Input file containing the precomputed OGs."){ |v| o[:ogs]=v }
-  opts.separator ""
-  opts.separator "Other Options"
-  opts.on("-j", "--json FILE", "Output file in JSON format."){ |v| o[:json]=v }
-  opts.on("-t", "--tab FILE","Output file in tabular format."){ |v| o[:tab]=v }
-  opts.on("-T", "--transposed-tab FILE",
-    "Output file in transposed tabular format."){ |v| o[:ttab]=v }
-  opts.on("-a", "--auto", "Run completely quietly (no STDERR or STDOUT)") do
-    o[:q] = true
-    o[:a] = true
-  end
-  opts.on("-q", "--quiet", "Run quietly (no STDERR output)."){ o[:q] = true }
-  opts.on("-h", "--help", "Display this screen.") do
-    puts opts
-    exit
-  end
-  opts.separator ""
-end.parse!
-abort "-o is mandatory" if o[:ogs].nil?
-
-##### MAIN:
-begin
-  # Initialize the collection of OGs.
-  collection = OGCollection.new
-   
-  # Read the pre-computed OGs
-  $stderr.puts "Reading pre-computed OGs in '#{o[:ogs]}'." unless o[:q]
-  f = File.open(o[:ogs], "r")
-  h = f.gets.chomp.split /\t/
-  while ln = f.gets
-    collection << OG.new(h, ln.chomp.split(/\t/))
-  end
-  f.close
-  $stderr.puts " Loaded OGs: #{collection.ogs.length}." unless o[:q]
-   
-  # Estimate descriptive stats
-  stat_name = {
-    genomes: "Number of genomes",
-    pan: "Pangenome (OGs)",
-    core: "Core genome (OGs)",
-    core90pc: "OGs in 90% of the genomes",
-    core80pc: "OGs in 80% of the genomes",
-    unus: "Unus genome, core genome discarding paralogs (OGs)",
-    avg: "Average number of OGs in a genome",
-    avg_pan: "Average genome (OGs) / Pangenome (OGs)",
-    core_avg: "Core genome (OGs) / Average genome (OGs)",
-    core_pan: "Core genome (OGs) / Pangenome (OGs)",
-    ogs_shannon: "Entropy of the OG frequencies (bits)"
-  }
-  stats = {}
-  stats[:genomes] = Gene.genomes.length
-  stats[:pan] = collection.ogs.length
-  stats[:core] = collection.ogs.map do |og|
-    (og.genomes.length == Gene.genomes.length) ? 1 : 0
-  end.inject(0,:+)
-  stats[:core90pc] = collection.ogs.map do |og|
-    (og.genomes.length >= 0.9*Gene.genomes.length) ? 1 : 0
-  end.inject(0,:+)
-  stats[:core80pc] = collection.ogs.map do |og|
-    (og.genomes.length >= 0.8*Gene.genomes.length) ? 1 : 0
-  end.inject(0,:+)
-  stats[:unus] = collection.ogs.map do |og|
-    (og.genomes.length != Gene.genomes.length) ? 0 :
-      (og.genes.all?{ |i| i.size==1 }) ? 1 : 0
-  end.inject(0,:+)
-  og_genomes = collection.ogs.map{ |og| og.genomes.length }.inject(0,:+)
-  stats[:avg] = og_genomes.to_f/Gene.genomes.length
-  stats[:avg_pan] = stats[:avg]/stats[:pan]
-  stats[:core_avg] = stats[:core].to_f/stats[:avg]
-  stats[:core_pan] = stats[:core].to_f/stats[:pan]
-  stats[:ogs_shannon] = -1 * collection.ogs.map do |og|
-    pi = og.genomes.length.to_f/Gene.genomes.length
-    pi * Math.log(pi)
-  end.inject(0.0,:+)
-
-  # Show result
-  $stderr.puts "Generating reports." unless o[:q]
-  stats.each_pair{ |k,v| puts " #{stat_name[k]}: #{v}" } unless o[:a]
-
-  # Save results in JSON
-  unless o[:json].nil?
-    ohf = File.open(o[:json], "w")
-    ohf.puts JSON.pretty_generate(stats)
-    ohf.close
-  end
-
-  # Save results in tab
-  unless o[:tab].nil?
-    ohf = File.open(o[:tab], "w")
-    stats.each_pair{ |k,v| ohf.puts "#{k}\t#{v}" }
-    ohf.close
-  end
-
-  # Save results in T(tab)
-  unless o[:ttab].nil?
-    ohf = File.open(o[:ttab], "w")
-    ohf.puts stats.keys.join("\t")
-    ohf.puts stats.values.join("\t")
-    ohf.close
-  end
-
-  $stderr.puts "Done.\n" unless o[:q] 
-rescue => err
-  $stderr.puts "Exception: #{err}\n\n"
-  err.backtrace.each { |l| $stderr.puts l + "\n" }
-  err
-end
-
-

data/utils/enveomics/Scripts/rbm.rb

@@ -1,146 +0,0 @@
-#!/usr/bin/env ruby
-
-#
-# @author: Luis M. Rodriguez-R
-# @update: Aug-25-2015
-# @license: artistic license 2.0
-#
-
-require 'optparse'
-require 'tmpdir'
-
-o = {len:0, id:0, fract:0, score:0, q:false, bin:"", program:"blast+", thr:1,
-   nucl:false}
-ARGV << "-h" if ARGV.size==0
-OptionParser.new do |opts|
-   opts.banner = "
-Finds the reciprocal best matches between two sets of sequences.
-
-Usage: #{$0} [options]"
-   opts.separator ""
-   opts.separator "Mandatory"
-   opts.on("-1", "--seq1 FILE",
-      "Path to the FastA file containing the set 1."){ |v| o[:seq1] = v }
-   opts.on("-2", "--seq2 FILE",
-      "Path to the FastA file containing the set 2."){ |v| o[:seq2] = v }
-   opts.separator ""
-   opts.separator "Search Options"
-   opts.on("-n", "--nucl",
-      "Sequences are assumed to be nucleotides (proteins by default)."
-      ){ |v| o[:nucl] = true }
-   opts.on("-l", "--len INT",
-      "Minimum alignment length (in residues).  By default: #{o[:len]}."
-      ){ |v| o[:len] = v.to_i }
-   opts.on("-f", "--fract FLOAT",
-      "Minimum alignment length (as a fraction of the query).",
-      "If set, requires BLAST+ or Diamond (see -p).  By default: #{o[:fract]}."
-      ){ |v| o[:fract] = v.to_i }
-   opts.on("-i", "--id NUM",
-      "Minimum alignment identity (in %).  By default: #{o[:id].to_s}."
-      ){ |v| o[:id] = v.to_f }
-   opts.on("-s", "--score NUM",
-      "Minimum alignment score (in bits).  By default: #{o[:score]}."
-      ){ |v| o[:score] = v.to_f }
-   opts.separator ""
-   opts.separator "Software Options"
-   opts.on("-b", "--bin DIR",
-      "Path to the directory containing the binaries of the search program."
-      ){ |v| o[:bin] = v }
-   opts.on("-p", "--program STR",
-      "Search program to be used.  One of: blast+ (default), blast, diamond."
-      ){ |v| o[:program] = v }
-   opts.on("-t", "--threads INT",
-      "Number of parallel threads to be used.  By default: #{o[:thr]}."
-      ){ |v| o[:thr] = v.to_i }
-   opts.separator ""
-   opts.separator "Other Options"
-   opts.on("-q", "--quiet", "Run quietly (no STDERR output)"){ o[:q] = true }
-   opts.on("-h", "--help", "Display this screen") do
-      puts opts
-      exit
-   end
-   opts.separator ""
-end.parse!
-abort "-1 is mandatory" if o[:seq1].nil?
-abort "-2 is mandatory" if o[:seq2].nil?
-abort '-p diamond is incompatible with -n' if o[:program]=='diamond' && o[:nucl]
-abort 'Argument -f/--fract requires -p blast+ or -p diamond' if
-   o[:fract]>0 and o[:program]!='blast+' and o[:program]!='diamond'
-o[:bin] = o[:bin]+"/" if o[:bin].size > 0
-
-Dir.mktmpdir do |dir|
-   $stderr.puts "Temporal directory: #{dir}." unless o[:q]
-
-   # Create databases.
-   $stderr.puts "Creating databases." unless o[:q]
-   [:seq1, :seq2].each do |seq|
-      case o[:program].downcase
-      when 'blast'
-         `"#{o[:bin]}formatdb" -i "#{o[seq]}" -n "#{dir}/#{seq}" \
-	 -p #{(o[:nucl]?"F":"T")}`
-      when 'blast+'
-         `"#{o[:bin]}makeblastdb" -in "#{o[seq]}" -out "#{dir}/#{seq}" \
-	 -dbtype #{(o[:nucl]?"nucl":"prot")}`
-      when 'diamond'
-         `"#{o[:bin]}diamond" makedb --in "#{dir}/#{seq}.fa" \
-         --db "#{dir}/#{seq}.fa.dmnd" --threads "#{o[:thr]}"`
-      else
-         abort "Unsupported program: #{o[:program]}."
-      end
-   end # |seq|
-
-   # Best-hits.
-   rbh = {}
-   n2 = 0
-   $stderr.puts " Running comparisons." unless o[:q]
-   [2,1].each do |i|
-      qry_seen = {}
-      q = o[:"seq#{i}"]
-      s = "#{dir}/seq#{i==1?2:1}"
-      $stderr.puts "  Query: #{q}." unless o[:q]
-      case o[:program].downcase
-      when 'blast'
-	 `"#{o[:bin]}blastall" -p #{o[:nucl]?"blastn":"blastp"} -d "#{s}" \
-	 -i "#{q}" -v 1 -b 1 -a #{o[:thr]} -m 8 -o "#{dir}/#{i}.tab"`
-      when 'blast+'
-	 `"#{o[:bin]}#{o[:nucl]?"blastn":"blastp"}" -db "#{s}" -query "#{q}" \
-	 -max_target_seqs 1 -num_threads #{o[:thr]} -out "#{dir}/#{i}.tab" \
-	 -outfmt "6 qseqid sseqid pident length mismatch gapopen qstart qend \
-	 sstart send evalue bitscore qlen slen"`
-      when 'diamond'
-         `"#{o[:bin]}diamond" blastp --threads "#{o[:thr]}" \
-         --outfmt "6 qseqid sseqid pident length mismatch gapopen qstart qend \
-         sstart send evalue bitscore qlen slen" --db "#{s}.dmnd" \
-         --query "#{q}" --out "#{dir}/#{i}.tab" --more-sensitive`
-      else
-	 abort "Unsupported program: #{o[:program]}."
-      end
-      fh = File.open("#{dir}/#{i}.tab", "r")
-      n = 0
-      fh.each_line do |ln|
-	 ln.chomp!
-	 row = ln.split(/\t/)
-	 row[12] = "1" unless %w[blast+ diamond].include? o[:program]
-	 if qry_seen[ row[0] ].nil? and row[3].to_i >= o[:len] and
-	       row[2].to_f >= o[:id] and row[11].to_f >= o[:score] and
-	       row[3].to_f/row[12].to_i >= o[:fract]
-	    qry_seen[ row[0] ] = 1
-	    n += 1
-	    if i==2
-	       rbh[ row[0] ] = row[1]
-	    else
-	       if !rbh[ row[1] ].nil? and rbh[ row[1] ]==row[0]
-		  puts ln
-		  n2 += 1
-	       end
-	    end
-	 end
-      end # |ln|
-      fh.close()
-      $stderr.puts "    #{n} sequences with hit." unless o[:q]
-   end # |i|
-   $stderr.puts "  #{n2} RBMs." unless o[:q]
-end # |dir|
-
-
-