miga-base 1.2.17.0 → 1.2.17.1

data/utils/enveomics/Scripts/HMM.haai.rb

@@ -0,0 +1,168 @@
+#!/usr/bin/env ruby
+
+# @author Luis M. Rodriguez-R <lmrodriguezr at gmail dot com>
+# @license Artistic-2.0
+
+require 'optparse'
+
+o = {q: false}
+ARGV << '-h' if ARGV.size==0
+
+OptionParser.new do |opt|
+  opt.banner = "
+Estimates Average Amino Acid Identity (AAI) from the essential genes extracted
+and aligned by HMM.essential.rb (see --alignments).
+
+Usage: #{$0} [options]"
+  opt.separator ''
+  opt.separator 'Mandatory'
+  opt.on('-1 PATH', 'Input alignments file for genome 1.'){ |v| o[:a] = v }
+  opt.on('-2 PATH', 'Input alignments file for genome 2.'){ |v| o[:b] = v }
+  opt.separator ''
+  opt.separator 'Options'
+  opt.on('-a', '--aln-out FILE',
+    'Output file containing the aligned proteins'){ |v| o[:alnout] = v }
+  opt.on('-c', '--components FILE',
+    'Output file containing the components of the estimation.',
+    'Tab-delimited file with model name, matches, and columns.'
+    ){ |v| o[:compout] = v }
+  opt.on('-q', '--quiet', 'Run quietly (no STDERR output).'){ o[:q] = true }
+  opt.on('-h', '--help', 'Display this screen.') do
+    puts opt
+    exit
+  end
+  opt.separator ''
+end.parse!
+abort '-1 is mandatory.' if o[:a].nil?
+abort '-2 is mandatory.' if o[:b].nil?
+
+class HList
+  attr_accessor :list
+  
+  def initialize(file)
+    @list = {}
+    r = File.readlines(file)
+    while not r.empty?
+      e = HElement.new(*r.shift(3))
+      @list[ e.model_id ] = e
+    end
+  end
+
+  def [](model_id)
+    list[model_id]
+  end
+
+  ##
+  # Returns an array of HAln objects.
+  def align(other)
+    list.keys.map do |model_id|
+      self[model_id].align(other[model_id]) unless other[model_id].nil?
+    end.compact
+  end
+
+  def models
+    list.keys
+  end
+end
+
+class HElement
+  attr_accessor :defline, :model_id, :protein_id, :protein_coords
+  attr_accessor :model_aln, :protein_aln
+
+  def initialize(defline, model_aln, protein_aln)
+    @defline = defline.chomp
+    @model_aln = model_aln.chomp
+    @protein_aln = protein_aln.chomp
+    if defline =~ /^# (.+) : (.+) : (.+)/
+      @model_id = $1
+      @protein_id = $2
+      @protein_coords = $3
+    end
+  end
+
+  def dup
+    HElement.new(defline, model_aln, protein_aln)
+  end
+
+  ##
+  # Returns an HAln object
+  def align(other)
+    return nil unless model_width == other.model_width
+    HAln.new(self, other)
+  end
+
+  def masked_protein
+    @masked_protein ||= model_aln.chars.
+      each_with_index.map{ |c, pos| c == 'X' ? protein_aln[pos] : nil }.
+        compact.join('')
+  end
+
+  def model_width
+    masked_protein.size
+  end
+end
+
+class HAln
+  attr :protein_1, :protein_2, :model_id, :protein_1_id, :protein_2_id
+  
+  def initialize(a, b)
+    @protein_1 = a.masked_protein
+    @protein_2 = b.masked_protein
+    @model_id = a.model_id
+    @protein_1_id = a.protein_id + '/' + a.protein_coords
+    @protein_2_id = b.protein_id + '/' + b.protein_coords
+  end
+
+  def stats
+    @stats = { len: 0, gaps: 0, matches: 0 }
+    return @stats unless @stats[:id].nil?
+    protein_1.chars.each_with_index do |v, k|
+      # Ignore gaps in both proteins
+      next if v == '-' and protein_2[k] == '-'
+      # Count matches
+      @stats[:len] += 1
+      if v == protein_2[k]
+        @stats[:matches] += 1
+      elsif v == '-' or protein_2[k] == '-'
+        @stats[:gaps] += 1
+      end
+    end
+    @stats.tap { |i| i[:id] = 100.0 * i[:matches] / i[:len] }
+  end
+
+  def stats_to_s
+    stats.map{ |k,v| "#{k}:#{v}" }.join ' '
+  end
+
+  def to_s
+    ["# #{model_id} | #{protein_1_id} | #{protein_2_id} | #{stats_to_s}",
+      protein_1, protein_2, ''].join("\n")
+  end
+end
+
+hlist1 = HList.new(o[:a])
+hlist2 = HList.new(o[:b])
+haln_arr = hlist1.align(hlist2)
+
+avg_identity  = haln_arr.map{ |i| i.stats[:id] }.inject(:+) / haln_arr.size
+avg2_identity = haln_arr.map{ |i| i.stats[:id] ** 2 }.inject(:+) / haln_arr.size
+sd_identity   = Math.sqrt( avg2_identity - avg_identity ** 2 )
+puts "Common models: #{haln_arr.size}"
+puts "All models: #{(hlist1.models | hlist1.models).size}"
+puts "Average identity: #{avg_identity.round(2)}%"
+puts "SD identity: #{sd_identity.round(2)}"
+
+if o[:alnout]
+  File.open(o[:alnout], 'w') do |fh|
+    haln_arr.each { |i| fh.puts i }
+  end
+end
+
+if o[:compout]
+  File.open(o[:compout], 'w') do |fh|
+    haln_arr.each do |i|
+      fh.puts "#{i.model_id}\t#{i.stats[:matches]}\t#{i.stats[:len]}"
+    end
+  end
+end
+

