bio-samtools-wrapper 2.7.0

data/lib/bio/db/fastadb.rb

@@ -0,0 +1,320 @@
+#Module to hold the information about the fasta file
+
+module Bio::DB::Fasta
+  #This class contains the entries in a fasta, as generated by samtools faidx
+  class Index
+    include Enumerable
+    attr_reader :entries
+
+    def initialize
+      @entries=[]
+      @entries_map = Hash.new
+    end
+
+    #This doesnt validate if you are adding the same entry twice. I may add
+    #a validation for that. 
+    def <<(entry)
+      @entries << entry
+      @entries_map[entry.id] = entry
+    end
+
+    def each(&block)
+      @entries.entries(&block)
+    end  
+    #Total number of entries
+    def length
+      @entries.length
+    end
+    alias_method :size, :length
+
+    #Returns a new Index just with the specified range, as if it was an Array. 
+    #The return object is of type Index. 
+    def [](args)
+      tmp = @entries[args]
+      @new_index = Index.new
+      tmp.each do | entry |
+        @new_index << entry
+      end       
+    end
+
+    #Gets the Region object for the full length of the sequence 
+    #name queried.
+    def region_for_entry(entry)
+      @entries_map[entry]
+    end
+  end
+
+  class Entry
+    attr_reader :id, :length, :line_bases, :line_length, :offset
+    alias_method :size, :length
+    def initialize(id, length, offset = 0 , line_bases= 0 , line_length = 0 )
+      @id=id
+      @length=length.to_i
+      @offset = offset.to_i
+      @line_bases  = line_bases.to_i
+      @line_length = line_length.to_i
+    end
+
+    def get_base_coordinate(coordinate)
+      lines_for_offset = coordinate / line_bases
+      line_offset = coordinate % line_bases
+      #puts "get_base_coordinate"
+      #puts "Coordinate: #{coordinate}"
+      #puts "lines_for_offset: #{lines_for_offset}"
+      #puts "line pffset: #{line_offset}"
+      #puts self.inspect
+      pointer = offset + (line_length * lines_for_offset) + line_offset - 1
+      pointer
+    end
+
+    def get_full_region
+      reg = Region.new
+      reg.entry = id
+      reg.start = 1
+      reg.end = @length
+      reg.orientation = :forward
+      reg
+    end
+
+    alias_method  :to_region, :get_full_region
+
+  end
+
+  #Class to wrap a region of a chromosome
+  class Region
+    BASE_COUNT_ZERO =  {:A => 0, :C => 0, :G => 0,  :T => 0}
+    attr_accessor :entry, :start, :end, :orientation
+
+    attr_accessor :pileup, :average_coverage, :snps, :reference, :allele_freq, :consensus, :coverages, :bases, :total_cov, :called
+  
+    def initialize(args ={})
+      @entry = args[:entry]
+      @start = args[:start]
+      @end = args[:end]
+      @orientation = args[:orientation]
+    end
+  
+    #TODO: Debug, as it hasnt been tested in the actual code. 
+    def allele_freq_for_base(base)
+      @all_ratios = Hash.new unless @all_ratios
+      unless @all_ratios[base]
+        ratios = Array.new
+        for i in (0..region.size-1)
+          ratios << @allele_freq[i][base]
+        end
+        @all_ratios[base] = ratios
+      end
+      @all_ratios[base]
+    end
+
+    alias_method :base_ratios_for_base, :allele_freq_for_base
+    alias_method :base_ratios, :allele_freq
+
+    #Calculates the concensus, base ratios, coverages and total coverages in the region
+    #* min_cov minimum coverage to make a call (default 0)
+    #* min_per minimum representation to make make a call. If more than one base 
+    #  can be called, the IUAPC ambiguity code is returned
+    def calculate_stats_from_pile(opts={})
+      min_cov = opts[:min_cov] ? opts[:min_cov] : 0
+      min_per =  opts[:min_per] ? opts[:min_per] : 0.20
+      self.called = 0
+      reference = self.reference.downcase
+
+      self.allele_freq = Array.new(self.size, BASE_COUNT_ZERO) 
+      self.bases = Array.new(self.size, BASE_COUNT_ZERO) 
+      self.coverages = Array.new(self.size, 0)
+      self.total_cov = 0
+
+      self.pileup.each do | pile |
+
+        if pile.coverage > min_cov
+          self.allele_freq[pile.pos - self.start ] = pile.allele_freq
+          reference[pile.pos - self.start   ] = pile.consensus_iuap(min_per).upcase
+          self.coverages[pile.pos - self.start   ]  = pile.coverage.to_i
+          self.bases[pile.pos - self.start       ]  = pile.bases
+          self.called += 1 
+        end
+        #puts "#{pile.pos}\t#{bef}\t#{reference[pile.pos - region.start  - 1 ]} "
+        self.total_cov += pile.coverage
+      end
+
+      self.consensus = Bio::Sequence.new(reference)
+      self.consensus.na
+      if self.orientation == :reverse
+        self.consensus.reverse_complement!()
+      end
+      self.average_coverage = self.total_cov.to_f/self.size.to_f
+      self
+    end
+
+    def to_s
+      string = @entry + ":" + @start.to_s + "-" + @end.to_s 
+      string
+    end
+
+    #Returns a region object from a string in form "name:start-end"
+    def self.parse_region(reg_str)
+      string = reg_str.delete("'")
+      fields_1 = string.split(":")
+      raise FastaDBException.new(), "Invalid region. #{string}" if fields_1.length != 2
+      fields_2 = fields_1[1].split("-")
+      raise FastaDBException.new(), "Invalid region. #{string}" if fields_2.length != 2
+
+      reg = Region.new(:entry=> fields_1[0], :start=>fields_2[0].to_i, :end=>fields_2[1].to_i)
+
+      if reg.end < reg.start 
+        reg.orientation = :reverse
+      else
+        reg.orientation = :forward
+      end
+      reg
+    end
+
+    #Length of the region
+    def size
+      @end - @start
+    end
+    alias_method :length, :size
+
+  end
+
+  class FastaDBException < StandardError; end
+
+  #Class that holds the fasta file. It is used as a database. 
+  class FastaFile
+    attr_reader :fasta_path
+
+    #Initialize the fasta file. If the fai file doesn't exists, it is generated at startup
+    #* fasta path to the fasta file
+    #* samtools path to samtools, if it is not provided, use the bundled version
+    def initialize(fasta: nil, samtools: false)
+      #puts "The arguments are: '#{fasta}':'#{samtools}'"
+      @fasta_path = fasta
+      @samtools = samtools  
+      @index = nil
+      @fasta_file = nil
+      @samtools = File.join(File.expand_path(File.dirname(__FILE__)),'sam','external','samtools') if samtools == true
+      raise FastaDBException.new(), "No path for the refernce fasta file. " if @fasta_path.nil?
+      @fai_file = @fasta_path + ".fai" 
+      unless File.file?(@fai_file) then
+        command = "#{@samtools} faidx '#{@fasta_path}'"
+        @last_command = command
+        system(command)
+      end
+    end
+
+    #Loads the fai entries 
+    def load_fai_entries()
+      return  @index.length if @index
+      @index = Index.new
+      fai_file = @fai_file
+      File.open(fai_file).each do | line |
+        fields = line.split("\t")
+        @index << Entry.new(fields[0], fields[1], fields[2], fields[3], fields[4])
+      end     
+      @index.length
+    end
+
+
+
+    #Index reference sequence in the FASTA format or extract subsequence from indexed reference sequence. If no region is specified, faidx will index the file and create <ref.fasta>.fai on the disk. If regions are speficified, the subsequences will be retrieved and printed to stdout in the FASTA format.
+    #Options - if a subsequence is required
+    #* chr - [STRING] the reference name of the subsequence
+    #* start - [INT] the start position for the subsequence
+    #* stop - [INT] the stop position for the subsequence
+    def faidx(opts={})
+      if opts.has_key?(:chr) and opts.has_key?(:start) and opts.has_key?(:stop)
+        opts={:as_bio => false}
+        self.fetch_reference(:chr,:start,:stop,opts)
+      else
+        command = "#{@samtools} faidx #{@fasta_path}"
+        @last_command = command
+        system(command)
+      end
+    end
+
+    def index
+      return @index if @index
+      if @samtools
+        faidx
+      else
+        samtools = File.join(File.expand_path(File.dirname(__FILE__)),'sam','external','samtools')
+        #TODO: make a ruby implementations 
+        command = "#{samtools} faidx #{@fasta_path}"
+        @last_command = command
+        system(command)
+      end
+        load_fai_entries
+      return @index
+    end
+
+    def fetch_sequence_samtools(region)
+      query = region.to_s
+      query = region.to_region.to_s if region.respond_to?(:to_region) 
+      command = "#{@samtools} faidx #{@fasta_path} '#{query}'"
+      puts "Running: #{command}"  if $DEBUG
+      @last_command = command
+      seq = ""
+      yield_from_pipe(command, String, :text ) {|line| seq = seq + line unless line =~ /^>/}
+      seq
+    end
+
+    def fetch_sequence_native(region)
+      query = region
+      query = Region.parse_region(region) unless region.is_a?(Region) 
+      seq = ""
+      #In order to make this reentrant, if we want to make a multithreaded
+      #version of this function, we need to get a lock. Currently, only one thred
+      #can be assosiated with eache fastadb object
+      @fasta_file = File.open(@fasta_path) unless @fasta_file
+      entry = index.region_for_entry(query.entry)
+     
+      start_pointer  =  entry.get_base_coordinate(query.start)
+      @fasta_file.seek(start_pointer, IO::SEEK_SET)
+      end_pointer  =  entry.get_base_coordinate(query.end)
+      to_read = end_pointer - start_pointer + 1
+      seq = @fasta_file.read(to_read)
+      seq.gsub!(/\s+/, '')
+      seq 
+    end
+
+    #The region needs to have a method to_region or a method to_s that ha the format "chromosome:start-end" as in samtools
+    def fetch_sequence(region)
+      load_fai_entries
+      region = Region.parse_region(region.to_s) unless region.is_a?(Region) 
+      entry = index.region_for_entry(region.entry)
+      raise FastaDBException.new "Entry (#{region.entry})not found in reference" unless entry
+      raise FastaDBException.new "Region in invalid range (#{region}): Valid range: #{entry.to_region.to_s} has a size of #{entry.size}." if region.end > entry.size or region.start < 1
+      seq = @samtools ?  fetch_sequence_samtools(region): fetch_sequence_native(region)
+      reference = Bio::Sequence::NA.new(seq)
+      if region.respond_to? :orientation and region.orientation == :reverse
+        reference.reverse_complement!()
+      end
+      reference
+    end
+
+    private
+    #Returns Process::Status with the execution status. If run in a $DEBUG environment, stderr of the process
+    #is forwarded to the default stdout
+    def yield_from_pipe(command, klass, type=:text, skip_comments=true, comment_char="#", &block)
+      stdin, pipe, stderr, wait_thr = Open3.popen3(command)
+      #pid = wait_thr[:pid]  # pid of the started process.       
+      if type == :text
+        while (line = pipe.gets)
+          next if skip_comments and line[0] == comment_char
+          yield klass.new(line.chomp)
+        end
+      elsif type == :binary
+        while (c = pipe.gets(nil))
+          yield c
+        end
+      end
+      exit_status = wait_thr.value  # Process::Status object returned.
+      puts stderr.read if $DEBUG 
+      stdin.close
+      pipe.close
+      stderr.close
+      return exit_status
+    end
+  end
+end

