miga-base 0.7.26.0 → 1.0.0.1

data/utils/enveomics/Scripts/BlastTab.taxid2taxrank.pl

@@ -0,0 +1,90 @@
+#!/usr/bin/env perl
+#
+# @author  Luis M. Rodriguez-R <lmrodriguezr at gmail dot com>
+# @license artistic 2.0
+# @update  Oct-13-2015
+#
+
+use warnings;
+use strict;
+
+my($blast, $nodes, $names, $rank, $bh) = @ARGV;
+($blast and $nodes and $names) or die <<HELP
+
+Takes a BLAST with NCBI Taxonomy IDs as subjects and replaces them by names at a
+given taxonomic rank.
+
+Usage:
+   $0 tax_blast.txt nodes.dmp names.dmp[ rank[ best-hit]] > taxrank_blast.txt
+
+   tax_blast.txt	BLAST output, where subject IDs are NCBI Taxonomy IDs.
+   nodes.dmp		Nodes file from NCBI Taxonomy*.
+   names.dmp		Names file from NCBI Taxonomy*.
+   rank			The rank to be reported.  All the reported nodes will
+   			have the same rank.  By default, genus.  To see
+			supported values, run:
+			cut -f 5 nodes.dmp | sort -u
+   best-hit		A word (yes or no) telling the program whether or not it
+   			should take into account the best hit per query only.
+			By default: yes.
+   taxrank_list.txt	BLAST-like output, where subject IDs are Taxonomy names.
+
+   * Download from ftp://ftp.ncbi.nih.gov/pub/taxonomy/taxdump.tar.gz
+
+HELP
+;
+$rank ||= "genus";
+$bh   ||= "yes";
+
+# %nodes structure:
+#   taxid => [parent's taxid, rank, nil, name, name type]
+
+print STDERR "Reading $nodes.\n";
+open NODES, "<", $nodes or die "Cannot read file: $nodes: $!\n";
+my %nodes = map { my @a=split /\t\|\t/; ($a[0] => [$a[1], $a[2]]) } <NODES>;
+close NODES;
+
+print STDERR "Reading $names.\n";
+open NAMES, "<", $names or die "Cannot read file: $names: $!\n";
+while(<NAMES>){
+   my @a=split /\t\|\t/;
+   next if exists $nodes{$a[0]}->[3] and
+      $nodes{$a[0]}->[4] eq "scientific name";
+   next if exists $nodes{$a[0]}->[3] and
+      $a[3] ne "scientific name";
+   $nodes{$a[0]}->[3] = $a[1];
+   $nodes{$a[0]}->[4] = $a[3];
+}
+close NAMES;
+
+my $i     = 0;
+my $nomap = 0;
+my $qry   = "";
+open BLAST, "<", $blast or die "Cannot read file: $blast: $!\n";
+HIT:while(<BLAST>){
+   if(/^#/){
+      print $_;
+      next;
+   }
+   chomp;
+   my @row = split /\t/;
+   next if $bh eq "yes" and $row[0] eq $qry;
+   $i++;
+   print STDERR " Mapping hit $i\r" unless $i%10;
+   exists $nodes{$row[1]} or die "Cannot find Taxonomy node: $row[1].\n";
+   my $n = $nodes{$row[1]};
+   while($n->[1] ne $rank){
+      if($n->[0] eq $nodes{$n->[0]}->[0]){
+	 $nomap++;
+	 next HIT;
+      }
+      $n = $nodes{$n->[0]};
+   }
+   $row[1] = $n->[3];
+   print "".join("\t", @row)."\n";
+}
+close BLAST;
+print STDERR " Mapped $i hits\n";
+print STDERR
+   " WARNING: $nomap hits above rank or in a lineage without rank.\n" if $nomap;
+

data/utils/enveomics/Scripts/BlastTab.topHits_sorted.rb