data/utils/enveomics/Scripts/HMMsearch.extractIds.rb

@@ -0,0 +1,83 @@
+#!/usr/bin/env ruby
+
+#
+# @author  Luis M. Rodriguez-R <lmrodriguezr at gmail dot com>
+# @update  Dec-01-2015
+# @license artistic 2.0
+#
+
+require "optparse"
+
+o = {quiet:false, model:true}
+
+OptionParser.new do |opts|
+   opts.banner = "
+Extracts the sequence IDs and query model form a (multiple) HMMsearch report
+(for HMMer 3.0).
+
+Usage: #{$0} [options] < input.hmmsearch > list.txt"
+   opts.separator ""
+   opts.separator "Options"
+   opts.on("-E", "--all-evalue FLOAT",
+      "Maximum e-value of sequence to report result."
+      ){|v| o[:all_evalue] = v.to_f }
+   opts.on("-S", "--all-score FLOAT",
+      "Minimum score of sequence to report result."
+      ){|v| o[:all_score] = v.to_f }
+   opts.on("-e", "--best-evalue FLOAT",
+      "Maximum e-value of best domain to report result."
+      ){|v| o[:best_evalue] = v.to_f }
+   opts.on("-s", "--best-score FLOAT",
+      "Minimum score of best domain to report result."
+      ){|v| o[:best_score] = v.to_f }
+   opts.on("-n", "--no-model",
+      "Do not include the query model in the output list."){ o[:model]=false }
+   opts.on("-q", "--quiet", "Run quietly."){ o[:quiet]=true }
+   opts.on("-h", "--help", "Display this screen.") do
+      puts opts
+      exit
+   end
+   opts.separator ""
+end.parse!
+
+at = :header
+query = ""
+i = 0
+ARGF.each_line do |ln|
+   next unless /^(#.*)$/.match(ln).nil?
+   ln.chomp!
+   case at
+   when :header
+      qm = /Query:\s+(.*?)\s+/.match(ln)
+      qm.nil? or query=qm[1]
+      unless /^[\-\s]+$/.match(ln).nil?
+         at = :list
+	 i  = 0
+	 STDERR.print "Parsing hits against #{query}: " unless o[:quiet]
+      end
+   when :list
+      if /^\s*$/.match(ln).nil?
+         next if ln =~ /^\s*-+ inclusion threshold -+$/
+	 ln.gsub!(/#.*/,"")
+	 row = ln.split(/\s+/)
+	 row << nil if row.count==10
+	 raise "Unable to parse seemingly malformed list of hits in line " +
+	    "#{$.}:\n#{ln}" unless row.count==11
+	 good   = true
+	 good &&= ( o[:all_evalue].nil? || row[1].to_f <= o[:all_evalue] )
+	 good &&= ( o[:all_score].nil? || row[2].to_f >= o[:all_score] )
+	 good &&= ( o[:best_evalue].nil? || row[4].to_f <= o[:best_evalue] )
+	 good &&= ( o[:best_score].nil? || row[5].to_f >= o[:best_score] )
+	 if good
+	    puts row[9]+(o[:model]?"\t#{query}":"")
+	    i+=1
+	 end
+      else
+         at = :align
+         STDERR.puts "#{i} results." unless o[:quiet]
+      end
+   when :align
+      at = :header unless /^\/\/$/.match(ln).nil?
+   end
+end
+

data/utils/enveomics/Scripts/JPlace.distances.rb

@@ -0,0 +1,88 @@
+#!/usr/bin/env ruby
+
+#
+# @author: Luis M. Rodriguez-R
+# @update: Jul-14-2015
+# @license: artistic license 2.0
+#
+
+$:.push File.expand_path(File.dirname(__FILE__) + '/lib')
+require 'enveomics_rb/jplace'
+require 'optparse'
+require 'json'
+
+o = {:q=>false}
+ARGV << '-h' if ARGV.size==0
+OptionParser.new do |opts|
+   opts.banner = "
+Extracts the distance (estimated branch length) of each placed read to a given node in a JPlace file.
+
+Usage: #{$0} [options]"
+   opts.separator ""
+   opts.separator "Mandatory"
+   opts.on("-i", "--in FILE", ".jplace input file containing the read placement."){ |v| o[:in]=v }
+   opts.on("-n", "--node STR", "Index (number in curly brackets) of the node to which distances should be measured."){ |v| o[:node]=v }
+   opts.on("-o", "--out FILE", "Ouput file."){ |v| o[:out]=v }
+   opts.separator ""
+   opts.separator "Other Options"
+   opts.on("-N", "--in-node STR","Report only reads placed at this node or it's children."){ |v| o[:onlynode]=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 "-i is mandatory" if o[:in].nil?
+abort "-o is mandatory" if o[:out].nil?
+abort "-n is mandatory" if o[:node].nil?
+
+##### MAIN:
+begin
+   $stderr.puts "Loading jplace file." unless o[:q]
+   ifh = File.open(o[:in], 'r')
+   jplace = JSON.load(ifh)
+   ifh.close
+   
+   $stderr.puts "Parsing tree." unless o[:q]
+   tree = JPlace::Tree.from_nwk(jplace["tree"])
+   node = JPlace::Node.edges[ o[:node].gsub(/[{}]/,"").to_i ]
+   from_node = o[:onlynode].nil? ? tree : JPlace::Node.edges[ o[:onlynode].gsub(/[{}]/,"").to_i ]
+   raise "Cannot find node with index #{o[:node]}." if node.nil?
+   raise "Cannot find node with index #{o[:onlynode]}." if from_node.nil?
+
+   $stderr.puts "Parsing placements." unless o[:q]
+   JPlace::Placement.fields = jplace["fields"]
+   placements_n = 0
+   jplace["placements"].each do |placement|
+      JPlace::Node.link_placement(JPlace::Placement.new(placement))
+      placements_n += 1
+   end
+   $stderr.puts " #{placements_n} placements in tree, #{node.placements.length} direct placements to {#{node.index}}." unless o[:q]
+   
+   # First, calculate distances
+   from_node.pre_order do |n|
+      d = n.distance(node)
+      if node.path_to_root.include? n
+	 n.placements.each{ |p| p.flag = d + p.pendant_length + p.distal_length }
+      else
+	 n.placements.each{ |p| p.flag = d + p.pendant_length - p.distal_length }
+      end
+   end
+   
+   # Finally, report results
+   ofh = File.open(o[:out], "w")
+   ofh.puts %w(read distance multiplicity edge_index node_name).join("\t")
+   from_node.pre_order do |n|
+      n.placements.each do |p|
+	 p.nm.each{ |r| ofh.puts [ r[:n], p.flag, r[:m], n.index, n.name ].join("\t") }
+      end
+   end
+   ofh.close
+rescue => err
+   $stderr.puts "Exception: #{err}\n\n"
+   err.backtrace.each { |l| $stderr.puts l + "\n" }
+   err
+end
+
+

data/utils/enveomics/Scripts/JPlace.to_iToL.rb

@@ -0,0 +1,320 @@
+#!/usr/bin/env ruby
+
+# @author: Luis M. Rodriguez-R
+# @license: artistic license 2.0
+
+$:.push File.expand_path("../lib", __FILE__)
+require "enveomics_rb/enveomics"
+require "enveomics_rb/jplace"
+require "optparse"
+require "json"
+
+o = {q: false, regex: "^(?<dataset>.+?):.*", area: false, norm: :counts,
+  olditol: false}
+ARGV << "-h" if ARGV.size==0
+OptionParser.new do |opts|
+  opts.banner = "
+Generates iToL-compatible files from a .jplace file (produced by RAxML's EPA
+or pplacer), that can be used to draw pie-charts in the nodes of the reference
+tree.
+
+Usage: #{$0} [options]"
+  opts.separator ""
+  opts.separator "Mandatory"
+  opts.on("-i", "--in FILE",
+    ".jplace input file containing the read placement."){ |v| o[:in]=v }
+  opts.on("-o", "--out FILE", "Base of the output files."){ |v| o[:out]=v }
+  opts.separator ""
+  opts.separator "Other Options"
+  opts.on("-u", "--unique STR",
+    "Name of the dataset (if only one is used). Conflicts with -r and -s."
+    ){ |v| o[:unique]=v }
+  opts.on("-r", "--regex STR",
+    "Regular expression capturing the sample ID (named dataset) in read names.",
+    "By default: '#{o[:regex]}'. Conflicts with -s."){ |v| o[:regex]=v }
+  opts.on("-s", "--separator STR",
+    "String separating the dataset name and the rest of the read name.",
+    "It assumes that the read name starts by the dataset name. Conflicts with -r."
+    ){ |v| o[:regex]="^(?<dataset>.+?)#{v}" }
+  opts.on("-m", "--metadata FILE",
+    "Datasets metadata in tab-delimited format with a header row.",
+    "Valid headers: name (required), color (in Hex), size (# reads), norm (any float)."
+    ){ |v| o[:metadata]=v }
+  opts.on("-n", "--norm STR", %w[none counts size norm],
+    "Normalization strategy. Must be one of:",
+    "none: Direct read counts are reported without normalization.",
+    "count (default): The counts are normalized (divided) by the total counts per dataset.",
+    "size: The counts are normalized (divided) by the size column in metadata (must be integer).",
+    "norm: The counts are normalized (divided) by the norm column in metadata (can be any float)."
+    ){ |v| o[:norm]=v.to_sym }
+  opts.on("--old-itol",
+    "Generate output file using the old iToL format (pre v3.0)."
+    ){ |v| o[:olditol] = v }
+  opts.on("-c", "--collapse FILE",
+    "Internal nodes to collapse (requires rootted tree)."){ |v| o[:collapse]=v }
+  opts.on("-a", "--area",
+    "If set, the area of the pies is proportional to the placements. Otherwise, the radius is."
+    ){ o[:area]=true }
+  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 ""
+  opts.separator "Quick how-to in 5 steps"
+  opts.separator "    1. Create the placement file using RAxML's EPA [1] or pplacer [2]. You can use any other software"
+  opts.separator "       producing a compliant .jplace file [3]. If you're using multiple datasets, include the name of"
+  opts.separator "       the dataset somewhere in the read names."
+  opts.separator "    2. If you have multiple datasets, it's convenient to create a metadata table. It's not necessary,"
+  opts.separator "       but it allows you to control the colors and the normalization method (see -m)."
+  opts.separator "    3. Execute this script passing the .jplace file created in step 1 (see -i).  If you have a single"
+  opts.separator "       dataset, use the option -u to give it a short name.  If you have multiple datasets, use the -s"
+  opts.separator "       or -r options to tell the script how to find the dataset name within the read name.  Note that"
+  opts.separator "       some programs (like CheckM) may produce nonstandard characters that won't be correctly parsed."
+  opts.separator "       To avoid this problem,  install iconv support (gem install iconv) before running this script"
+  opts.separator "       (currently "+(JPlace::Tree.has_iconv? ? "" : "NOT ")+"installed)."
+  opts.separator "    4. Upload the tree (.nwk file) to iToL  [4].  Make sure you check 'Keep internal node IDs' in the"
+  opts.separator "       advanced options.  In that same page, upload the dataset (.itol file), pick a name, and select"
+  opts.separator "       the data type 'Multi-value Bar Chart or Pie Chart'. If you used the -c option, upload the list"
+  opts.separator "       of nodes to collapse (.collapse file) in the 'Pre-collapsed clades' field (advanced options)."
+  opts.separator "    5. Open the tree. You can now see the names of the internal nodes. If you want to collapse nodes,"
+  opts.separator "       simply list the nodes to collapse and go back to step 3, this time using the -c option."
+  opts.separator ""
+  opts.separator "References"
+  opts.separator "    [1] SA Berger, D Krompass and A Stamatakis, 2011, Syst Biol 60(3):291-302."
+  opts.separator "        http://sysbio.oxfordjournals.org/content/60/3/291"
+  opts.separator "    [2] FA Matsen, RB Kodner and EV Armbrust, 2010, BMC Bioinf 11:538."
+  opts.separator "        http://www.biomedcentral.com/1471-2105/11/538/"
+  opts.separator "    [3] FA Matsen, NG Hoffman, A Gallagher and A Stamatakis, 2012, PLoS ONE 7(2):e31009."
+  opts.separator "        http://www.plosone.org/article/info%3Adoi%2F10.1371%2Fjournal.pone.0031009"
+  opts.separator "    [4] I Letunic and P Bork, 2011, NAR 39(suppl 2):W475-W478."
+  opts.separator "        http://nar.oxfordjournals.org/content/39/suppl_2/W475.full"
+  opts.separator ""
+end.parse!
+abort "-o is mandatory" if o[:out].nil?
+
+##### CLASSES:
+
+class Dataset
+  attr_reader :name, :data
+  def initialize(name)
+    @name = name
+    @data = {:count=>0}
+  end
+  def count
+    self.datum :count
+  end
+  def add_count(n)
+    @data[:count] += n
+  end
+  def datum(k)
+    @data[k]
+  end
+  def add_datum(k, v)
+    @data[k] = v
+  end
+  def color
+    if @data[:color].nil?
+      @data[:color] = "#" + (1 .. 3).map{ |i|
+        sprintf("%02X", rand(255)) }.join("")
+    end
+    @data[:color].sub(/^#?/, "#")
+    self.datum :color
+  end
+  def size
+    self.datum :size
+  end
+  def norm
+    self.datum :norm
+  end
+end
+
+class Metadata
+  attr_reader :datasets
+  def initialize
+    @datasets = {}
+  end
+  def load_table(file)
+    f = File.open(file, "r")
+    h = f.gets.chomp.split(/\t/)
+    name_idx = h.find_index "name"
+    color_idx = h.find_index "color"
+    size_idx = h.find_index "size"
+    norm_idx = h.find_index "norm"
+    abort "The metadata table must contain a 'name' column." if name_idx.nil?
+    while ln = f.gets
+      vals = ln.chomp.split(/\t/)
+      name = vals[name_idx]
+      self[name] # Create sample, in case "name" is the only column
+      self[name].add_datum(:color, vals[color_idx]) unless color_idx.nil?
+      self[name].add_datum(:size, vals[size_idx].to_i) unless size_idx.nil?
+      self[name].add_datum(:norm, vals[norm_idx].to_f) unless norm_idx.nil?
+    end
+    f.close
+  end
+  def [](name)
+    self << Dataset.new(name) unless @datasets.has_key?(name)
+    @datasets[name]
+  end
+  def <<(dataset)
+    @datasets[dataset.name] = dataset
+  end
+  def names
+    @datasets.keys
+  end
+  def colors
+    @datasets.values.map{ |d| d.color }
+  end
+  def data(k)
+    self.names.map{ |name| self[name].datum[k] }
+  end
+  def set_unique!(n)
+    u = self[n]
+    @datasets = {}
+    @datasets[n] = u
+  end
+  def size
+    self.datasets.length
+  end
+end
+
+##### MAIN:
+begin
+  $stderr.puts "Parsing metadata." unless o[:q]
+  metadata = Metadata.new
+  metadata.load_table(o[:metadata]) unless o[:metadata].nil?
+  metadata.set_unique! o[:unique] unless o[:unique].nil?
+
+
+  $stderr.puts "Loading jplace file." unless o[:q]
+  ifh = File.open(o[:in], 'r')
+  jplace = JSON.load(ifh)
+  ifh.close
+
+
+  $stderr.puts "Parsing tree." unless o[:q]
+  tree = JPlace::Tree.from_nwk(jplace["tree"])
+
+
+  $stderr.puts "Parsing placements." unless o[:q]
+  JPlace::Placement.fields = jplace["fields"]
+  placements_n = 0
+  jplace["placements"].each do |placement|
+    JPlace::Node.link_placement(JPlace::Placement.new(placement))
+    placements_n += 1
+  end
+  $stderr.puts " #{placements_n} placements." unless o[:q]
+  tree.pre_order do |n|
+    n.placements.each do |p|
+      p.nm.each do |r|
+        m = (o[:unique].nil? ? (/#{o[:regex]}/.match(r[:n]) or
+          abort "Cannot parse read name: #{r[:n]}, placed at edge #{n.index}") :
+          {:dataset=>o[:unique]})
+        metadata[ m[:dataset] ].add_count(r[:m])
+      end
+    end
+  end
+
+
+  unless o[:collapse].nil?
+    $stderr.puts "Collapsing nodes." unless o[:q]
+    collapse = File.readlines(o[:collapse]).map do |ln|
+      l = ln.chomp.split(/\t/)
+      l[1] = l[0] if l[1].nil?
+      l
+    end.inject({}) do |hash,ar|
+      hash[ar[0]] = ar[1]
+      hash
+    end
+    f = File.open(o[:out] + ".collapse", "w")
+    coll_n = 0
+    tree.pre_order do |n|
+      if collapse.keys.include? n.cannonical_name
+        n.collapse!
+        n.name = collapse[n.cannonical_name]
+        f.puts n.name
+        coll_n += 1
+      end
+    end
+    f.close
+    $stderr.puts " #{coll_n} nodes collapsed (#{collapse.length} requested)." unless o[:q]
+  end
+   
+
+  $stderr.puts "Estimating normalizing factors by #{o[:norm].to_s}." unless o[:q] or o[:norm]==:none
+  case o[:norm]
+  when :none
+    metadata.datasets.values.each{ |d| d.add_datum :norm, 1.0 }
+  when :counts
+    metadata.datasets.values.each{ |d| d.add_datum :norm, d.count.to_f }
+  when :size
+    abort "Column 'size' required in metadata." if metadata.datasets.values[0].size.nil?
+    metadata.datasets.values.each{ |d| d.add_datum :norm, d.size.to_f }
+  when :norm
+    abort "Column 'norm' required in metadata." if metadata.datasets.values[0].norm.nil?
+  end
+  max_norm = metadata.datasets.values.map{ |d| d.norm }.max
+
+
+  $stderr.puts "Generating iToL dataset." unless o[:q]
+  f = File.open(o[:out] + ".itol.txt", "w")
+  if o[:olditol]
+    f.puts "LABELS\t" + metadata.names.join("\t")
+    f.puts "COLORS\t" + metadata.colors.join("\t")
+  else
+    f.puts "DATASET_PIECHART"
+    f.puts "SEPARATOR TAB"
+    f.puts "DATASET_LABEL\tReadPlacement"
+    f.puts "COLOR\t#1f2122"
+    f.puts "FIELD_LABELS\t" + metadata.names.join("\t")
+    f.puts "FIELD_COLORS\t" + metadata.colors.join("\t")
+    f.puts "DATA"
+  end
+  max_norm_sum,min_norm_sum,max_norm_n,min_norm_n = 0.0,Float::INFINITY,"",""
+  tree.pre_order do |n|
+    ds_counts = Hash.new(0.0)
+    n.placements.each do |p|
+      p.nm.each do |r|
+        m = (o[:unique].nil? ? (/#{o[:regex]}/.match(r[:n]) or
+          abort "Cannot parse read name: #{r[:n]}, placed at edge #{n.index}") :
+          {:dataset=>o[:unique]})
+        ds_counts[ m[:dataset] ] += r[:m] / metadata[ m[:dataset] ].norm
+      end
+    end
+    counts_sum = ds_counts.values.reduce(:+)
+    unless counts_sum.nil?
+      # In the area option, the radius is "twice" to make the smallest > 1 (since counts_sum is >= 1)
+      radius = (o[:area] ? 2*Math.sqrt(counts_sum/Math::PI) : counts_sum)*max_norm
+      f.puts n.cannonical_name +
+        "#{"\t0.5" unless o[:olditol]}\t#{"R" if o[:olditol]}" +
+        radius.to_i.to_s + "\t" +
+        metadata.names.map{ |n| ds_counts[n] }.join("\t")
+      if counts_sum > max_norm_sum
+        max_norm_n = n.cannonical_name
+        max_norm_sum = counts_sum
+      end
+      if counts_sum < min_norm_sum
+        min_norm_n = n.cannonical_name
+        min_norm_sum = counts_sum
+      end
+    end
+  end
+  f.close
+  units = {none: "", counts: " per million placements",
+    size: " per million reads", norm: " per normalizing unit"}
+  $stderr.puts " The pie #{o[:area] ? "areas" : "radii"} are proportional to the placements#{units[o[:norm]]}." unless o[:q]
+  $stderr.puts " The minimum radius (#{min_norm_n}) represents #{min_norm_sum*(([:none, :norm].include? o[:norm]) ? 1 : 1e6)} placements#{units[o[:norm]]}." unless o[:q]
+  $stderr.puts " The maximum radius (#{max_norm_n}) represents #{max_norm_sum*(([:none, :norm].include? o[:norm]) ? 1 : 1e6)} placements#{units[o[:norm]]}." unless o[:q]
+
+
+  $stderr.puts "Re-formatting tree for iToL." unless o[:q]
+  f = File.open(o[:out] + ".nwk", "w")
+  f.puts tree.to_s + ";"
+  f.close
+
+rescue => err
+  $stderr.puts "Exception: #{err}\n\n"
+  err.backtrace.each { |l| $stderr.puts l + "\n" }
+  err
+end
+