miga-base 0.7.26.0 → 0.7.26.1

data/utils/enveomics/Scripts/gi2tax.rb

@@ -0,0 +1,103 @@
+#!/usr/bin/env ruby
+
+#
+# @author  Luis M. Rodriguez-R <lmrodriguezr at gmail dot com>
+# @license artistic license 2.0
+#
+
+$:.push File.expand_path(File.dirname(__FILE__) + "/lib")
+require "enveomics_rb/remote_data"
+use "nokogiri"
+
+#================================[ Options parsing ]
+o = {
+  :q=>false, :gis=>[], :dbfrom=>"nuccore", :header=>true,
+  :exact_gi=>false, :no_nil=>false, :ret=>"ScientificName",
+  :ranks=>%w(superkingdom phylum class order family genus species)}
+OptionParser.new do |opt|
+  opt.banner = "
+  Maps a list of NCBI GIs to their corresponding taxonomy using the NCBI
+  EUtilities. Avoid using this script on millions of entries at a time, since
+  each entry elicits two requests to NCBI's servers.
+
+  *IMPORTANT NOTE*: NCBI is phasing out support for GIs. Please use acc.ver
+  instead with NCBIacc2tax.rb.
+
+  Usage: #{$0} [options]".gsub(/^ +/,"")
+  opt.separator ""
+  opt.on("-g", "--gis GI1,GI2,...", Array,
+    "Comma-separated list of GIs. Required unless -i is passed."
+    ){ |v| o[:gis]=v }
+  opt.on("-i", "--infile FILE",
+    "Raw text file containing the list of GIs, one per line.",
+    "Required unless -g is passed."){ |v| o[:infile]=v }
+  opt.on("-p", "--protein",
+    "Use if the GIs are proteins. Otherwise, GIs are assumed to be from " +
+    "the Nuccore Database."){ o[:dbfrom]="protein" }
+  opt.on("-r", "--ranks RANK1,RANK2,...", Array,
+    "Taxonomic ranks to report. By default: #{o[:ranks].join(",")}."
+    ){ |v| o[:ranks]=v }
+  opt.on("-n", "--noheader",
+    "Do not include a header in the output."){ o[:header]=false }
+  opt.on("-t", "--taxids",
+    "Return Taxonomy IDs instead of scientific names."){ o[:ret]="TaxId" }
+  opt.on("--exact-gi",
+    "Returns only taxonomy associated with the exact GI passed.",
+    "By default, it attempts to update accession versions if possible."
+    ){ |v| o[:exact_gi]=v }
+  opt.on("--ignore-missing",
+    "Does not report missing GIs in the output file.",
+    "By default, it reports GI and empty values for all other columns."
+    ){ |v| o[:no_nil]=v }
+  opt.on("-q", "--quiet", "Run quietly."){ |v| o[:q]=true }
+  opt.on("-h", "--help","Display this screen") do
+    puts opt
+    exit
+  end
+  opt.separator ""
+end.parse!
+
+#================================[ Functions ]
+def gi2taxid(db, gi)
+  doc = Nokogiri::XML( RemoteData.elink({:dbfrom=>db,
+    :db=>"taxonomy", :id=>gi}) )
+  doc.at_xpath("/eLinkResult/LinkSet/LinkSetDb/Link/Id")
+end
+#================================[ Main ]
+begin
+  o[:gis] += File.readlines(o[:infile]).map{ |l| l.chomp } unless
+    o[:infile].nil?
+  o[:ranks].map!{ |r| r.downcase }
+  puts (["GI", "TaxId"] + o[:ranks].map{ |r| r.capitalize }).join("\t") if
+    o[:header]
+  o[:gis].each do |gi|
+    taxid = gi2taxid(o[:dbfrom], gi)
+    status = ""
+    if taxid.nil? and not o[:exact_gi]
+      new_gi, status = RemoteData.update_gi(o[:dbfrom], gi)
+      taxid = gi2taxid(o[:dbfrom], new_gi) unless new_gi.nil?
+    end
+    if taxid.nil?
+      warn "Cannot find link to taxonomy: #{gi} #{status}"
+      puts ([gi, ""] + o[:ranks].map{ |i| "" }).join("\t") unless o[:no_nil]
+      next
+    end
+    taxonomy = {}
+    unless taxid.nil?
+      doc = Nokogiri::XML( RemoteData.efetch({:db=>"taxonomy",
+        :id=>taxid.content}) )
+      taxonomy[ doc.at_xpath("/TaxaSet/Taxon/Rank").content ] =
+        doc.at_xpath("/TaxaSet/Taxon/#{o[:ret]}").content
+      doc.xpath("/TaxaSet/Taxon/LineageEx/Taxon").each do |taxon|
+        taxonomy[ taxon.at_xpath("./Rank").content ] =
+          taxon.at_xpath("./#{o[:ret]}").content
+      end
+    end
+    puts ([gi, taxid.content] +
+      o[:ranks].map{ |rank| taxonomy[ rank ] ||= "" }).join("\t")
+  end
+rescue => err
+  $stderr.puts "Exception: #{err}\n\n"
+  err.backtrace.each { |l| $stderr.puts l + "\n" }
+  err
+end

