full_lengther_next 0.0.8 → 0.5.6

data/lib/full_lengther_next/classes/test_code.rb

@@ -18,16 +18,11 @@ class TestCode
 		protein = ''
 		p_long = 0
 		
-		if (seq.fasta_length < 200)
-			ref_name = seq.seq_name
-			ref_code = 0.0
-			ref_frame = 0
-			ref_status = 'unknown'
-			ref_orf = ''
-			ref_msgs = 'Sequence length < 200 nt'
-			
-			seq.annotate(:tcode_unknown,"#{ref_name}\t#{seq.fasta_length}\t\ttestcode\t#{ref_status}\t#{ref_code}\t\t\t\t\t#{ref_msgs}\t#{ref_frame}\t#{ref_start}\t#{ref_end}\t\t\t\t",true)
-			# seq.annotate(:tcode,"#{ref_name}\t#{seq.seq_fasta.length}\t\ttestcode\t#{ref_status}\t#{ref_code}\t\t\t\t\t#{ref_msgs}\t#{ref_frame}\t#{ref_start}\t#{ref_end}\t\t\t\t",true)
+		if seq.fasta_length < 200			
+			seq.type = UNKNOWN
+			seq.test_code(0.0)
+			seq.warnings('<200nt')
+			seq.hit = [ref_start, ref_end, 0] #Last element is ref_frame
 		else
 			
 # para probar tescode con toda la secuencia, en lugar de con los ORFs ----------------------------------------------------------------------
@@ -43,11 +38,15 @@ class TestCode
 
 
 			# see add_region filter
-			(name,t_code,status,ref_start,ref_end,ref_frame,orf,ref_msgs,stop_before_start,more_than_one_frame) = t_code(seq)
-			if (status == :unknown)
-				seq.annotate(:tcode_unknown,"#{name}\t#{seq.fasta_length}\t\ttestcode\t#{status}\t#{t_code}\t\t\t\t\t#{ref_msgs}\t#{ref_frame}\t#{ref_start}\t#{ref_end}\t\t\t\t",true)
+			name,t_code,status,ref_start,ref_end,ref_frame,orf,ref_msgs,stop_before_start,more_than_one_frame = t_code(seq)
+			seq.test_code(t_code)
+			seq.warnings(ref_msgs)
+			seq.hit = [ref_start, ref_end, ref_frame]
+
+			if status == :unknown
+				seq.type = UNKNOWN
 			else
-				seq.annotate(:tcode,"#{name}\t#{seq.fasta_length}\t\ttestcode\t#{status}\t#{t_code}\t\t\t\t\t#{ref_msgs}\t#{ref_frame}\t#{ref_start}\t#{ref_end}\t\t\t\t",true)
+				seq.type = CODING
 			end
 			
 			# if (ref_msgs.nil?)
@@ -157,7 +156,7 @@ class TestCode
 			ref_end = 0
 			ref_frame = 0
 			ref_orf = ''
-			ref_type = 'unknown'
+			ref_type = :unknown
 			ref_msgs = 'Non coding ORF found >= 200 nt '
 			return [name, ref_score, ref_type, ref_start, ref_end, ref_frame, ref_orf, ref_msgs, false, false]
 		end
@@ -772,7 +771,7 @@ class TestCode
 		valueY = ((valueY*1000.0).round/1000.0);
 
 		# return 'The TestCode value is <b>' + valueY.to_s + '</b>, which indicates that the sequence ' + getConclusion(valueY) + '.';
-		return [valueY.to_s, getConclusion(valueY)]
+		return [valueY, getConclusion(valueY)]
 	end
 
 	def calcParam (valueOne,valueTwo,valueThree)

data/lib/full_lengther_next/classes/types.rb

@@ -0,0 +1,12 @@
+FAILED			= -4
+OTHER			= -3
+CHIMERA			= -2
+MISASSEMBLED	= -1
+UNKNOWN			= 0
+COMPLETE		= 1
+N_TERMINAL		= 2
+C_TERMINAL		= 3
+INTERNAL		= 4
+NCRNA			= 5
+CODING			= 6
+

