class Bio::DB::Exonerate::Alignment

Attributes

g[RW]
line[RW]
pi[RW]
ql[RW]
query_end[RW]
query_id[RW]
query_start[RW]
query_strand[RW]
score[RW]
target_end[RW]
target_id[RW]
target_start[RW]
target_strand[RW]
tl[RW]
vulgar_block[RW]

Public Class Methods

parse_custom(line) click to toggle source

This one day may grow to work with complex ryo.…

# File lib/bio/db/exonerate.rb, line 52
def self.parse_custom(line)
  fields=line.split(/\t/)
  if fields[0] == "RESULT:"
    al = Bio::DB::Exonerate::Alignment.new()      
    al.parse_sugar(fields[1])
    al.pi = fields[2].to_f 
    al.ql = fields[3].to_i
    al.tl = fields[4].to_i
    al.g  = fields[5]
    al.parse_vulgar(fields[6])
    al.line = line
    return al
  else
    return nil
  end
end

Public Instance Methods

exon_on_gene_position(position) click to toggle source

This assumes that the gene is the query and the chromosome is the target

# File lib/bio/db/exonerate.rb, line 184
def exon_on_gene_position(position)
  @vulgar_block.each do |vulgar|
    if position.between?(vulgar.query_start, vulgar.query_end)
      return vulgar
    end
  end
  nil
end
identity() click to toggle source
# File lib/bio/db/exonerate.rb, line 100
def identity
  @pi
end
parse_sugar(sugar_str) click to toggle source
# File lib/bio/db/exonerate.rb, line 119
def parse_sugar(sugar_str)
  @query_id, @query_start, @query_end, @query_strand, @target_id, @target_start, @target_end, @target_strand, @score = sugar_str.split(/\s+/)

  @query_start  = @query_start.to_i
  @query_end = @query_end.to_i
  @target_start = @target_start.to_i
  @target_end = @target_end.to_i
  @score = @score.to_f

  if @target_strand == "+"
    @target_strand = :forward
  elsif @target_strand == "-"
    @target_strand = :reverse
  else
    raise  ExonerateException.new(), "Ivalid target orientation #{@target_strand} for line:\n#{sugar_str}"
  end


  if @query_strand == "+"
    @query_strand = :forward
  elsif @query_strand == "-"
    @query_strand = :reverse
  else
    raise  ExonerateException.new(), "Ivalid query orientation #{@query_strand} for line:\n#{sugar_str}"
  end

  raise  ExonerateException.new(), "Inconsistent orientation (forward, query)" if @query_strand == :forward and @query_start > @query_end
  raise  ExonerateException.new(), "Inconsistent orientation (reverse, query)" if @query_strand == :reverse and @query_start < @query_end
  raise  ExonerateException.new(), "Inconsistent orientation (forward, target)" if @target_strand == :forward and @target_start > @target_end
  raise  ExonerateException.new(), "Inconsistent orientation (reverse, target)" if @target_strand == :reverse and @target_start < @target_end


  self
end
parse_vulgar(vulgar_str) click to toggle source

The vulgar has to be parsed AFTER the sugar, otherwise it is impossible to determine the orientations

# File lib/bio/db/exonerate.rb, line 156
def parse_vulgar(vulgar_str)

  tarcurrent = @target_start
  query_current = @query_start
  target_multiply = 1
  query_multiply = 1

  if @target_strand == :reverse
    target_multiply = -1
  end

  if @query_strand == :reverse
    query_multiply = -1
  end

  @vulgar_block = Array.new
  #p "VULGAR #{vulgar_str}"
  vulgar_str.split(/\s/).each_slice(3) do | block |
    #p block
    vulgar = Vulgar.new(block[0].to_sym, block[1].to_i, block[2].to_i, tarcurrent, target_multiply, query_current, query_multiply, self)
    query_current = vulgar.query_end
    tarcurrent = vulgar.target_end
    vulgar_block << vulgar
  end
  self
end
print_features() click to toggle source
query() click to toggle source
# File lib/bio/db/exonerate.rb, line 69
 def query
  unless @query
    @query = Bio::DB::Fasta::Region.new()
    @query.entry = query_id 
    @query.start = query_start + 1
    @query.end = query_end
    @query.orientation = query_strand
    if @query.orientation == :reverse
     @query.end = query_start 
     @query.start = query_end + 1
    end
    @query
  end
  @query
end
query_coverage() click to toggle source
# File lib/bio/db/exonerate.rb, line 106
def query_coverage
  total_m = 0
  vulgar_block.each do |v|  
    #p v.label
    if v.label == :M
      total_m += v.query_length
    end
  end
 #puts "Total m #{total_m}"
 #puts "ql #{query_length}"
  return 100.00 * total_m.to_f / query_length.to_f 
end
query_length() click to toggle source
# File lib/bio/db/exonerate.rb, line 103
def query_length
  @ql
end
query_position_on_target(position, base:0) click to toggle source
# File lib/bio/db/exonerate.rb, line 193
def query_position_on_target(position, base:0)
  vulgar = exon_on_gene_position(position)
  qr = vulgar.query_region
  tr = vulgar.target_region
  
  offset = qr.orientation == :forward ? position - qr.start + 1 : qr.end - position

  #puts vulgar.to_s
  #puts "SNP position: #{position}"
  #puts vulgar.query_region
  #puts vulgar.query_region.orientation
  #puts "Offset query: #{offset}"
  #puts vulgar.target_region
  #puts vulgar.target_region.orientation

  new_pos = tr.orientation == :forward ? offset + tr.start - 1 :  tr.end - offset + 1

  return new_pos
end
target() click to toggle source
# File lib/bio/db/exonerate.rb, line 85
 def target
  unless @target
    @target = Bio::DB::Fasta::Region.new()
    @target.entry = target_id 
    @target.start = target_start + 1
    @target.end = target_end
    @target.orientation = target_strand
    if @target.orientation == :reverse
      @target.end = target_start 
      @target.start = target_end + 1
    end
  end
  @target
end
tarpostion_from_query_position(position) click to toggle source
# File lib/bio/db/exonerate.rb, line 213
def tarpostion_from_query_position(position)
  ret = nil
  vulgar_block = exon_on_gene_position(position)
  ret
end