data/utils/enveomics/Scripts/in_silico_GA_GI.pl

@@ -0,0 +1,96 @@
+# usage perl in_silico_GA.pl [options]
+
+use Getopt::Long;
+use Math::Random qw(:all);
+
+$argu=GetOptions('in=s'=>\$infile, # input fasta chr file
+                 'out=s'=>\$outfile, # output file name
+                 'coverage=s'=>\$cov, # desired output
+                 'seq_error=s'=>\$seq_error, # sequencing error
+                 'read_len=s'=>\$read_len, # simulated read length
+                 'ins_len=s'=>\$ins_len,  # insertion length
+                 'ins_var=s'=>\$ins_var);
+
+$chr='';
+open(IN,$infile);
+open(OUT,">$outfile");
+%code=();
+$code{'0'}='C';
+$code{'1'}='A';
+$code{'2'}='T';
+$code{'3'}='G';
+
+while(<IN>){
+  chomp;
+  if(!/^\>/){
+	$chr.=$_;
+  }
+  else{
+    $gi=$_;
+    if($gi= ~/^\>gi\|(\S+)\|\S+\|\S+/){
+      $gi=$1;}
+
+}
+}
+close(IN);
+  
+$chr_size=length $chr;
+print "chromosome size: $chr_size\n";
+$seg_size=2*$read_len+$ins_len;
+$reads_number=int($cov*$chr_size/($read_len*2));
+print "generated reads $reads_number x 2\n";
+
+for(1..$reads_number){
+  $index=$_;
+  $l=length $index;
+  $k=8-$l;
+  $kk='0' x $k;
+  $id= 'read'.$kk.$index.'_'.$gi;
+
+#make start site;
+  $start_site=int(rand($chr_size));
+#make short seg length;
+  $seg_length=int(random_normal(1,$seg_size,$ins_var));
+
+#extract the segment
+  $seg=substr($chr,$start_site,$seg_length);
+  $s_len=length $seg;
+  $gap=$seg_length-$s_len;
+  if($gap!=0){
+	$makeup=substr($chr,0,$gap);
+	$seg.=$makeup;
+  }
+
+  $id.='.start'.$start_site.'.seg_len'.$seg_length;
+
+#get the reads
+  $seq1=substr($seg,0,$read_len);
+  #$seg=~tr/ATCG/TAGC/ this line can change the orientation of the second read;
+  $seq2=substr($seg,-$read_len);
+# sequencing error introducing
+  @seq1=split(//,$seq1);
+  @seq2=split(//,$seq2);
+  @mut1=random_binomial($read_len,1,$seq_error);
+  @mut2=random_binomial($read_len,1,$seq_error);
+
+  for(0..$#mut1){
+	$i=$_;
+	if($mut1[$i]==1){
+	  $r=int(rand(4));
+	  $seq1[$i]=$code{$r};
+	}
+	if($mut2[$i]==1){
+	  $r=int(rand(4));
+	  $seq2[$i]=$code{$r};
+	}
+  }
+  $seq1=join('',@seq1);
+  $seq2=join('',@seq2);
+
+  $id1=$id.'#0/1';
+  $id2=$id.'#0/2';
+  
+  print OUT ">$id1\n$seq1\n>$id2\n$seq2\n";
+}
+	
+

data/utils/enveomics/Scripts/lib/enveomics.R

@@ -0,0 +1 @@
+../../enveomics.R

data/utils/enveomics/Scripts/lib/enveomics_rb/enveomics.rb

@@ -0,0 +1,24 @@
+
+#
+# @author: Luis M. Rodriguez-R
+# @license: artistic license 2.0
+#
+
+require "optparse"
+ARGV << "-h" if ARGV.size==0
+
+def use(gems, mandatory=true)
+  gems = [gems] unless gems.is_a? Array
+  begin
+    require "rubygems"
+    while ! gems.empty?
+      require gems.shift
+    end
+    return true
+  rescue LoadError
+    abort "\nUnmet requirements, please install required gems:" +
+      gems.map{ |gem| "\n   gem install #{gem}" }.join + "\n\n" if mandatory
+    return false
+  end
+end
+

data/utils/enveomics/Scripts/lib/enveomics_rb/jplace.rb

@@ -0,0 +1,253 @@
+
+#
+# @author: Luis M. Rodriguez-R
+# @update: Jul-14-2015
+# @license: artistic license 2.0
+#
+
+module JPlace
+   ##### CLASSES:
+   # Placement.new(placement[, fields]): Initializes a new read placement.
+   # placement: A hash containing the placement.
+   # fields: If passed, sets the field order for all subsequent placements.
+   class Placement
+      attr_writer :flag # This attribute is used by JPlace.distances.rb as a placeholder
+      attr_reader :p, :n, :m, :flag
+      @@fields = nil
+      def self.fields=(fields)
+	 @@fields=fields
+      end
+      def self.fields
+	 @@fields
+      end
+      def initialize(placement, fields=nil)
+	 @@fields = fields if @@fields.nil? and not fields.nil?
+	 # Save only the best (first) placement:
+	 abort "Placements must contain a 'p' field.\n" if placement["p"].nil?
+	 abort "Placements must contain a 'p' field with at least one entry.\n" if placement["p"][0].nil?
+	 @p = [placement["p"][0]]
+	 # Find name-only placements (EPA-style):
+	 unless placement["n"].nil?
+	    @n = placement["n"]
+	    @m = @n.map{ |n| 1 }
+	 end
+	 # Find multiplicity placements (pplacer-style):
+	 unless placement["nm"].nil?
+	    @n = placement["nm"].map{ |nm| nm[0] }
+	    @m = placement["nm"].map{ |nm| nm[1].to_i }
+	 end
+	 abort "Placements must contain one of 'n' or 'nm' fields.\n" if @n.nil? or @m.nil?
+      end
+      def nm
+	 (0 .. (self.n.length-1)).map{ |i| {:n=>self.n[i], :m=>self.m[i]} }
+      end
+      def get_field_value(field)
+	 abort "Impossible to read placement with undefined fields." if @@fields.nil?
+	 f = @@fields.find_index(field)
+	 abort "Undefined field #{field}." if f.nil?
+	 self.p[0][f]
+      end
+      def set_field_value(field, value)
+	 f = @@fields.find_index(field)
+	 abort "Undefined field #{field}." if f.nil?
+	 self.p[0][f] = value
+      end
+      def edge_num
+	 self.get_field_value('edge_num').to_i
+      end
+      def likelihood
+	 self.get_field_value('likelihood').to_f
+      end
+      def like_weight_ratio
+	 self.get_field_value('like_weight_ratio').to_f
+      end
+      def distal_length
+	 (self.get_field_value('distal_length') || 0).to_f
+      end
+      def pendant_length
+	 (self.get_field_value('pendant_length') || 0).to_f
+      end
+      def to_s
+	 "#<Placement of #{self.n}: #{self.p}>"
+      end
+   end
+
+   # Ancilliary class Tree
+   class Tree
+      @@HAS_ICONV = nil
+      def self.has_iconv?
+	 if @@HAS_ICONV.nil?
+	    @@HAS_ICONV = true
+	    begin
+	       require 'rubygems'
+	       require 'iconv'
+	    rescue LoadError
+	       @@HAS_ICONV = false
+	    end
+	 end
+	 @@HAS_ICONV
+      end
+      def self.from_nwk(nwk)
+	 if Tree.has_iconv?
+	    ic = Iconv.new('UTF-8//IGNORE','UTF-8')
+	    nwk = ic.iconv(nwk + ' ')[0..-2]
+	 end
+	 Node.new(nwk)
+      end
+   end
+   
+   # Node.new(nwk[, parent]): Initializes a new Node.
+   # nwk: Node's description in Newick format.
+   # parent: Node's parent, or nil if root node.
+   class Node
+      # Class
+      @@edges = []
+      def self.edges
+	 @@edges
+      end
+      def self.register(node)
+	 @@edges[node.index] = node unless node.index.nil?
+      end
+      # Class-level functions related to JPlace
+      def self.link_placement(placement)
+	 abort "Trying to link placement in undefined edge #{placement.edge_num}: #{placement.to_s}" if @@edges[placement.edge_num].nil?
+	 @@edges[placement.edge_num].add_placement!(placement)
+      end
+      def self.unlink_placement(placement)
+	 @@edges[placement.edge_num].delete_placement!(placement)
+      end
+      # Instance
+      attr_reader :children, :length, :name, :label, :index, :nwk, :parent, :placements, :collapsed
+      def initialize(nwk, parent=nil)
+	 abort "Empty newick.\n" if nwk.nil? or nwk==''
+	 nwk.gsub! /;(.)/, '--\1'
+	 @nwk = nwk
+	 @parent = parent
+	 @placements = []
+	 @collapsed = false
+	 # Find index
+	 index_m = /^(?<pre>.*){(?<idx>[0-9]+)}(?<post>[^\(\),;]*);?$/.match(nwk)
+	 if index_m.nil? and parent.nil? and nwk[nwk.length-1]==';'
+	    @index = nil
+	 else
+	    abort "Unindexed edge found:\n#{@nwk}\n" if index_m.nil?
+	    nwk = index_m[:pre]+index_m[:post]
+	    @index = index_m[:idx].to_i
+	 end
+	 # Find name, label, and length
+	 meta_m = /^(\((?<cont>.+)\))?(?<name>[^:\(\);]*)(:(?<length>[0-9\.Ee+-]*)(?<label>\[[^\[\]\(\);]+\])?)?;?$/.match(nwk) or
+	    abort "Cannot parse node metadata (index #{@index}):\n#{@nwk}\n"
+	 nwk = meta_m[:cont]
+	 @name = meta_m[:name]
+	 @length = meta_m[:length]
+	 @label = meta_m[:label]
+	 # Find children
+	 @children = []
+	 nwk ||= ''
+	 quote = nil
+	 while nwk != ''
+	    i = 0
+	    j = 0
+	    nwk.each_char do |chr|
+	       if quote.nil?
+		  if chr=='"' or chr=="'"
+		     quote = chr
+		  else
+		     i += 1 if chr=='('
+		     i -= 1 if chr==')'
+		     if i==0 and chr==','
+			i=nil
+			break
+		     end
+		  end
+	       else
+		  quote = nil if chr==quote
+	       end
+	       j += 1
+	    end
+	    abort "Unbalanced node at edge {#{@index}}, with leftness #{i}:\n#{@nwk}\n" unless i.nil? or i==0
+	    @children << Node.new(nwk[0 .. j-1],self)
+	    nwk = nwk.length==j ? '' : nwk[j+1 .. -1]
+	 end
+	 Node.register(self)
+      end
+      # Accessors/Setters
+      def name=(new_name)
+	 @name = new_name.gsub(/[\s\(\),;:]/, '_')
+      end
+      # Tree algorithms
+      def post_order &blk
+	 self.children.each { |n| n.post_order &blk }
+	 blk[self]
+      end
+      def in_order &blk
+	 abort "Tree must be dycotomic to traverse in_order, node #{self.cannonical_name} "+
+	    "has #{self.children.lenght} children." unless [0,2].include? self.children.length
+	 self.children[0].in_order &blk unless self.children[0].nil?
+	 blk[self]
+	 self.children[1].in_order &blk unless self.children[1].nil?
+      end
+      def pre_order &blk
+	 blk[self]
+	 self.children.each { |n| n.pre_order &blk }
+      end
+      def path_to_root
+	 if @path_to_root.nil?
+	    @path_to_root = [self]
+	    @path_to_root += self.parent.path_to_root unless self.parent.nil?
+	 end
+	 @path_to_root
+      end
+      def distance_to_root
+	 if @distance_to_root.nil?
+	    @distance_to_root = path_to_root.map{ |n| n.length.nil? ? 0.0 : n.length.to_f }.reduce(0.0, :+)
+	 end
+	 @distance_to_root
+      end
+      def lca(node)
+	 p1 = self.path_to_root
+	 p2 = node.path_to_root
+	 p1.find{ |n| p2.include? n }
+      end
+      def distance(node)
+	 self.distance_to_root + node.distance_to_root - (2.0 * self.lca(node).distance_to_root)
+      end
+      def ==(node) self.index == node.index ; end
+      # Tree representation
+      def cannonical_name
+	 return(self.name) unless self.name.nil? or self.name == ""
+	 return(self.label) unless self.label.nil? or self.label == ""
+	 return("{#{self.index.to_s}}") unless self.index.nil?
+	 ""
+      end
+      def to_s
+	 o = ""
+	 o += "(" + self.children.map{ |c| c.to_s }.join(",") + ")" if self.children.length > 0
+	 o += self.cannonical_name
+	 u = "#{self.length.nil? ? "" : self.length}#{self.label.nil? ? "" : self.label}"
+	 o += ":#{u}" unless u==""
+	 o
+      end
+      # Instance-level functions related to JPlace
+      def collapse!
+	 self.pre_order do |n|
+	    if n!=self
+	       while n.placements.length > 0
+		  p = Node.unlink_placement(n.placements[0])
+		  p.set_field_value('edge_num', self.index)
+		  Node.link_placement(p)
+	       end
+	    end
+	 end
+	 @collapsed = true
+      end
+      def add_placement!(placement)
+	 @placements << placement
+      end
+      def delete_placement!(placement)
+	 @placements.delete(placement)
+      end
+   end
+
+end # module JPlace
+