data/lib/full_lengther_next/classes/une_los_hit.rb

@@ -4,284 +4,202 @@ include CommonFunctions
 
 class UneLosHit
 	
-	attr_reader :output_seq, :final_hit, :msgs, :number_x, :wrong_seq, :is_ok, :q_index_start, :full_prot
+	attr_reader :output_seq, :final_hit, :msgs, :number_x, :is_ok, :q_index_start, :full_prot
    
-	def initialize(q, query_fasta, pident_threshold)
-				
-		(mismas_ids_array, query_fasta, wrong_seq) = hits_misma_id(q, query_fasta)
-		
-		@wrong_seq = wrong_seq
+	def initialize(full_hit, query_fasta)
+		#puts 'BEG ___________________'
+		#full_hit.map{|hsp| puts hsp.inspect}
+		mismas_ids_array, query_fasta = hits_misma_id(full_hit, query_fasta)
+		#puts '..................'
 		@mismas_ids_array = mismas_ids_array
-		@msgs = ''
-		@number_x = 0
-		num_x = ''
-		
+		@msgs = []
 		@output_seq = query_fasta
-		
-		if (mismas_ids_array.count > 1)
-			mismas_ids_array.sort! {|h1,h2| h1.q_beg <=> h2.q_beg} # ordenamos los hit por el inicio del query
-			@final_hit = mismas_ids_array[0].dup
 
+		if mismas_ids_array.count > 1
+			mismas_ids_array.sort! {|h1,h2| h1.q_beg <=> h2.q_beg} # ordenamos los hit por el inicio del query
+			@final_hit = mismas_ids_array.shift # We take first hsp like reference for unigene reconstruction
+			#puts @output_seq.length
+			#puts "\e[32m#{@final_hit.inspect}\e[0m"
 			mismas_ids_array.each do |hit|
-				if (hit.ident >= pident_threshold)
-					# if ($verbose)
-						# puts "#{hit.acc}\tsc:#{hit.score}\teval:#{hit.e_val}\tid:#{hit.ident}\tframe:#{hit.q_frame}\tqb:#{hit.q_beg + 1}\tqe:#{hit.q_end + 1}\tsb:#{hit.s_beg + 1}\tse:#{hit.s_end + 1}"
-						# puts "#{query_fasta[hit.q_beg..hit.q_end].translate}"
-					# end
-				
-					same = same_hit(hit)
-			
-					if (!same)
-						if (@final_hit.q_frame == hit.q_frame)
-							same_frame_hits(hit)
-						else
-							# condiciones para corregir el frame en el que tiene que continuar la seq de nt
-							correccion_x = 0
-							if (@final_hit.q_frame - hit.q_frame == 1)
-								correccion_x = 1
-							elsif (@final_hit.q_frame - hit.q_frame == 2)
-								correccion_x = 2
-							elsif (@final_hit.q_frame - hit.q_frame == -1)
-								correccion_x = 2
-							elsif (@final_hit.q_frame - hit.q_frame == -2)
-								correccion_x = 1
-							end
-						
-							# las secuencias solapan en el query
-							if ((@final_hit.q_end >= hit.q_beg) && (@final_hit.q_end < hit.q_end)) && (hit.q_end > @final_hit.q_end + 15)
-								overlapped_hits(hit, correccion_x, q)
-								# puts "---#{@output_seq[@final_hit.q_frame-1, @output_seq.length+1].translate}"
-						
-							elsif (@final_hit.q_end < hit.q_beg) && (hit.q_end > @final_hit.q_end + 15) # las secuencias estan separadas en el query
-								separated_hits(hit, correccion_x, q)
-								# puts "----------#{@output_seq[@final_hit.q_frame-1, @output_seq.length+1].translate}"
-							else
-								@msgs = 'warning!, putative chimeric sequence! or repetitive structure'
-								# puts "\nWARNING!, PUTATIVE CHIMERIC SEQUENCE !!!\n\n"
-							end
-						end
+				#puts '.....', "\e[31m#{hit.inspect}\e[0m"
+				##if @final_hit.q_frame == hit.q_frame #Same frame
+				##	puts "\e[33mSame Frame\e[0m"
+				##	same_frame_hits_query(hit)
+				if  overlapping_hits?(hit) #Diff frame
+					if @msgs.empty?
+						@msgs << ['OverlapHit', @final_hit.q_end + 1, hit.q_beg + 1]
+					else
+						@msgs << ['AndOverlapHit', @final_hit.q_end + 1, hit.q_beg + 1]
 					end
