miga-base 0.7.26.0 → 1.0.0.1

data/utils/enveomics/Scripts/BedGraph.tad.rb

@@ -0,0 +1,93 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+
+o = {range: 0.5, perseq: false, length: false}
+ARGV << '-h' if ARGV.empty?
+OptionParser.new do |opt|
+  opt.banner = "
+  Estimates the truncated average sequencing depth (TAD) from a BedGraph file.
+
+  IMPORTANT: This script doesn't consider zero-coverage positions if missing
+  from the file. If you produce your BedGraph file with bedtools genomecov and
+  want to consider zero-coverage position, be sure to use -bga (not -bg).
+
+  Usage: #{$0} [options]"
+  opt.separator ''
+  opt.on('-i', '--input PATH',
+    'Input BedGraph file (mandatory).'){ |v| o[:i]=v }
+  opt.on('-r', '--range FLOAT',
+    'Central range to consider, between 0 and 1.',
+    "By default: #{o[:range]} (inter-quartile range)."
+    ){ |v| o[:range]=v.to_f }
+  opt.on('-s', '--per-seq',
+    'Calculate averages per reference sequence, not total.',
+    'Assumes a sorted BedGraph file.'
+    ){ |v| o[:perseq] = v }
+  opt.on('-l', '--length',
+    'Add sequence length to the output.'){ |v| o[:length] = v }
+  opt.on('-h', '--help', 'Display this screen.') do
+    puts opt
+    exit
+  end
+  opt.separator ''
+end.parse!
+abort '-i is mandatory.' if o[:i].nil?
+
+def pad(d, idx, r)
+  idx.each do |i|
+    next if d[i].nil?
+    d[i] -= r
+    break unless d[i] < 0
+    r = -d[i]
+    d[i] = nil
+  end
+  d
+end
+
+def report(sq, d, ln, o)
+  # Estimate padding ranges
+  pad = (1.0-o[:range])/2.0
+  r = (pad*ln).round
+
+  # Pad
+  d = pad(d, d.each_index.to_a, r+0)
+  d = pad(d, d.each_index.to_a.reverse, r+0)
+
+  # Average
+  y = [0.0]
+  unless d.compact.empty?
+    s = d.each_with_index.to_a.map{ |v,i| v.nil? ? 0 : i*v }.inject(0,:+)
+    y[0] = s.to_f/d.compact.inject(:+)
+  end
+
+  # Report
+  y.unshift(sq) if o[:perseq]
+  y << ln if o[:length]
+  puts y.join("\t")
+end
+
+# Read BedGraph
+d  = []
+ln = 0
+pre_sq = nil
+File.open(o[:i], "r") do |ifh|
+  ifh.each_line do |i|
+    next if i =~ /^#/
+    r  = i.chomp.split("\t")
+    sq = r.shift
+    if o[:perseq] and !pre_sq.nil? and pre_sq!=sq
+      report(pre_sq, d, ln, o)
+      d  = []
+      ln = 0
+    end
+    r.map! { |j| j.to_i }
+    l = r[1]-r[0]
+    d[ r[2] ] ||= 0
+    d[ r[2] ]  += l
+    ln += l
+    pre_sq = sq
+  end
+end
+report(pre_sq, d, ln, o)
+

data/utils/enveomics/Scripts/BedGraph.window.rb

