miga-base 0.3.0.0 → 0.3.0.1

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_rb/enveomics.rb

@@ -0,0 +1,26 @@
+
+#
+# @author: Luis M. Rodriguez-R
+# @update: Oct-21-2015
+# @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.first
+	 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
+

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

@@ -0,0 +1,182 @@
+
+##### CLASSES:
+# Gene.new(genome, id): Initializes a new Gene.
+# genome: A string uniquely identifying the parent genome.
+# id: A string uniquely identifying the gene within the genome. It can be
+#   non-unique across genomes.
+class Gene
+  attr_reader :genome_id, :id
+  @@genomes = []
+  def self.genomes
+    @@genomes
+  end
+  def initialize(genome, id)
+    if genome.is_a? Integer
+      abort "Internal error: Genome #{genome} does not exist yet." if
+        @@genomes[genome].nil?
+      @genome_id = genome
+    else
+      @@genomes << genome unless @@genomes.include? genome
+      @genome_id = @@genomes.index(genome)
+    end
+    @id = id
+  end
+  # Compare if two Gene objects refer to the same gene.
+  def ==(b)
+    self.genome_id==b.genome_id and self.id==b.id
+  end
+  # Get all genomes in the run as an array of strings.
+  def genome
+    @@genomes[self.genome_id]
+  end
+  def to_s
+    "#{self.genome}:#{self.id}"
+  end
+end
+
+# OG.new(): Initializes an empty OG.
+# OG.new(genomes, genes): Initializes a pre-computed OG.
+# genomes: List of genomes as an array of strings (as in Gene.genomes).
+# genes: List of genes as an array of strings, with '-' indicating no genes and
+#   multiple genes separated by ','.
+class OG
+  attr_reader :genes, :notes
+  def initialize(genomes=nil, genes=nil)
+    @genes = []
+    @notes = []
+    unless genomes.nil? or genes.nil?
+      (0 .. genes.length-1).each do |genome_i|
+        next if genes[genome_i]=="-"
+        genes[genome_i].split(/,/).each do |gene_id|
+          self << Gene.new(genomes[genome_i], gene_id)
+        end
+      end
+    end
+  end
+  # Add genes or combine another OG into the loaded OG (self).
+  def <<(obj)
+    if obj.is_a? Gene
+      @genes[obj.genome_id] = [] if @genes[obj.genome_id].nil?
+      @genes[obj.genome_id] << obj.id unless self.include? obj
+    elsif obj.is_a? OG
+      obj.genes_obj.each{ |gene| self << gene }
+    else
+      abort "Unsupported class for #{obj}"
+    end
+  end
+  # Get the list of genes as objects (internally saved as strings to save RAM).
+  def genes_obj
+    o = []
+    (0 .. Gene.genomes.length-1).map do |genome_id|
+      o += self.genes[genome_id].map{ |gene_id|
+        Gene.new(Gene.genomes[genome_id], gene_id) } unless
+          self.genes[genome_id].nil?
+    end
+    return o
+  end
+  # Evaluates if the OG contains the passed gene.
+  def include?(gene)
+    return false if self.genes[gene.genome_id].nil?
+    self.genes[gene.genome_id].include? gene.id
+  end
+  # Get the list of genomes containing genes in this OG.
+  def genomes
+    (0 .. Gene.genomes.length-1).select do |gno|
+      not(self.genes[gno].nil? or self.genes[gno].empty?)
+    end
+  end
+  # Adds a note that will be printed after the last column
+  def add_note note, note_idx=nil
+    if note_idx.nil?
+      @notes << note
+    else
+      @notes[note_idx] = (@notes[note_idx].nil? ? '' :
+        (@notes[note_idx]+' || ')) + note
+    end
+  end
+  def to_s
+    (0 .. Gene.genomes.length-1).map do |genome_id|
+      self.genes[genome_id].nil? ? "-" : self.genes[genome_id].join(",")
+    end.join("\t") + ((self.notes.size==0) ? '' :
+      ("\t#\t"+self.notes.join("\t")))
+  end
+  def to_bool_a
+    (0 .. Gene.genomes.length-1).map { |genome_id| not genes[genome_id].nil? }
+  end
+end
+
+# OGCollection.new(): Initializes an empty collection of OGs.
+class OGCollection
+  attr_reader :ogs, :note_srcs
+  def initialize
+    @ogs = []
+    @note_srcs = []
+  end
+  # Add an OG to the collection
+  def <<(og)
+    @ogs << og
+  end
+  # Compare OGs all-vs-all to identify groups that should be merged.
+  def consolidate!
+    old_ogs = self.ogs
+    @ogs = []
+    old_ogs.each do |og|
+      is_new = true
+      og.genes_obj.each do |gene|
+        o = self.get_og gene
+        unless o.nil?
+          o << og
+          is_new = false
+          break
+        end
+      end
+      self << og if is_new
+    end
+  end
+  # Removes OGs present in less than 'fraction' of the genomes
+  def filter_core!(fraction=1.0)
+    min_genomes = (fraction * Gene.genomes.size).ceil
+    @ogs.select! { |og| og.genomes.size >= min_genomes }
+  end
+  # Removes OGs present more than 'dups' number of times in any genome
+  def remove_inparalogs!(dups=1)
+    @ogs.select! do |og|
+      og.genes.map{ |pergenome| pergenome.size }.max <= dups
+    end
+  end
+  # Add a pair of RBM genes into the corresponding OG, or create a new OG.
+  def add_rbm(a, b)
+    og = self.get_og(a)
+    og = self.get_og(b) if og.nil?
+    if og.nil?
+      og = OG.new
+      @ogs << og
+    end
+    og << a
+    og << b
+  end
+  # Get the OG containing the gene (returns the first, if multiple).
+  def get_og(gene)
+    idx = self.ogs.index { |og| og.include? gene }
+    idx.nil? ? nil : self.ogs[idx]
+  end
+  # Get the genes from a given genome (returns an array of arrays)
+  def get_genome_genes(genome)
+    genome_id = Gene.genomes.index(genome)
+    self.ogs.map do |og|
+      g = og.genes[genome_id]
+      g.nil? ? [] : g
+    end
+  end
+  # Add annotation sources
+  def add_note_src src
+    @note_srcs << src
+  end
+  def to_s
+    Gene.genomes.join("\t") + ((self.note_srcs.length>0) ?
+        ("\t#\t"+self.note_srcs.join("\t")) : '') +
+      "\n" + self.ogs.map{ |og| og.to_s }.join("\n")
+  end
+  def to_bool_a ; ogs.map{ |og| og.to_bool_a } ; end
+end
+