-				end # pident
+					#puts "\e[33mOverlapped hits\e[0m"
+					overlapped_hits_query(hit)			
+				elsif  separated_hits?(hit) #Diff frame
+					if @msgs.empty?
+						@msgs << ['SeparatedHit', @final_hit.q_end + 1, hit.q_beg + 1]
+       				else
+						@msgs << ['AndSeparatedHit', @final_hit.q_end + 1, hit.q_beg + 1]
+					end
+					#puts "\e[33mSeparated hits\e[0m"
+					separated_hits(hit) #Diff frame
+				end
+			#puts @output_seq.length
+			#puts  '.....'
+			#puts "\e[32m#{@final_hit.inspect}\e[0m"
 			end
-
 		else
-
-			@final_hit = mismas_ids_array[0].dup
-			
-			# if ($verbose)
-				# puts "***#{@final_hit.acc}\t#{@final_hit.score}\t#{@final_hit.e_val}\t#{@final_hit.ident}\t#{@final_hit.align_len}\t#{@final_hit.q_frame}\t#{@final_hit.q_beg + 1}\t#{@final_hit.q_end + 1}\t#{@final_hit.s_beg + 1}\t#{@final_hit.s_end + 1}\t#{@final_hit.q_seq}"
-				# puts "#{query_fasta[@final_hit.q_beg..@final_hit.q_end].translate}"
-			# end
+			@final_hit = mismas_ids_array.shift			
 		end
-		# puts "***#{@final_hit.acc}\t#{@final_hit.score}\t#{@final_hit.e_val}\t#{@final_hit.ident}\t#{@final_hit.align_len}\t#{@final_hit.q_frame}\t#{@final_hit.q_beg + 1}\t#{@final_hit.q_end + 1}\t#{@final_hit.s_beg + 1}\t#{@final_hit.s_end + 1}\t#{@final_hit.q_seq}"
-		# puts "#{query_fasta[@final_hit.q_beg..@final_hit.q_end].translate}"
-		
-		@full_prot = @output_seq[@final_hit.q_frame-1, @output_seq.length+1].translate
-		# puts "\nfull_prot_ulh: \n#{full_prot}"
-		
-		(@is_ok, @q_index_start) = contenidos_en_prot(@final_hit, @full_prot, q)
-		
+		#puts 'END ___________________'
+		#puts @final_hit.inspect
 	end
 
-
-
-	def same_hit(hit)
-	
-		same = false
-		if (hit.score == @final_hit.score &&
-			hit.q_beg == @final_hit.q_beg &&
-			hit.q_end == @final_hit.q_end &&
-			hit.s_beg == @final_hit.s_beg &&
-			hit.s_end == @final_hit.s_end)
-		
-			same = true
-		end
-	
-		return same
+	def same_frame_hits_query(hit)
+		@final_hit.q_seq = @output_seq[@final_hit.q_beg..@final_hit.q_end].translate
+		@final_hit.q_end = hit.q_end
+		@final_hit.s_end = hit.s_end
+		@final_hit.align_len = hit.s_end - @final_hit.s_beg + 1
 	end
 
 
