class ExonerateResult

Extracts results from blast table's file and uses it to create instances of “BlastQuery” and “BlastHit”

Attributes

querys[RW]

Public Class Methods

new(input,all) click to toggle source

Parser initialization

# File lib/gene_assembler/exonerate_result.rb, line 39
def initialize(input,all)
  @querys = []

  if input.is_a?(Array)
      input.each do |file|
      fich = File.open(file,'r')
      lines = fich.readlines
      fich.close
      parse_file(lines,all)
      end
  else
    fich = File.open(input,'r')
    lines = fich.readlines
    fich.close
    parse_file(lines,all)
  end
  query_name=''
  
end

Public Instance Methods

convert_parsed_lines(lines_parsed) click to toggle source
# File lib/gene_assembler/exonerate_result.rb, line 86
def convert_parsed_lines(lines_parsed)
  lines_parsed.each do |line|
    align_data=nil
    features=nil
    if lines_parsed.class.to_s=='Array'
      align_data=line['align_data']
      features=line
    else #hash
      align_data=line[1]['align_data']
      features=line[1]        
    end
    tags=[]
    elm=[]
    align_data_len=align_data.length-1
    align_data.each_with_index do |field,c|
      mod=c.modulo(3)
      if mod==0 #tag operation
        if c>0
          tags << elm
        end
        elm=[] #array q inicia segunda dimension en el array principal
        elm << field
      elsif mod==1 # Coordenada relativa del query
        elm << field.to_i
      elsif mod==2 # Coordenada relativa del target
        elm << field.to_i
      end
      if align_data_len==c #Guardar ultima operacion x fin de parseo
        tags << elm
      end           
    end
    hiting(features,tags)
  end    
end
empty?() click to toggle source

check if there are querys

# File lib/gene_assembler/exonerate_result.rb, line 219
def empty?

  return @querys.empty?
end
find_query(querys,name_q) click to toggle source

find query by name

# File lib/gene_assembler/exonerate_result.rb, line 207
def find_query(querys,name_q)
  #  newq = querys.find{|q| ( q.find{|h| (h.subject_id)})}
  new_q=nil

  if !querys.empty?
    new_q=querys.find{|q| (q.query_id==name_q)}
  end

  return new_q
end
hiting(features,tags) click to toggle source
# File lib/gene_assembler/exonerate_result.rb, line 121
def hiting(features,tags) #Convierte las coordenadas relativas del exonerate a absolutas tipo blast, definiendo solo los hits
query=ExoBlastQuery.new(features['target_id'])
        #Variables para hit
        if features['target_strand']=='+'
                reversed=FALSE
                strand=1
        else 
                reversed=TRUE 
                strand=-1
        end
        #------------------
        start_target=features['target_start_align'].to_i#paso de coord 0 a 1
        ends_target=0
        start_query=features['query_start_align'].to_i
        ends_query=0
        tag_len=tags.length-1
        counter_target=start_target
        counter_query=start_query
        add=TRUE #Hay casos q hay q realizar la adicion de coordenadas relativas antes de la operacion de guardado, esta varible se define para impedir la suma al final de la iteracion
        tags.each_with_index do |tag,c|
                if c==tag_len||tag[0]=='S'||tag[0]=='G'
                        counter_query+=tag[1]
                        counter_target+=(tag[2]*strand)
                        add=FALSE
                else
                        if tag[0]=='F'
                                query.s_frameshift << counter_query 
                                query.q_frameshift << counter_target
                        end
                        add=TRUE
                end
                if tag[0]=='5'||c==tag_len #Comienzo de intron o final de secuencia
                        ends_target=counter_target
                        ends_query=counter_query 
                        
                        # creates the hit
                        hit = BlastHit.new(start_target+1, ends_target, start_query+1, ends_query) 
                        hit.align_len=(ends_target-start_target)*strand
                        hit.ident=0

                        hit.gaps=0
                        hit.mismatches=0
                        hit.e_val=0
                        hit.bit_score=0

                        hit.score = features['score'].to_i
                        if reversed
                                hit.q_frame = -1
                        else
                                hit.q_frame =1
                        end
                        hit.s_frame = nil
                        
                        hit.reversed=reversed
                        hit.subject_id = features['query_id']
                        hit.full_subject_length=0
                        hit.definition=features['query_id']
                        hit.acc=features['query_id']
                        hit.q_seq=''
                        hit.s_seq=''
                        #puts "#{features['target_id']}\t#{hit.inspect}"
                        query.add_hit(hit)
                end
                if add
                        counter_query+=tag[1]
                        counter_target+=tag[2]*strand
                end
                
                if tag[0]=='3' # Final de intron x lo tanto comienzo de exon
                        start_query=counter_query
                        start_target=counter_target
                end
        end#end do
        @querys << query
end
inspect() click to toggle source

inspect results

# File lib/gene_assembler/exonerate_result.rb, line 198
def inspect
  res = "Exonerate results:\n"
  res+= '-'*20
  res+= "\nQuerys: #{@querys.count}\n"
  @querys.each{|q| res+=q.inspect+"\n"}
  return res
end
parse_file(lines,all) click to toggle source
# File lib/gene_assembler/exonerate_result.rb, line 59
def parse_file(lines,all)
  lines_parsed=nil
  if !all
    lines_parsed={}
  else
    lines_parsed=[]
  end
  lines.each do |line|
                      if line=~ /^vulgar:/
                              fields=line.split
                              features={'query_id'=> fields[1], 'query_start_align'=> fields[2], 'query_end_align'=> fields[3], 'query_strand'=> fields[4],'target_id'=> fields[5], 'target_start_align'=> fields[6], 'target_end_align'=> fields[7], 'target_strand'=> fields[8], 'score'=> fields[9], 'align_data'=> fields[10..fields.length]}
                              if all
                                lines_parsed << features
                              else
                                if !lines_parsed.key?(features['target_id']) # Añadir valor si no existe
                                  lines_parsed[features['target_id']]=features
                                else
                                  if features['score']>lines_parsed[features['target_id']]['score'] # Si ya existe una query, ver si la nueva presenta un mayor score y reemplazar la antigua
                                    lines_parsed[features['target_id']]=features
                                  end
                                end
                              end
                      end
              end           
              convert_parsed_lines(lines_parsed)    
end
size() click to toggle source

get query count

# File lib/gene_assembler/exonerate_result.rb, line 225
def size
  @querys.size
end