miga-base 0.7.23.0 → 0.7.25.3

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

@@ -1,90 +0,0 @@
-#!/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

@@ -1,101 +0,0 @@
-#!/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

@@ -1,97 +0,0 @@
-#!/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

@@ -1,234 +0,0 @@
-#!/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