+	def overlapped_hits_query(hit)
+		overlapped_nts = @final_hit.q_end - hit.q_beg + 1
+		add_nt = ajust_nt(hit.q_frame-1) # Fix frame-shift
+		@output_seq = @output_seq[0..@final_hit.q_end-overlapped_nts] + 'n' * (overlapped_nts + add_nt) + @output_seq[@final_hit.q_end+1.. @output_seq.length-1]
 
-	def same_frame_hits(hit)
-		
-		@final_hit.q_beg = @final_hit.q_beg
-		@final_hit.q_end = hit.q_end
-		
-		@final_hit.s_beg = [@final_hit.s_beg,hit.s_beg].min
-		@final_hit.s_end = [@final_hit.s_end,hit.s_end].max
+		@final_hit.q_seq = @output_seq[@final_hit.q_beg..hit.q_end+add_nt].translate
+		@final_hit.q_end = hit.q_end + add_nt
 		
+		@final_hit.s_beg = [@final_hit.s_beg, hit.s_beg].min
+		@final_hit.s_end = [@final_hit.s_end, hit.s_end].max
+		@final_hit.align_len = @final_hit.s_end - @final_hit.s_beg+1
+		@final_hit.q_len = @output_seq.length
 	end
 
 
+	def separated_hits_query(hit)			
+		separated_nts = hit.q_beg - @final_hit.q_end + 1
+		add_nt = ajust_nt(separated_nts) # Fix frame-shift
 
-	def overlapped_hits(hit,correccion_x,q)
-	  # puts q.inspect
-		# puts "los hits solapan!!!"
-		
-		if (@msgs.empty?)
-			@msgs = "Overlapping hits, possible frame ERROR between #{@final_hit.q_end + 1} and #{hit.q_beg + 1}, "
-		else
-			@msgs += " and overlapping frame ERROR between #{@final_hit.q_end + 1} and #{hit.q_beg + 1}, "
-		end
-		
-		# -------------------------------------   preparamos los nt y aas que solapan
-		overlapped_nt = 0
-		overlapped_nt = (@final_hit.q_end - hit.q_beg + 1)
-
-		overlapped_aas = 0
-		overlapped_aas = (@final_hit.s_end - hit.s_beg + 1)
-		# ------------------------------------- 
-		if (overlapped_nt % 3 == 1)
-			overlapped_nt += 2
-		elsif (overlapped_nt % 3 == 2)
-			overlapped_nt += 1
-		end
-		# -------------------------------------   calculamos el numero de x a añadir 
-		@number_x = (((correccion_x + overlapped_nt)/3)+1)*3
-		@number_x_aa = overlapped_aas
-		num_x = ''
-		num_x_aa = ''
+		@output_seq = @output_seq[0..@final_hit.q_end - separated_nts] + 'n' * (separated_nts + add_nt) + @output_seq[@final_hit.q_end+1..@output_seq.length-1]
+		@final_hit.q_seq = @output_seq[@final_hit.q_beg..hit.q_end+add_nt].translate
 
-		if (@number_x.to_i > 0)
-			num_x = 'x'*@number_x.to_i
-		elsif (@number_x.to_i == 0)
-			num_x = ''
-		else
-			@msgs = "ERROR#2 unexpected negative index in x_number, "
-			# puts "ERROR#2 unexpected negative index in x_number"
-		end
+		@final_hit.q_end = hit.q_end + add_nt
+		@final_hit.s_end = hit.s_end
+		@final_hit.align_len = @final_hit.s_end - @final_hit.s_beg+1
+		@final_hit.q_len = @output_seq.length
+	end
 