@@ -0,0 +1,71 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+
+o = {win: 1000}
+ARGV << '-h' if ARGV.empty?
+OptionParser.new do |opt|
+  opt.banner = "
+  Estimates the sequencing depth per windows from a BedGraph file.
+
+  IMPORTANT: This script doesn't consider zero-coverage positions if missing
+  from the file. If you produce your BedGraph file with bedtools genomecov and
+  want to consider zero-coverage position, be sure to use -bga (not -bg).
+
+  Usage: #{$0} [options]"
+  opt.separator ''
+  opt.on('-i', '--input PATH',
+    'Input BedGraph file (mandatory).'){ |v| o[:i]=v }
+  opt.on('-w', '--win INT',
+    'Window size, in base pairs.', "By default: #{o[:win]}."
+    ){ |v| o[:win]=v.to_i }
+  opt.on('-h', '--help', 'Display this screen.') do
+    puts opt
+    exit
+  end
+  opt.separator ''
+end.parse!
+abort '-i is mandatory.' if o[:i].nil?
+
+def report(d, a, b, seqs)
+  # Average
+  y = 0.0
+  unless d.compact.empty?
+    s = d.each_with_index.to_a.map{ |v,i| v.nil? ? 0 : i*v }.inject(0,:+)
+    y = s.to_f/d.compact.inject(:+)
+  end
+
+  # Report
+  puts [a, b, y, seqs.keys.join(",")].join("\t")
+end
+
+# Read BedGraph
+d  = []
+ln = 0
+a = 1
+seqs = {}
+b = o[:win]
+File.open(o[:i], "r") do |ifh|
+  ifh.each_line do |i|
+    next if i =~ /^#/
+    r  = i.chomp.split("\t")
+    sq = r.shift
+    seqs[sq] = 1
+    r.map!{ |j| j.to_i }
+    l = r[1]-r[0]
+    d[ r[2] ] ||= 0
+    d[ r[2] ]  += l
+    ln += l
+    while ln >= b
+      d[ r[2] ] -= (ln-b)
+      report(d, a, b, seqs)
+      seqs = {}
+      seqs[ sq ] = 1 if ln > b
+      d = []
+      d[ r[2] ] = (ln-b)
+      a = b + 1
+      b = a + o[:win] - 1
+    end
+  end
+end
+

data/utils/enveomics/Scripts/BlastPairwise.AAsubs.pl