data/lib/bio/db/pileup.rb

@@ -0,0 +1,273 @@
+# :title:Pileup
+# = Bio::DB::Pileup 
+# A class representing information in SAMTools pileup format
+# Author:: Dan MacLean (dan.maclean@tsl.ac.uk)
+# Pileup is described at http://sourceforge.net/apps/mediawiki/samtools/index.php?title=SAM_FAQ#I_do_not_understand_the_columns_in_the_pileup_output.
+# Briefly (when you invoke pileup with the -c option):
+# * 1 reference sequence name
+# * 2 reference coordinate
+# * (3) reference base, or `*' for an indel line
+# * (4) genotype where heterozygotes are encoded in the IUB code: M=A/C, R=A/G, W=A/T, S=C/G, Y=C/T and K=G/T; indels are indicated by, for example, */+A, -A/* or +CC/-C. There is no difference between */+A or +A/*.
+# * (5) Phred-scaled likelihood that the genotype is wrong, which is also called `consensus quality'.
+# * (6) Phred-scaled likelihood that the genotype is identical to the reference, which is also called `SNP quality'. Suppose the reference base is A and in alignment we see 17 G and 3 A. We will get a low consensus quality because it is difficult to distinguish an A/G heterozygote from a G/G homozygote. We will get a high SNP quality, though, because the evidence of a SNP is very strong.
+# * (7) root mean square (RMS) mapping quality
+# * 8 # reads covering the position
+# * 9 read bases at a SNP line (check the manual page for more information); the 1st indel allele otherwise
+# * 10 base quality at a SNP line; the 2nd indel allele otherwise
+# * (11) indel line only: # reads directly supporting the 1st indel allele
+# * (12) indel line only: # reads directly supporting the 2nd indel allele
+# * (13) indel line only: # reads supporting a third indel allele
+# If pileup is invoked without `-c', indel lines and columns between 3 and 7 inclusive will not be outputted.
+# 
+# NB mpileup uses the 6 column output format eg
+# "seq2\t151\tG\tG\t36\t0\t99\t12\t...........A\t:9<;;7=<<<<<"
+# Pileup provides accessors for all columns (6 or 10 column format) and a few other useful methods
+# 
+# 
+module Bio
+  class DB
+    class Pileup
+      attr_accessor :ref_name, :pos, :ref_base, :coverage, :read_bases, :read_quals, :consensus_quality, :snp_quality, :rms_mapq, :ar1, :ar2, :ar3, :indel_1, :indel_2
+      
+      #creates the Pileup object
+      #    pile_up_line = "seq2\t151\tG\tG\t36\t0\t99\t12\t...........A\t:9<;;7=<<<<<"
+      #    pile = Bio::DB::Pileup.new(pile_up_line)
+      def initialize(pile_up_line)
+        cols = pile_up_line.split(/\t/)
+        @consensus = nil
+        @consensus_quality = nil
+        @read_quals = nil
+        @bases = nil
+        @allele_frequency = nil
+        @consensus_iuap = nil
+        if cols.length == 6 ##should only be able to get 6 lines from mpileup
+          @ref_name, @pos, @ref_base, @coverage, @read_bases, @read_quals = cols
+        elsif (10..13).include?(cols.length) ##incase anyone tries to use deprecated pileup with -c flag we get upto 13 cols...
+          if cols[2] == '*' #indel
+            @ref_name, @pos, @ref_base, @consensus, @consensus_quality, @snp_quality, @rms_mapq, @coverage, @indel_1, @indel_2, @ar1, @ar2, @ar3 = cols
+          else #snp / identity
+            @ref_name, @pos, @ref_base, @consensus, @consensus_quality, @snp_quality, @rms_mapq, @coverage, @read_bases, @read_quals = cols
+          end
+          @consensus_quality = @consensus_quality.to_f
+          @snp_quality = @snp_quality.to_f
+          @rms_mapq = @rms_mapq.to_f
+        else
+          #raise RuntimeError, "parsing line '#{pile_up_line.chomp}' failed"
+        end
+          
+        @pos = @pos.to_i
+        @coverage = @coverage.to_f
+        @ref_count = nil
+        @non_ref_count_hash = nil 
+        @non_ref_count = nil
+      end
+      
+      #Calculate the total count of each non-reference nucleotide and return a hash of all 4 nt counts
+      #returns a hash pile.non_refs #{:A => 1, :C => 0, :T => 0, :G => 0}
+      def non_refs
+        if @non_ref_count_hash.nil?
+           @non_ref_count_hash = {:A => self.read_bases.count("Aa"), :C => self.read_bases.count("Cc"), :G => self.read_bases.count("Gg"), :T => self.read_bases.count("Tt")}
+        end
+          @non_ref_count_hash
+      end
+      
+      # returns the total non-reference bases in the reads at this position
+      def non_ref_count
+        if @non_ref_count.nil?
+          @non_ref_count = @read_bases.count("ATGCatgc").to_f
+        end
+        @non_ref_count
+      end
+      
+      # returns the count of reference-bases in the reads at this position
+      def ref_count
+        if @ref_count.nil?
+          @ref_count = self.read_bases.count(".,")
+        end
+        @ref_count
+      end
+      
+      # returns the consensus (most frequent) base from the pileup, if there are equally represented bases returns a string of all equally represented bases in alphabetical order   
+      def consensus
+          if @consensus.nil?
+            max = self.non_refs.values.max
+            #if the ref base is in more than half the coverage..
+            if (self.ref_count / self.coverage) > 0.5
+              #..then the ref base is the concensus
+              @consensus = self.ref_base
+            ##not sure if the following will ever apply as the non_refs method also returns the ref base count, hence can never be over the max count  
+            #elsif self.ref_count > max
+            #  @consensus = self.ref_base
+            else
+              #get the base(s) and count(s) that has the max count
+              arr = self.non_refs.select {|k,v| v == max }
+              #just get the bases (remove the counts)
+              bases = arr.collect {|b| b[0].to_s }
+              #add the ref base if the ref base has a max count (commenting this out as it should already be in)
+              #bases << self.ref_base if self.ref_count == max
+              @consensus = bases.sort.join
+            end
+          end
+          @consensus
+      end
+      
+      #returns basic VCF string as per samtools/misc sam2vcf.pl except that it scrimps on the ref for indels, returning a '*' instead of the reference allele
+      def to_vcf
+        alt,g = self.genotype_list 
+        alt = self.consensus.split(//).join(',') unless self.ref_base == '*'
+        alt = '.' if alt == self.ref_base
+        alt = alt.split(',')
+        #if the reference base is in alt, remove it
+        alt.delete(self.ref_base.to_s)
+        alt = alt.join(',')
+        [self.ref_name, self.pos, '.', self.ref_base, alt, self.snp_quality.to_i, "0", "DP=#{self.coverage.to_i}", "GT:GQ:DP", "#{g}:#{self.consensus_quality.to_i}:#{self.coverage.to_i}" ].join("\t")
+      end
+      
+      private
+      def Pileup.vcf_header
+        %{##fileformat=VCFv3.3\n##INFO=DP,1,Integer,"Total Depth"\n##FORMAT=GT,1,String,"Genotype"\n##FORMAT=GQ,1,Integer,"Genotype Quality"\n##FORMAT=DP,1,Integer,"Read Depth"\n#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT\tDATA\n}
+      end
+      
+      
+ 
+      #returns the genotype of the indel
+      def indel_gt
+        return "undef" if self.consensus.instance_of?(Array)
+        al1, al2 = self.consensus.split(/\//)
+        if al1 == al2 && al1 == '*'   
+          al1=self.indel_1 
+          al2=self.indel_2
+        end
+        alt1 = parse_indel(al1)
+        alt2 = parse_indel(al2)
+        alt,gt = nil,nil
+        
+        return nil if !alt1 and !alt2
+        if !alt1 
+          alt = alt2
+          gt = '0/1'
+        elsif !alt2
+          alt = alt1
+          gt - '0/1'
+        elsif alt1 == alt2
+          alt = alt1
+          gt = '1/1'
+        else
+          alt="#{alt1},#{alt2}"
+          gt= '1/2'
+        end
+        return [alt, gt]
+        
+      end
+      #returns the genotype of the snp
+      def snp_gt
+        return ['.','0/0'] if self.ref_base == self.consensus
+        bases = Pileup.iupac_to_base(self.consensus)
+        if bases[0] == self.ref_base
+           return [bases[1],'0/1']
+        elsif bases[1] == self.ref_base
+           return [bases[0],'0/1']
+        else
+          return ["#{bases[0]},#{bases[1]}",'1/1']
+        end 
+      end
+      
+      #identifies the reference base and returns the indel or snp genotype as applicable
+      public
+      def genotype_list
+        if self.ref_base == '*'
+          return indel_gt
+        else
+         return snp_gt
+        end
+      end
+      
+      #returns the two bases for the corresponding iupac code
+      public
+      def Pileup.iupac_to_base(alt_base)
+          case alt_base
+                when 'K' then ['G','T']
+                when 'M' then ['A','C']
+                when 'S' then ['C','G']
+                when 'R' then ['A','G']
+                when 'W' then ['A','T']
+                when 'Y' then ['C','T']
+                else alt_base.split(//)
+          end
+      end
+      
+      #identifies if the indel is an insertion or a deletion  
+      def parse_indel(alt)
+        return "D#{$'.length}" if alt =~/^-/ 
+        if alt=~/^\+/
+          return "I#{$'}"
+        elsif alt == '*' 
+          return nil
+        end
+      end
+      
+      
+      #returns pileup format line
+      def to_s
+        if @read_quals and !@consensus_quality #6col
+          [@ref_name, @pos, @ref_base, @coverage.to_i, @read_bases, @read_quals].join("\t")    
+        elsif @indel_1 #13 cols
+          [@ref_name, @pos, @ref_base, @consensus, @consensus_quality.to_i, @snp_quality.to_i, @rms_mapq.to_i, @coverage.to_i, @indel_1, @indel_2, @ar1, @ar2, @ar3].join("\t")
+        else #10 cols
+          [@ref_name, @pos, @ref_base, @consensus, @consensus_quality.to_i, @snp_quality.to_i, @rms_mapq.to_i, @coverage.to_i, @read_bases, @read_quals].join("\t")
+        end
+          
+      end
+      
+      
+      def bases
+         return @bases if @bases
+         @bases = self.non_refs
+         #puts self.ref_count
+         @bases[self.ref_base.upcase.to_sym] = self.ref_count 
+         @bases
+      end
+
+       def base_coverage
+         total = 0
+         @bases.each do |k,v|
+           total += v  
+         end
+         total
+       end
+
+      #returns the frequency of all bases in pileup position
+       def allele_freq
+         return @allele_frequency if @allele_frequency
+         bases = self.bases
+         @allele_frequency = Hash.new
+         bases.each do |k,v| 
+           @allele_frequency[k] = v.to_f/self.base_coverage.to_f 
+         end
+         @allele_frequency
+       end
+
+       # returns the consensus (most frequent) base from the pileup, if there are equally represented bases returns a string of all equally represented bases in alphabetical order   
+       def consensus_iuap(minumum_ratio_for_iup_consensus)
+         
+         tmp = []
+         if @consensus_iuap.nil?
+           @consensus_iuap = self.ref_base.downcase
+           bases = self.bases
+           #tmp = String.new
+           bases.each do |k,v|
+             tmp << k[0].to_s if v/self.coverage.to_f > minumum_ratio_for_iup_consensus
+           end
+           if tmp.length > 0
+             tmp = tmp.collect{ |x| Bio::Sequence::NA.new(x) }
+              # creates alignment object
+              a = Bio::Alignment.new(tmp)
+              # shows IUPAC consensus
+             @consensus_iuap = a.consensus_iupac
+           end
+         end 
+         @consensus_iuap
+       end
+    end
+  end
+end

data/lib/bio/db/sam/external/COPYING

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2008-2009 Genome Research Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/lib/bio/db/sam/external/VERSION

@@ -0,0 +1 @@
+1.6

data/lib/bio/db/sam/library.rb

@@ -0,0 +1,32 @@
+module Bio
+  class DB
+    module SAM
+      module Library
+        #IMPORTANT NOTE: Windows library is missing in this distribution
+
+        # Return the path with the file name of the library for the specific operating system
+        def filename
+          #TODO refactor this piece of code in all the files
+          lib_os = case RUBY_PLATFORM
+          when /linux/
+            'so.1'
+          when /darwin/
+            '1.dylib'
+          when /windows/
+            'dll'
+          else
+            case RUBY_DESCRIPTION
+            when /jruby.*darwin/
+              '1.dylib'
+            when /jruby.*linux/
+            'so.1'
+            end
+          end
+
+          File.join(File.expand_path(File.dirname(__FILE__)),'external',"libbam.#{lib_os}")
+        end #filename
+        module_function :filename
+      end #Library
+    end #Sam
+  end #DB
+end #Bio