-		if (@number_x_aa.to_i > 0)
-			num_x_aa = 'x'*@number_x_aa.to_i
-		elsif (@number_x_aa.to_i == 0)
-			num_x_aa = ''
-		else
-			num_x_aa = 'x'*@number_x_aa.to_i.abs
-			@msgs = "Warning!, your query overlaps and the subject is separated, "
-		end
+	def same_frame_hits(hit)
+		add = (hit.s_beg - @final_hit.s_end) + 1
+		nt_add = add *3
+		@final_hit.q_seq = @final_hit.q_seq + 'x' * add + hit.q_seq
+		@final_hit.s_seq = @final_hit.s_seq + 'x' * add + hit.s_seq
+		@output_seq = @output_seq[0..@final_hit.q_end-nt_add] + 'n'*nt_add  + @output_seq[hit.q_beg+1..@output_seq.length-1]
+		@final_hit.q_end = hit.q_end
+		@final_hit.s_end = hit.s_end
+		@final_hit.align_len = hit.s_end - @final_hit.s_beg + 1
+	end
 
-		if (@number_x_aa.to_i >= 0)
-			@final_hit.q_seq = "#{@final_hit.q_seq[0..@final_hit.q_seq.length - 1 - overlapped_aas]}#{num_x_aa}#{hit.q_seq[overlapped_aas..hit.q_seq.length]}"
-			@final_hit.s_seq = "#{@final_hit.s_seq[0..@final_hit.s_seq.length - 1 - overlapped_aas]}#{num_x_aa}#{hit.s_seq[overlapped_aas..hit.s_seq.length]}"
-		else
-			@final_hit.q_seq = "#{@final_hit.q_seq[0..@final_hit.q_seq.length - 1]}#{num_x_aa}#{hit.q_seq[0..hit.q_seq.length]}"
-			@final_hit.s_seq = "#{@final_hit.s_seq[0..@final_hit.s_seq.length - 1]}#{num_x_aa}#{hit.s_seq[0..hit.s_seq.length]}"
+	def overlapped_hits(hit) #Colapsa cuando hay hsps en diferentes partes de la query pero son lo mismo en el subject con lo cual los eliminamos antes
+		overlapped_aas = @final_hit.s_end - hit.s_beg + 1
+		overlapped_nts = @final_hit.q_end - hit.q_beg + 1
+		align_len_final_hit = @final_hit.q_seq.length
+		hit_gaps_query = @final_hit.q_seq[align_len_final_hit-overlapped_aas..align_len_final_hit].count('-')
+		hit_gaps_subject = @final_hit.s_seq[0..align_len_final_hit].count('-')
+		total_gaps = (hit_gaps_query - hit_gaps_subject).abs # Gaps añaden aa q no existen, x lo q han de descontarse
+		nt_discount = (overlapped_aas ) * 3
+
+		absolute_overlap = 1
+		if nt_discount < 0 #Not overlap on subject
+            overlapped_aas = overlapped_aas.abs
+			absolute_overlap = 0 #Don't cut q_seq and s_seq, because there is query overlap but there isn't subject overlap
+			nt_discount =  @final_hit.q_end - hit.q_beg + 1
+			nt_discount += ajust_nt(nt_discount)
 		end
-		
-		
-		output_seq_tmp = "#{@output_seq[0..(@final_hit.q_end - overlapped_nt)]}#{num_x}#{@output_seq[(hit.q_beg + overlapped_nt)..(@output_seq.length)]}"
+		add_nt = overlapped_nts + ajust_nt(hit.q_frame-1)
+		@output_seq = @output_seq[0..@final_hit.q_end-overlapped_nts] + 'n' * add_nt + @output_seq[@final_hit.q_end+1.. @output_seq.length-1]
 
-		full_prot_tmp = output_seq_tmp[@final_hit.q_frame-1, output_seq_tmp.length+1].translate
-		
-		(is_ok_tmp, q_index_start_tmp) = contenidos_en_prot(@final_hit, full_prot_tmp, q)
+		#q_seq and s_seq are aa sequences
+		final_hit_upper_bound = @final_hit.q_seq.length - 1 - overlapped_aas * absolute_overlap
+		@final_hit.q_seq = @final_hit.q_seq[0..final_hit_upper_bound] + 'x' * overlapped_aas + hit.q_seq[overlapped_aas * absolute_overlap .. hit.q_seq.length-1]
+		@final_hit.s_seq = @final_hit.s_seq[0..final_hit_upper_bound] + 'x' * overlapped_aas + hit.s_seq[overlapped_aas * absolute_overlap .. hit.s_seq.length-1]
 