@@ -0,0 +1,101 @@
+#!/usr/bin/env ruby
+
+#
+# @author:  Luis M. Rodriguez-R <lmrodriguezr at gmail dot com>
+# @update:  Dec-11-2015
+# @license: artistic license 2.0
+#
+
+require "optparse"
+
+$opts = {n:5, sortby:"bitscore", q:false}
+$cols = {"bitscore"=>11, "evalue"=>10, "identity"=>2, "length"=>3}
+ARGV << "-h" if ARGV.size==0
+OptionParser.new do |opts|
+   opts.banner = "Reports the top-N best hits of a BLAST, pre-sorted by query."
+   opts.separator ""
+   opts.separator "Mandatory"
+   opts.on("-i", "--blast FILE",
+      "Path to the BLAST file."){ |v| $opts[:blast]=v }
+   opts.separator ""
+   opts.separator "Optional"
+   opts.on("-n", "--top INTEGER",
+      "Maximum number of hits to report for each query.",
+      "By default: #{$opts[:n]}"){ |v| $opts[:n]=v.to_i }
+   opts.on("-s", "--sort-by STRING",
+      "Parameter used to detect the 'best' hits.",
+      "Any of: bitscore (default), evalue, identity, length."
+      ){ |v| $opts[:sortby]=v }
+   opts.on("-q", "--quiet", "Run quietly."){ $opts[:q]=true }
+   opts.on("-h", "--help", "Display this screen") do
+      puts opts
+      exit
+   end
+   opts.separator ""
+end.parse!
+
+abort "-i/--blast is mandatory." if $opts[:blast].nil?
+abort "Unrecognized value for -s/--sortby: #{$opts[:sortby]}." if
+   $cols[ $opts[:sortby] ].nil?
+
+class Hit
+   attr_reader :blast_line
+   def initialize(blast_line)
+      @blast_line = blast_line.chomp.split(/\t/)
+   end
+   def col(i)
+      @blast_line[i]
+   end
+   def <=>(other)
+      ans = self.col( $cols[ $opts[:sortby] ] ).to_f <=> other.col( $cols[ $opts[:sortby] ] ).to_f
+      ans = ans * -1 unless $opts[:sortby] == "evalue"
+      return ans
+   end
+   def to_s
+      @blast_line.join("\t")
+   end
+end
+
+class HitSet
+   attr_reader :query, :hits
+   def initialize
+      @hits = []
+      @query = nil
+   end
+   def <<(hit)
+      @query = hit.col(0) if @query.nil?
+      raise "Inconsistent query, expecting #{self.query}" unless
+	 self.query == hit.col(0)
+      @hits << hit
+   end
+   def empty?
+      self.hits.length == 0
+   end
+   def filter!
+      @hits.sort!
+      @hits.slice!($opts[:n], @hits.length)
+   end
+   def to_s
+      @hits.join("\n")
+   end
+end
+
+$stderr.puts "Parsing BLAST." unless $opts[:q]
+fh = File.open $opts[:blast], "r"
+hs = HitSet.new
+while ln=fh.gets
+   hit = Hit.new( ln )
+   if hs.query != hit.col(0)
+      hs.filter!
+      puts hs unless hs.empty?
+      hs = HitSet.new
+      $stderr.print "Parsing line #{$.}... \r" unless $opts[:q]
+   end
+   hs << hit
+end
+$stderr.print "Parsed #{$.} lines.   \n" unless $opts[:q]
+fh.close
+
+hs.filter!
+puts hs unless hs.empty?
+

data/utils/enveomics/Scripts/Chao1.pl