@@ -0,0 +1,102 @@
+#!/usr/bin/env perl
+# 
+# @authors Konstantinos Konstantinidis (initial version)
+#          modified to work with the BLASTp 2.2.25+ m0 output by
+#          Despina Tsementzi & Luis M. Rodriguez-R
+# @updated Dec-21-2015
+#
+
+
+$/ = "Lambda     ";
+use strict;
+my %hash_depth;
+
+my @query;
+my @subject;
+my @similarity;
+my $length = "0";
+
+my($cigar_chr, $blast) = @ARGV;
+
+($cigar_chr and $blast) or die "
+.Description:
+   Counts the different AA substitutions in the best hit blast alignments, from
+   a BLASTP pairwise format output (-outfmt 0 in BLAST+, -m 0 in legacy BLAST).
+
+.Usage: $0 cigar_char blast.m0.txt > aa-subs.list
+
+   cigar_char    Use '+' for similar substitutions, use '_' for non similar
+                 substitutions
+   blast.m0.txt  Blast in 'text' format (-outfmt/-m 0).
+   aa-subs.list  A tab-delimited raw file with one substitution per row and
+                 columns:
+                 (1) Name-of-query_Name-of-subject
+		 (2) AA-in-subject
+		 (3) AA-in-query
+		 (4) Total-Align-Length
+
+";
+
+# For each blast result (i.e., for each query)
+open BLAST, "<", $blast or die "Cannot read file: $blast: $!\n";
+while(my $data=<BLAST>) {
+   $data =~ s/\r//g;
+   my ($data_q, @array_matches) = split(/>/,$data);
+   my ($name_query) = ($data_q =~ /Query\= (\S+?)(?:_GENE|\s)/);
+   my ($length_query) = ($data_q =~ /\(([\d,]+) letters/ );
+   ($length_query) = ($data_q =~ /Length=([\d,]+)/) unless $length_query;
+   $length_query =~ tr/,//d;
+   
+   # For each alignment (i.e., for each HSP),
+   # note the "last" at the end of the block,
+   # so only the best match is considered
+   foreach my $data_f (@array_matches) {
+      # Capture statistics
+      my ($length_match) = ($data_f =~ /Identities = \d+\/(\d+)/);
+      my ($identity_match) = ($data_f =~ /Identities = \d+\/\d+ \((\d+)%/);
+      my ($target_name) = ($data_f =~ /^\s?(\S+)/);
+
+      # If the alignment meets minimum requirements
+      if ($length_query >30 && ($length_match/$length_query > 0.7) && $identity_match > 60) {
+	 $data_f =~ tr/ /_/;
+	 my @array = split ("\n", $data_f);
+	 my $blanks = 0;
+	 my $prefix_size = 0;
+
+	 # For each line in the alignment
+	 for my $data_fff (@array) {	
+	    if ($data_fff =~ /(Query[:_]_+\d+_+)([^_]+)/){
+	       # Query lines
+	       $prefix_size = length($1);
+	       $length = length($2);
+	       @query = split (//, $2);
+	    }elsif ($data_fff =~ /^_{11}/){
+	       # Cigar lines
+	       @similarity = split(//, substr($data_fff, $prefix_size, $length));
+	    }elsif ($data_fff =~ /Sbjct[:_]_+\d+_+([^_]+)/){
+	       # Subject lines
+	       @subject = split(//, $1);
+	       # For each alignment column
+	       for(my $i=0; $i <= $length; $i++){
+		  if ($similarity[$i] eq $cigar_chr) {
+		     print "$name_query\_$target_name\t$subject[$i]\t$query[$i]\t$length_match\n";
+		  }
+	       }
+	       undef @query;
+	       undef @similarity;
+	       undef @subject; 
+	    }
+	    
+	    # Remove secondary alignments
+	    if ($data_fff =~ /^$/){
+	       $blanks++;
+	       last if $blanks >= 3;
+	    }else{
+	       $blanks=0;
+	    }
+	 } # for my $data_fff (@array)
+      } # if ($length_query >30 ...
+      last; # <---- So it takes only the best match!
+   } # foreach my $data_f (@array_matches)
+} # while(my $data=<>)
+

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

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+
+#
+# @author: Luis M. Rodriguez-R
+# @license: artistic license 2.0
+#
+
+require 'optparse'
+
+o = { sbj: false, q: false }
+ARGV << '-h' if ARGV.size == 0
+OptionParser.new do |opts|
+  opts.banner = "
+Appends an extra column to a BLAST with the length of the query or the subject
+sequence. You can pipe two instances to add both:
+  cat input.blast | #{$0} -f queries.fa | #{$0} -f subjects.fa -s > output.blast
+
+Usage: #{$0} [options] < input.blast > output.blast"
+  opts.separator ''
+  opts.separator 'Mandatory'
+  opts.on('-f', '--fasta FILE', 'Path to the FastA file'){ |v| o[:fasta] = v }
+  opts.separator ''
+  opts.separator 'Options'
+  opts.on('-s', '--subject',
+    'Use the subject column of the BLAST, by default the query column is used'
+    ){ o[:sbj] = 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 ''
+end.parse!
+abort '-f is mandatory' if o[:fasta].nil?
+
+len = {}
+id  = ''
+$stderr.puts "Reading FastA file: #{o[:fasta]}" unless o[:q]
+fh = File.open(o[:fasta], 'r')
+fh.each_line do |ln|
+   defline = /^>(\S+)/.match(ln)
+   if defline.nil?
+      ln.gsub! /[^A-Za-z]/, ''
+      abort 'Error: Unsupported format, expecting FastA' if len[id].nil?
+      len[id] = len[id] + ln.size
+   else
+      id = defline[1]
+      len[id] = 0
+   end
+end
+fh.close
+
+unless o[:q]
+  $stderr.puts 'Appending %s length column' % (o[:sbj] ? 'subject' : 'query')
+end
+ARGF.each_line do |ln|
+  ln.chomp!
+  row = ln.split /\t/
+  id = o[:sbj] ? row[1] : row[0]
+  abort "Impossible to find sequence of #{id}" if len[id].nil?
+  puts "#{ln}\t#{len[id]}"
+end
+

data/utils/enveomics/Scripts/BlastTab.advance.bash

@@ -0,0 +1,48 @@
+#!/bin/bash
+
+#
+# @author  Luis M. Rodriguez-R
+# @update  Mar-23-2016
+# @license artistic license 2.0
+#
+
+if [[ ! $2 ]] ; then
+   echo "
+.DESCRIPTION
+   Calculates the percentage of a partial BLAST result. The
+   value produced slightly subestimates the actual advance,
+   due to un-flushed output and trailing queries that could
+   be processed but generate no results.
+
+.USAGE
+   $0 blast.txt qry.fasta
+
+   blast.txt	Incomplete Tabular BLAST output.
+   qry.fasta	FastA file with query sequences.
+";
+   exit 1;
+fi
+
+if [[ ! -r $1 ]]; then
+   echo "Cannot open file: $1";
+   exit 1;
+fi
+
+if [[ ! -r $2 ]]; then
+   echo "Cannot open file: $2";
+   exit 1;
+fi
+
+LAST_Q=`tail -n 2 $1 | head -n 1 | awk '{print $1}'`
+LAST_Q_NO=`grep -n "^>$LAST_Q\\( \\|$\\)" $2 | sed -e 's/:.*//'`
+if [[ ! $LAST_Q_NO ]]; then
+   echo "Cannot find sequence: $LAST_Q";
+   echo "Make sure you are providing the right query file.";
+   exit 1;
+fi
+TOTAL_Q_NO=`cat $2 | wc -l | sed -e 's/ *//'`
+let PERC=100*$LAST_Q_NO/$TOTAL_Q_NO
+
+echo "$PERC%: $LAST_Q_NO / $TOTAL_Q_NO"
+exit 0;
+

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

@@ -0,0 +1,55 @@
+#!/usr/bin/env perl
+
+#
+# @author: Luis M. Rodriguez-R <lmrodriguezr at gmail dot com>
+# @license: artistic license 2.0
+# @last_update: Mar-23-2015
+#
+
+use strict;
+use warnings;
+
+die "
+Usage:
+   sort blast.txt ... | $0 > blast.bh.txt
+   $0 blast_sorted.txt ... > blast.bh.txt
+   $0 -h|--help|-?
+
+   blast.txt ...	One or more files in Tabular BLAST format.
+   blast_sorted.txt ...	One or more files in Tabular BLAST format pre-sorted.
+   blast.bh.txt		Output file in BLAST format containing best-hits only.
+   -h|--help|-?		Any of these flags trigger this help message and exits.
+
+   NOTE: This script assumes that the BLAST is sorted.  Because it can read
+   from the STDIN, calling this script without arguments cause it to still until
+   killed or until an EOF (^D) is presented.
+
+" if exists $ARGV[0] and $ARGV[0] =~ /^\-?\-(h(elp)?|\?)/i;
+
+my $last_qry = '';
+my @best_res;
+
+sub best_result($$){
+   my($r1, $r2)=@_;
+   return $r1 unless $r2;
+   return $r1->[11] > $r2->[11] ? @$r1 : @$r2;
+}
+
+my $i=0;
+while(<>){
+   chomp;
+   #print STDERR " Reading entry $i...                             \r" unless $i%1000;
+   my @res = split /\t/;
+   die "\nCannot parse BLAST line $.: $_\n" unless exists $res[1];
+   if($last_qry eq $res[0]){
+      @best_res = &best_result(\@res, \@best_res);
+   }else{
+      print join("\t", @best_res), "\n" if $#best_res>0;
+      @best_res = @res;
+      $last_qry = $res[0];
+   }
+}
+print join("\t", @best_res), "\n" if @best_res;
+
+
+

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

@@ -0,0 +1,104 @@
+#!/usr/bin/env perl
+
+# @author: Luis M. Rodriguez-R
+# @license: Artistic-2.0
+
+use warnings;
+use strict;
+use List::Util qw/min max/;
+use Getopt::Std;
+
+sub HELP_MESSAGE { die "
+
+Description:
+  Generates a list of hits from a BLAST result concatenating the subject
+  sequences.  This can be used, e.g., to analyze BLAST results against
+  draft genomes.
+
+Usage:
+  $0 [options] seq.fa map.bls
+
+  seq.fa	Subject sequences (ref) in FastA format.
+  map.bls	Mapping of the reads to the reference in BLAST Tabular
+   		format.
+   
+  Options:
+  -i <float>	Minimum identity to report a result.  By default: 70.
+  -l <int>	Minimum alignment length to report a result.  By default: 60.
+  -s		The FastA provided is to be treated as a subset of the subject.
+   		By default, it expects all the BLAST subjects to be present in
+		the FastA.
+  -q		Run quietly.
+  -h		Display this message and exit.
+   
+  This script creates two files using <map.bls> as prefix with extensions
+  .rec (for the recruitment plot) and .lim (for the limits of the different
+  sequences in <seq.fa>).
+
+";}
+
+my %o;
+getopts('i:l:sqh', \%o);
+my($fa, $map) = @ARGV;
+($fa and $map) or &HELP_MESSAGE;
+$o{h} and &HELP_MESSAGE;
+$o{i} ||= 70;
+$o{l} ||= 60;
+
+my %seq = ();
+my @seq = ();
+my $tot = 0;
+
+SEQ: {
+  print STDERR "== Reading reference sequences\n" unless $o{q};
+  open FA, "<", $fa or die "Cannot read the file: $fa: $!\n";
+  my $cur_seq = '';
+  while(<FA>){
+    chomp;
+    if(m/^>(\S+)/){
+      my $c = $1;
+      $seq{$c} = exists $seq{$cur_seq} ? $seq{$cur_seq}+1 : 1;
+      push @seq, $c;
+      $cur_seq = $c;
+    }else{
+      s/[^A-Za-z]//g;
+      $seq{$cur_seq} += length $_;
+    }
+  }
+  close FA;
+  print STDERR " Found ".(scalar @seq)." sequences.\n" unless $o{q};
+}
+
+open LIM, ">", "$map.lim" or die "Cannot create the file: $map.lim: $!\n";
+my $l = 0;
+for my $s (@seq){
+  print LIM "$s\t".(++$l)."\t$seq{$s}\n";
+  ($l, $seq{$s}) = ($seq{$s}, $l);
+}
+close LIM;
+
+MAP: {
+  print STDERR "== Reading mapping\n" unless $o{q};
+  open BLS, "<", $map or die "Cannot read the file: $map: $!\n";
+  open REC, ">", "$map.rec" or die "Cannot create the file: $map.rec: $!\n";
+  RESULT: while(<BLS>){
+    chomp;
+    my @ln = split /\t/;
+    $ln[11] or die "Cannot parse line $map:$.: $_\n";
+    next unless $ln[3]>=$o{l};
+    next unless $ln[2]>=$o{i};
+    unless(exists $seq{$ln[1]}){
+      die "Cannot find the subject sequence: $ln[1]\n" unless $o{s};
+      next RESULT;
+    }
+    my $start = $seq{$ln[1]}+min($ln[8], $ln[9]);
+    my $end   = $seq{$ln[1]}+max($ln[8], $ln[9]);
+    print REC "$start\t$end\t$ln[2]\t$ln[11]\t$ln[0]",
+          (exists($ln[13])?"\t".($ln[2]*$ln[3]/min($ln[12],$ln[13]))."\t":
+          exists($ln[12])?"\t".($ln[2]*$ln[3]/$ln[12])."\t":""),"\n";
+  }
+  close BLS;
+  close REC;
+  print STDERR " done.\n" unless $o{q};
+}
+