-		@output_seq = output_seq_tmp.dup
-		
-		@final_hit.q_beg = @final_hit.q_beg
 		@final_hit.q_end = hit.q_end
 		
-		@final_hit.s_beg = [@final_hit.s_beg,hit.s_beg].min
-		@final_hit.s_end = [@final_hit.s_end,hit.s_end].max
-		
+		@final_hit.s_beg = [@final_hit.s_beg, hit.s_beg].min
+		@final_hit.s_end = [@final_hit.s_end, hit.s_end].max
+		@final_hit.align_len = @final_hit.s_end - @final_hit.s_beg+1		
 	end
 
+	def separated_hits(hit)			
+		number_x = hit.q_beg - @final_hit.q_end - 1
+		number_x += ajust_nt(number_x)	
 
-
-	def separated_hits(hit,correccion_x,q)
-		
-		# puts "los hits estan separados!!!"
-		
-		if (@msgs.empty?)
-			@msgs = "Separated hits, possible frame ERROR between #{@final_hit.q_end + 1} and #{hit.q_beg + 1}, "
-		else
-			@msgs += " and possible frame ERROR between #{@final_hit.q_end + 1} and #{hit.q_beg + 1}, "
-		end
-		
-		# PROBAR CON % 3!!!!!!!!!!!!!!!!!!!!!!!!
-		@number_x = (hit.q_beg - @final_hit.q_end - 1)
-		# @number_x = (hit.q_beg - @final_hit.q_end - 1) + correccion_x
-		if (@number_x % 3 == 1)
-			@number_x += 2
-		elsif (@number_x % 3 == 2)
-			@number_x += 1
-		end
-		
-
-		if (@number_x.to_i > 0)
-			num_x = 'x'*@number_x.to_i
-			num_x_aa = 'x'*(@number_x.to_i/3)
-		elsif (@number_x.to_i == 0)
-			num_x = ''
-			num_x_aa = ''
-		else
-			@msgs = "ERROR#2 unexpected negative index in x_number"
-			# puts "ERROR#2 unexpected negative index in x_number"
+		num_x = ''
+		num_x_aa = ''
+		if number_x > 0
+			num_x = 'n'*number_x
+			num_x_aa = 'x'*(number_x/3)
 		end
+		@output_seq = @output_seq[0..@final_hit.q_end-1] + num_x + @output_seq[hit.q_beg-1..@output_seq.length-1]
+        @final_hit.q_seq = @final_hit.q_seq[0, @final_hit.q_seq.length] + num_x_aa + hit.q_seq[0, hit.q_seq.length]
+        @final_hit.s_seq = @final_hit.s_seq[0, @final_hit.s_seq.length] + num_x_aa + hit.s_seq[0, hit.s_seq.length]
 
-		@output_seq = @output_seq[0..@final_hit.q_end-1]+num_x+@output_seq[hit.q_beg-1..@output_seq.length-1]
-		# @output_seq = @output_seq[0..@final_hit.q_end-1]+num_x+@output_seq[hit.q_beg-1..@output_seq.length-1]
-
-		@final_hit.score += 1
-		@final_hit.q_beg = @final_hit.q_beg
 		@final_hit.q_end = hit.q_end
-		@final_hit.s_beg = @final_hit.s_beg
 		@final_hit.s_end = hit.s_end