@@ -0,0 +1,97 @@
+#!/usr/bin/env perl
+#
+# @author  Luis M. Rodriguez-R <lmrodriguezr at gmail dot com>
+# @license artistic license 2.0
+# @update  Dec-29-2015
+#
+
+use warnings;
+use strict;
+use Getopt::Std;
+use List::Util qw/min max/;
+
+sub VERSION_MESSAGE(){print "Home-made Chao1 (enveomics)\n"}
+sub HELP_MESSAGE(){die "
+Description:
+   Takes a table of OTU abundance in one or more samples and calculates the
+   chao1 index (with 95% Confidence Interval) for each sample.  To use it with
+   Qiime OTU Tables, run it as:
+   $0 -i OTU_Table.txt -c 1 -h
+
+Usage:
+   $0 [opts]
+
+   -i <str>	* Input table (columns:samples, rows:OTUs).
+   -r <int>	Number of rows to ignore.  By default: 0.
+   -c <int>	Number of columns to ignore.  By default: 0.
+   -C <int>	Number of columns to ignore at the end. By default: 0.
+   -d <str>	Delimiter.  Supported escaped characters are: \"\\t\"
+		(tabulation), and \"\\0\" (null bit).  By default: \"\\t\".
+   -h		If set, the first row is assumed to have the names of the
+		samples.
+   --help	This help message.
+
+   * Mandatory.
+
+To improve:
+   o Account for n1==0 and n2==0 cases.  See http://www.mothur.org/wiki/Chao.
+
+"}
+
+my %o;
+getopts('i:c:C:r:d:h', \%o);
+
+&HELP_MESSAGE() unless $o{i};
+$o{c} ||= 0;
+$o{C} ||= 0;
+$o{r} ||= 0;
+$o{d} ||= "\\t";
+
+$o{d}="\t" if $o{d} eq "\\t";
+$o{d}="\0" if $o{d} eq "\\0";
+
+my @names = ();
+my @values = ();
+open TABLE, "<", $o{i} or die "Cannot open file: ".$o{i}.": $!\n";
+<TABLE> for (1 .. $o{r});
+if($o{h}){
+   my $h = <TABLE>;
+   $h or die "Empty table!\n";
+   chomp $h;
+   @names = split $o{d}, $h;
+   shift @names for (1 .. $o{c});
+   pop @names for (1 .. $o{C});
+}
+while(<TABLE>){
+   chomp;
+   my @ln = split $o{d};
+   shift @ln for (1 .. $o{c});
+   pop @ln for (1 .. $o{C});
+   push @{$values[$_] ||= []}, $ln[$_] for (0 .. $#ln);
+}
+close TABLE;
+
+print "Sample\tObs\tChao1\tChao1_LB\tChao1_UL\n";
+for my $i (0 .. $#values){
+   print "".(exists $names[$i] ? $names[$i] : $i).$o{d};
+   my $n1=0;
+   my $n2=0;
+   my $ob=0;
+   for my $v (@{$values[$i]}){
+      $n1++ if $v==1;
+      $n2++ if $v==2;
+      $ob++ if $v>=1;
+   }
+   if($ob and $n1 and $n2){
+      my $m   = $n1/$n2;
+      my $ch  = $ob + (($n1**2)/(2*$n2));
+      my $var = ($n2*((($m**4)/4) + ($m**3) + (($m**2)/2)));
+      my $c   = exp(1.96*sqrt(log(1+ $var/(($ch-$ob)**2))));
+      my $lc  = max($ob + ($ch-$ob)/$c, $ob);
+      my $uc  = $ob + $c*($ch-$ob);
+      print "".join($o{d}, $ob, $ch, $lc, $uc)."\n"
+   }else{
+      print "".join($o{d}, $ob, $ob, 0, 0)."\n"
+   }
+}
+

data/utils/enveomics/Scripts/CharTable.classify.rb

@@ -0,0 +1,234 @@
+#!/usr/bin/env ruby
+
+#
+# @author  Luis M. Rodriguez-R
+# @update  Jan-13-2016
+# @license artistic license 2.0
+#
+
+require "optparse"
+
+o = {:q=>false}
+ARGV << "-h" if ARGV.size==0
+OptionParser.new do |opts|
+   opts.banner = "
+Uses a dichotomous key to classify objects parsing a character table.
+
+Usage: #{$0} [options]"
+   opts.separator ""
+   opts.separator "Input Options (mandatory)"
+   opts.on("-t", "--table FILE",
+      "Input table containing the states (columns) per object (row).",
+      "It must be tab-delimited and with row and column names.",
+      "See Tests/anthrax-cansnp-data.tsv for an example."){ |v| o[:table]=v }
+   opts.on("-k", "--key FILE",
+      "Input table containing the dychotomous key in linked style, defined in",
+      "four columns (can contain #-lead comment lines):",
+      "  1. ID of the step, typically a sequential integer.",
+      "  2. Name of character to evaluate. Must coincide with the -t headers.",
+      "  3. First character decision (see below).",
+      "  4. Second character decision (see below).",
+      "A character decision must be formated as: state (must coincide with the",
+      "values in -t), colon (:), step to follow. If the state is * (star) any",
+      "state triggers the decision (this should be the norm in column 4). The",
+      "step to follow should be a step ID in square brackets, or the name of",
+      "the classification. See Tests/anthrax-cansnp-key.tsv for an example."
+      ){ |v| o[:key]=v }
+   opts.separator ""
+   opts.separator "Output Options"
+   opts.on("-c", "--classification FILE",
+      "Two-column table with the classification of the input objects."
+      ){ |v| o[:class]=v }
+   opts.on("-n", "--newick FILE",
+      "Tree containing all the classified objects. This only makes sense for",
+      "synoptic keys."){ |v| o[:nwk]=v }
+   opts.separator ""
+   opts.separator "Additional 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 "-t is mandatory" if o[:table].nil?
+abort "-k is mandatory" if o[:key].nil?
+
+##### Extensions:
+class String
+   def nwk_sanitize() self.gsub(/[\(\):;,"'\s]/,'_') ; end
+end
+
+##### Classes:
+module Dychotomous
+   class Decision
+      attr_reader :state, :terminal, :conclusion
+      def initialize(string)
+	 r = string.split /:/
+	 @state = r[0]
+	 @terminal = !(r[1] =~ /^\[(.*)\]$/)
+	 @conclusion = @terminal ? r[1] : $1
+      end
+      def ==(state)
+         return true if self.state == '*'
+	 self.state == state.to_s
+      end
+   end
+   class Character
+      attr_reader :name, :a, :b
+      def initialize(name, a, b)
+	 @name = name
+	 @a = a
+	 @b = b
+      end
+      def eval(object)
+	 state = object.state(self.name)
+	 return self.a if self.a == state
+	 return self.b if self.b == state
+	 raise "Impossible to make a decision for #{object.name} based on " +
+	    "character #{self.name}. Offending state: #{state.to_s}."
+      end
+   end
+   class Key
+      attr_reader :first
+      def initialize(file)
+	 @characters = {}
+	 fh = File.open(file, 'r')
+	 while ln = fh.gets
+	    next if ln=~/^#/ or ln=~/^\s*$/
+	    r = ln.chomp.split /\t/
+	    @characters[ r[0] ] = Character.new(r[1],
+	       Decision.new(r[2]), Decision.new(r[3]))
+	    @first = @characters[ r[0] ] if @first.nil?
+	 end
+	 fh.close
+      end
+      def [](name)
+	 raise "Cannot find character #{name} in key." if @characters[name].nil?
+	 @characters[name]
+      end
+   end
+end
+module CharData
+   class Object
+      attr_reader :name, :states
+      def initialize(name)
+	 @name = name
+	 @states = {}
+      end
+      def <<(state) @states[state.character] = state ; end
+      def state(name) @states[name] ; end
+   end
+   class State
+      attr_reader :character, :state
+      def initialize(character, state)
+	 @character = character
+	 @state = state
+      end
+      def to_s() self.state.to_s ; end
+   end
+   class Table
+      attr_reader :objects
+      def initialize(file)
+	 @objects = []
+	 fh = File.open(file, 'r')
+	 header = fh.gets.chomp.split(/\t/)
+	 while ln = fh.gets
+	    next if ln=~/^#/ or ln=~/^\s*$/
+	    r = ln.chomp.split /\t/
+	    o = Object.new(r[0])
+	    (1 .. r.size).each{ |i| o << State.new(header[i], r[i]) }
+	    self << o
+	 end
+	 fh.close
+      end
+      def <<(object) @objects << object ; end
+   end
+end
+module ClassData
+   class Classification
+      attr_reader :key, :object, :result
+      def initialize key, object
+	 @key = key
+	 @object = object
+	 self.classify!
+      end
+      def classify!
+	 @result = self.key.first.eval(object)
+	 while ! self.result.terminal
+	    @result = self.key[ self.result.conclusion ].eval(object)
+	 end
+      end
+   end
+   class Collection
+      attr_reader :key, :table, :classifications
+      def initialize(key, table)
+	 @key = key
+	 @table = table
+	 @classifications = []
+	 self.classify!
+      end
+      def classify!
+	 table.objects.each do |object|
+	    @classifications << Classification.new(key, object)
+	 end
+      end
+      def classified_as(conclusion)
+         self.classifications.select{ |c|
+	    c.result.conclusion==conclusion }.map{ |c| c.object }
+      end
+      def to_nwk
+	 self.to_nwk_node(self.key.first) + ";"
+      end
+      def to_nwk_node(node)
+	 if node.is_a? Dychotomous::Character
+	    a = self.to_nwk_node(node.a)
+	    b = self.to_nwk_node(node.b)
+	    return "" if (a + b)==""
+	    return "(" + a + b + ")#{node.name.nwk_sanitize}" if a=="" or b==""
+	    return "(" + self.to_nwk_node(node.a) + "," +
+	       self.to_nwk_node(node.b) + ")#{node.name.nwk_sanitize}"
+	 end
+	 if node.is_a? Dychotomous::Decision and node.terminal
+	    objects = self.classified_as(node.conclusion)
+	    return '' if objects.empty?
+	    return objects[0].name.nwk_sanitize if objects.size==1
+	    return "(" + objects.map{|o| o.name.nwk_sanitize}.join(",") + ")"
+	 end
+	 return self.to_nwk_node( self.key[node.conclusion] ) if
+	    node.is_a? Dychotomous::Decision
+	 raise "Unsupported class: to_nwk_node: #{node}."
+      end
+   end
+end
+
+##### MAIN:
+begin
+   $stderr.puts "Reading dychotomous key." unless o[:q]
+   key = Dychotomous::Key.new(o[:key])
+   $stderr.puts "Reading character table." unless o[:q]
+   table = CharData::Table.new(o[:table])
+   $stderr.puts "Classifying objects." unless o[:q]
+   classif = ClassData::Collection.new(key, table)
+   
+   unless o[:class].nil?
+      $stderr.puts "Generating classification table." unless o[:q]
+      fh = File.open(o[:class], 'w')
+      classif.classifications.each do |c|
+         fh.puts c.object.name + "\t" + c.result.conclusion
+      end
+      fh.close
+   end
+
+   unless o[:nwk].nil?
+      $stderr.puts "Generating classification tree." unless o[:q]
+      fh = File.open(o[:nwk], 'w')
+      fh.puts classif.to_nwk
+      fh.close
+   end
+   
+rescue => err
+   $stderr.puts "Exception: #{err}\n\n"
+   err.backtrace.each { |l| $stderr.puts l + "\n" }
+   err
+end