-
-		@final_hit.q_seq = "#{@final_hit.q_seq[0, @final_hit.q_seq.length]}#{num_x_aa}#{hit.q_seq[0, hit.q_seq.length]}"
-		@final_hit.s_seq = "#{@final_hit.s_seq[0, @final_hit.s_seq.length]}#{num_x_aa}#{hit.s_seq[0, hit.s_seq.length]}"
-
-		num_x = ''
-		num_x_aa = ''
-		
-		full_prot_tmp = @output_seq[@final_hit.q_frame-1, @output_seq.length+1].translate
-		# puts "\n\nfull_prot_tmp:#{full_prot_tmp}"
-		# puts "\n\n#{@output_seq[@final_hit.q_frame-1, @output_seq.length+1]}"
-		
-		(is_ok_tmp, q_index_start_tmp) = contenidos_en_prot(@final_hit, full_prot_tmp, q)
-		
-		# puts "#{q.query_def}: is_ok_tmp: #{is_ok_tmp} separated hits"
+		@final_hit.align_len = @final_hit.s_end - @final_hit.s_beg+1	
 	end
 
 
 
 	# creamos un array en el que esten solo los hits con la misma id. 
-	def hits_misma_id(q, query_fasta_ori)
-		
-		# Se les hace la reveso complementaria si es necesario, y se comprueba que para un mismo query no hay hits en sentidos diferentes
-		wrong_seq = false
-		
+	def hits_misma_id(full_hit, query_fasta_ori)		
+		# Se les hace la reverso complementaria si es necesario
 		misma_id = []
-		
 		query_fasta = query_fasta_ori.dup
-		frame_ori = q.hits[0].q_frame
-
-		q.hits.each do |h|
-
-			# puts "#{q.query_def} f_ori :#{frame_ori} y h_f: #{h.q_frame}"
-			reversed_hit = false # con respecto al primer hit, que es el de mayor score o evalue
-			if (h.acc == q.hits[0].acc)
-
-				# comprobar si los frames tiene el mismo sentido
-				if ((frame_ori < 0 && h.q_frame > 0) or (frame_ori > 0 && h.q_frame < 0))
-					wrong_seq = true
-					reversed_hit = true
-					# puts "The sequence #{q.query_def} contains sense and antisense hits!!! #{frame_ori} y #{h.q_frame}"
-				end
-				
-				if (reversed_hit == false)
-					if (h.q_frame.to_i < 0) # si la secuencia esta al reves le damos la vuelta
-						(query_fasta, h.q_frame, h.q_beg, h.q_end) = reverse_seq(query_fasta_ori, h.q_frame, h.q_beg, h.q_end)
-						h.reversed = true
+		#frame_ori = q.hits.first.q_frame
+
+		full_hit.each do |h|
+			if h.acc == full_hit.first.acc
+				# comprobar si los frames tienen el mismo sentido
+				#if frame_ori < 0 && h.q_frame > 0 || frame_ori > 0 && h.q_frame < 0
+					if h.q_frame < 0 # si la secuencia esta al reves le damos la vuelta
+						query_fasta = reverse_seq(query_fasta_ori, h)
+						h.reversed = TRUE
 					end
-					misma_id.push h
-				end
-
+					misma_id << h
+				#end
 			end
+		end
+
+		return misma_id, query_fasta
+	end
 
+	def overlapping_hits?(hit)
+		overlap = FALSE
+		if @final_hit.q_end >= hit.q_beg && @final_hit.q_end < hit.q_end && @final_hit.q_end < hit.q_end
+			overlap = TRUE
 		end
+		return overlap
+	end
 
-		return [misma_id, query_fasta, wrong_seq]
+	def separated_hits?(hit)
+		separated=FALSE
+		if @final_hit.q_end < hit.q_beg && hit.q_end > @final_hit.q_end
+			separated = TRUE
+		end
+		return separated
 	end
 
 
+
+	def ajust_nt(nt) # Returns the number of nt necessary for keep the ORF (or nt becomes multiple of 3) 
+		add=0
+		if nt % 3 == 1
+			add = 2
+		elsif nt % 3 == 2
+			add = 1
+		end
+		return add
+	end
 end