full_lengther_next 0.0.8 → 0.5.6

data/lib/full_lengther_next/classes/nc_rna.rb

@@ -1,3 +1,4 @@
+require 'types'
 
 module NcRna
 	
@@ -8,14 +9,11 @@ module NcRna
 			raise "BLAST query name and sequence are different"
 		end
 		
-		q=blast_query
+		hit=blast_query.hits.first
 		
-		if (!q.hits[0].nil?) # There is match in blast.
-			nc_annotations = "#{q.query_def}\t#{seq.fasta_length}\t#{q.hits[0].acc}\tncRNA\tPutative ncRNA\t\t#{q.hits[0].e_val}\t#{q.hits[0].ident}\t\t\t\t#{q.hits[0].q_frame}\t#{q.hits[0].q_beg}\t#{q.hits[0].q_end}\t#{q.hits[0].s_beg.to_i}\t#{q.hits[0].s_end.to_i}\t#{q.hits[0].definition}\t"
-			seq.annotate(:ncrna,nc_annotations,true)
-		else
-			unknown_annot = seq.get_annotations(:tcode_unknown).first
-			seq.annotate(:tcode, unknown_annot[:message],true)
+		if !hit.nil? && hit.align_len >= 40 # There is match in blast and it has a good length.
+			seq.hit = hit
+			seq.type = NCRNA
 		end
 	end
 end

data/lib/full_lengther_next/classes/reptrans.rb

@@ -0,0 +1,210 @@
+require 'scbi_mapreduce'
+require 'my_worker_manager_EST' #Second server
+require 'fln_stats'
+require 'types'
+
+########################################################################
+# MAIN FUNCTION
+########################################################################
+def reptrans(seqs_annotation_prot, seqs_some_coding ,seqs_unknown, options)
+	cpus = count_cpu(options)
+	stats_hash = initialize_stats_hash_reptrans
+	# Paths
+	#---------------------------------------------	
+	main_path = File.join(Dir.pwd, 'fln_results')
+	reptrans_fasta = File.join(main_path, 'Representative_transcriptome.fasta')
+	blast_path = File.join(main_path, 'ESTdb')
+	cluster_prot_annotated_path =File.join(main_path, 'Prot_clusters')
+	cluster_EST_annotated_path =File.join(main_path, 'EST_clusters')
+	html_file = File.join(main_path, 'Representative_transcriptome_stats.html')
+	txt_file = File.join(main_path, 'Representative_transcriptome_stats.txt')
+
+	# Prot annotations sequence analysis
+	#---------------------------------------------
+	analysis_over_DB_annotated_seqs(seqs_annotation_prot, reptrans_fasta, cluster_prot_annotated_path, stats_hash, 'prot_annotated', options[:high_clustering])
+	seqs_annotation_prot = nil
+
+	# NOT Prot annotations sequence analysis
+	#---------------------------------------------
+	putative_seqs = seqs_some_coding	
+	if !options[:est_db].nil? # WITH EST DATABASE
+		putative_seqs += seqs_unknown # Coding & unknown 
+		putative_seqs = reduce_pool_sequences(putative_seqs, main_path, cpus)
+		if !File.exists?(blast_path +'.nsq')
+			$LOG.info "Start makeblastdb over EST DB"
+			system("makeblastdb -in #{options[:est_db]} -out #{blast_path} -dbtype nucl -parse_seqids > #{File.join(main_path, 'log_makeblast_db')}")
+			$LOG.info "Ended makeblastdb over EST DB"
+		end
+		putative_seqs = do_blast_with_EST(putative_seqs, options, reptrans_fasta, blast_path, cluster_EST_annotated_path, stats_hash)
+	end
+
+	# Coding sequence analysis
+	#---------------------------------------------
+	if !putative_seqs.nil? && !putative_seqs.empty?
+		putative_seqs = select_seqs_more_500pb(putative_seqs)
+		putative_seqs = reduce_pool_sequences(putative_seqs, main_path, cpus) if options[:est_db].nil? # NOT EST database
+		putative_seqs.sort!{|s1, s2| #Order by testcode (first) and sequence length (last)
+			if s2.t_code == s1.t_code
+				s2.fasta_length <=> s1.fasta_length
+			else
+				s2.t_code <=> s1.t_code
+			end
+		}
+		count = 0
+		putative_seqs.each do |coding_seq|
+			coding_stats_reptrans(coding_seq, stats_hash)
+			count +=1
+		end
+ 
+		write_fasta(putative_seqs, reptrans_fasta, 'a')
+	end
+	write_reptrans_stats(stats_hash, html_file, txt_file)
+end
+########################################################################
+# END MAIN FUNCTION
+########################################################################
+
+def analysis_over_DB_annotated_seqs(seqs_annotation_DB, reptrans_fasta, cluster_file_path, stats_hash, key_stats, pfam_clustering)
+	clusters_seqs_annot_DB = clustering_by_id(seqs_annotation_DB)
+	representative_seqs_annot_DB = select_representative(clusters_seqs_annot_DB)
+	if pfam_clustering
+		clusters_seqs_annot_DB = clustering_by_annot(representative_seqs_annot_DB, :pfam_id) # pfam id, fix get the annotation guide on my_worker_manager_fln (@@func_annot_type) to this scope
+		representative_seqs_annot_DB = select_representative(clusters_seqs_annot_DB) # merge clusters by id and by pfam
+	end
+	stats_hash[key_stats] += representative_seqs_annot_DB.length
+	report_clustering(cluster_file_path, clusters_seqs_annot_DB, representative_seqs_annot_DB)
+	write_fasta(representative_seqs_annot_DB, reptrans_fasta, 'w')
+end
+
+def	report_clustering(cluster_file_path, clusters_seqs_annot_DB, representative_seqs_annot_DB)
+	cluster_file = File.open(cluster_file_path, 'w')
+	representative_seqs_annot_DB.each_with_index do |rep_seq, i|
+		cluster_seqs = clusters_seqs_annot_DB[i].map{|seq| seq.seq_name}.join(';')
+		cluster_file.puts "#{rep_seq.seq_name}\t#{cluster_seqs}"
+	end
+	cluster_file.close
+end
+
+def reduce_pool_sequences(putative_seqs, main_path, cpu)
+	temp_fasta = File.join(main_path, 'temp.fasta')
+	temp_fasta_clean = File.join(main_path, 'temp_cln.fasta')
+	log_file = File.join(main_path, 'log_cd_hit_Cod_Unk')
+	write_fasta(putative_seqs, temp_fasta, 'w')
+	$LOG.info "Start cd-hit with coding and unknow sequences"	
+	system("cd-hit -i #{temp_fasta} -o #{temp_fasta_clean} -c 0.95 -M 0 -T #{cpu} > #{log_file}") if !File.exists?(temp_fasta_clean)
+	$LOG.info "Ended cd-hit with coding and unknow sequences"	
+	cd_hit_names_putative_seqs = load_cd_hit_sequences_names(temp_fasta_clean)
+	putative_seqs = select_seqs_with_name(putative_seqs, cd_hit_names_putative_seqs)
+	return putative_seqs
+end
+
+def do_blast_with_EST(putative_seqs, options, reptrans_fasta, blast_path, cluster_EST_annotated_path, stats_hash) # Second server to representative transcriptome
+	$LOG.info 'Starting server for EST analysis'
+		custom_worker_file = File.join(File.dirname(ROOT_PATH),'lib','full_lengther_next','classes','my_worker_EST.rb')
+		options[:chimera] = nil #Inactive chimeras system on RepTrans, this resume the BLAST's output
+	
+		MyWorkerManagerEst.init_work_manager(putative_seqs, options, blast_path)
+		server_EST = ScbiMapreduce::Manager.new(options[:server_ip], options[:port], options[:workers], MyWorkerManagerEst, custom_worker_file, STDOUT, FULL_LENGTHER_NEXT_INIT)
+		server_EST.chunk_size = options[:chunk_size]
+		server_EST.start_server
+	$LOG.info 'Closing server for EST analysis'
+
+	seqs_with_EST, putative_seqs = MyWorkerManagerEst.get_array_seqs
+	if !seqs_with_EST.empty?
+		analysis_over_DB_annotated_seqs(seqs_with_EST, reptrans_fasta, cluster_EST_annotated_path, stats_hash, 'est_annotated') 
+	end
+	return putative_seqs
+end
+
+
+def load_cd_hit_sequences_names(file)
+	names=[]
+	File.open(file).readlines.each do |line|
+		if line =~ /^>/
+			line.chomp!
+			line.gsub!('>','')
+			names << line
+		end	
+	end
+	return names
+end
+
+def select_seqs_more_500pb(seqs_array)
+	seqs = seqs_array.select{|seq| seq.fasta_length > 500 }	
+	return seqs
+end
+
+def select_seqs_with_name(array_seqs, array_names)
+	seqs = array_seqs.select{|seq| array_names.include?(seq.seq_name)}
+	return seqs
+end
+
+def write_fasta(seqs_array, file_name, mode)
+	file=File.open(file_name, mode)
+	seqs_array.each do |seq|
+		file.puts ">#{seq.seq_name}\n#{seq.seq_fasta}"
+	end
+	file.close
+end
+
+def clustering_by_id(seqs_with_hit)
+	clusters=[]
+	hit_id=[]
+	seqs_with_hit.each do |seq|
+		position=hit_id.index(seq.get_acc)
+		if position.nil?
+			hit_id << seq.get_acc
+			clusters << [seq]
+		else
+			clusters[position] << seq 
+		end
+	end	
+	return clusters
+end
+
+def clustering_by_annot(seqs_with_hit, annotation_type)
+	clusters = []
+	annot_id = []
+	no_annotation_clusters = []
+	seqs_with_hit.each do |seq|
+		annot = seq.functional_annotations[annotation_type]
+		annot = annot.split(';').sort.join(';') if !annot.nil?
+		if annot == '-' || annot.nil?
+			no_annotation_clusters << [seq]
+		else
+			position = annot_id.index(annot)
+			if position.nil?
+				annot_id << annot
+				clusters << [seq]
+			else
+				clusters[position] << seq 
+			end
+		end
+	end
+	clusters.concat(no_annotation_clusters)
+	return clusters
+end
+
+def select_representative(clusters_seqs_annot_prot)
+	seqs=[]	
+	clusters_seqs_annot_prot.each do |cluster|
+		seq=cluster.select{|s| s.type == COMPLETE}.sort{|fl1, fl2| fl2.seq_fasta <=> fl1.seq_fasta}.first # Take longest full-length, s -> sequence, fl -> full-lentgh
+		if seq.nil?
+			cluster.sort!{|cl1, cl2| cl2.get_pident <=> cl1.get_pident}
+			best_pident=cluster.first.get_pident
+			seq=cluster.select{|s| s.get_pident == best_pident}.sort{|s1, s2| s2.seq_fasta <=> s1.seq_fasta}.first
+		end
+		seqs << seq
+	end
+	return seqs
+end
+
+def count_cpu(options)
+	cpu = 0
+	if options[:workers].class.to_s == 'Array'
+		cpu = options[:workers].length + 1
+	else
+		cpu = options[:workers]
+	end
+	return cpu
+end

data/lib/full_lengther_next/classes/sequence.rb

@@ -1,113 +1,472 @@
-
 require 'orf'
+require 'types'
+require 'warnings'
+require 'common_functions'
 
 class Sequence
 	
-	attr_accessor :seq_name,:seq_fasta,:seq_qual,:orfs,:sec_desc,:fasta_length
-	
-	def initialize(seq_name,seq_fasta,seq_qual='')
-		fasta_ori = seq_fasta.dup
-		@seq_name=seq_name
+	attr_accessor :seq_name, :seq_fasta, :fasta_length, :db_name, :seq_nt, :seq_aa, :db, :type, :status, :id, :orfs, :area_without_annotation, :save_fasta, :ignore, :hit, :t_code, :functional_annotations
+
+	def initialize(seq_name, seq_fasta, seq_qual='')
+		@seq_name = seq_name
 		@seq_fasta = seq_fasta
-		@fasta_length = fasta_ori.length
-		change_degenerated_nt!
-		@seq_qual = ''
-		@sec_desc = ''
+		@fasta_length = seq_fasta.length
+		@db_name = nil
+		@seq_nt = nil # Unigen sequence with tagged ATG & stop
+		@seq_aa = nil # Protein sequence generated over unigen
+		@db =nil
+		@type = UNKNOWN # See types.rb
+		@status = FALSE # TRUE => Sure, FALSE => Putative
+		@id = nil #Prot or EST id, can be several => array
+		@warnings = []
 		@annotations=[]
+		@functional_annotations = {}
 		@orfs=[]
 		
-		@rejected=false
-		@rejected_message=''
-		
+		@area_without_annotation=FALSE
+		@save_fasta=TRUE
+		@ignore=FALSE 
+		@hit=nil
+		@t_code=0
 	end
+
 	
-	def add_orf(orf_seq, orf_t_start, orf_t_end, orf_frame, orf_stop_codon, orf_type)
-		orf = Orf.new(orf_seq, orf_t_start, orf_t_end, orf_frame, orf_stop_codon, orf_type)
-		@orfs.push orf
+	def add_orf(orf_seq, orf_t_start, orf_t_end, orf_q_frame, orf_stop_codon, orf_type)
+		orf = Orf.new(orf_seq, orf_t_start, orf_t_end, orf_q_frame, orf_stop_codon, orf_type)
+		@orfs << orf
+	end
 		
+
+	def change_degenerated_nt!	
+		translate_hash = {}
+		translate_hash['R']= [['a','g'],0]
+		translate_hash['W']= [['a','t'],0]
+		translate_hash['M']= [['a','c'],0]
+		translate_hash['K']= [['g','t'],0]
+		translate_hash['S']= [['g','c'],0]
+		translate_hash['Y']= [['c','t'],0]
+		translate_hash['H']= [['a','t','c'],0]
+		translate_hash['B']= [['g','t','c'],0]
+		translate_hash['D']= [['g','a','t'],0]
+		translate_hash['V']= [['g','a','c'],0]
+		translate_hash['N']= [['g','a','c','t'],0]
+
+
+		fix_degenerated_fasta!(translate_hash)		
 	end
+
 	
-	def rejected?
-		return @rejected
+	def fix_degenerated_fasta!(translate_hash)
+		s = @seq_fasta
+		res = []
+
+		nts_of_a_line = s.split('')
+
+		nts_of_a_line.map{|e|
+
+			if (e =~ /[RWMKSYHBDVN]/)
+				translate_hash[e][1] += 1
+				e = translate_hash[e][0][translate_hash[e][1]%translate_hash[e][0].length]
+			end
+
+			res << e
+
+		}
+
+		@seq_fasta=res.compact.join
 	end
-	
-	def reject!(message='')
-		@rejected=true
-		@rejected_message=message
+  
+	def clean_orfs
+		@orfs=[]
 	end
-		
-	# :complete, :tmp_annotation, :error, :protein, :nucleotide, :alignment, :tcode
-	def get_annotations(annotation_type)
-		return @annotations.select{|a| a[:annotation_type]==annotation_type}
+
+	def reset_classification
+		@type = UNKNOWN
+		@status = FALSE
+	end
+
+	def clean_warnings
+		@warnings = []
+	end
+
+	def clean_annotations
+		@annotations = []
+	end
+
+	def get_acc
+		acc=hit.acc
+		return acc
+	end
+
+	def get_pident
+		pident=hit.ident
+		return pident
+	end
+
+	def format_chimera!
+		@hit = []
 	end
 	
-	def annotate(annotation_type, message='', replace_existing = false)
+	def warnings(warn)
+		if warn.class.to_s == 'Array'
+			warn.each do |w|
+				@warnings << check_warn(w)
+			end
+		else
+			@warnings << check_warn(warn)
+		end
+	end
 
-		if replace_existing
-			@annotations.reverse_each do |annotation| 
-				if annotation[:annotation_type]==annotation_type
-					@annotations.delete(annotation)
-				end
+	def clone_warnings(array_warnings)
+		array_warnings.map{|warn| @warnings << warn.dup}
+	end
+
+	def check_warn(warn)
+		check = warn
+		replace = nil
+		if warn.class.to_s == 'Array'
+			check = warn.shift # Take warning tag message
+			replace = warn # Take values to replace in message
+		end
+
+		message = $warnings_hash[check]
+		if message.nil?
+			message = check # If not exists the message
+		end
+
+		if !replace.nil?
+			message = message.dup # Duplicate memory to avoid overwrite original warning hash messages
+			replace.each do |rep|
+				message.sub!('(*replace*)',"#{rep}") #message variable
 			end
 		end
-		
-		
-		@annotations.push({:annotation_type=>annotation_type,:message=>message})
+		return message
 	end
-	
-	def change_degenerated_nt!
-		
-		
-		########################################
-
-		tranlaste_hash = {}
-		tranlaste_hash['R']= [['a','g'],0]
-		tranlaste_hash['W']= [['a','t'],0]
-		tranlaste_hash['M']= [['a','c'],0]
-		tranlaste_hash['K']= [['g','t'],0]
-		tranlaste_hash['S']= [['g','c'],0]
-		tranlaste_hash['Y']= [['c','t'],0]
-		tranlaste_hash['H']= [['a','t','c'],0]
-		tranlaste_hash['B']= [['g','t','c'],0]
-		tranlaste_hash['D']= [['g','a','t'],0]
-		tranlaste_hash['V']= [['g','a','c'],0]
-		tranlaste_hash['N']= [['g','a','c','t'],0]
-
-		########################################
-
-		fix_degenerated_fasta!(tranlaste_hash)
-		
-		
+
+	def test_code(test_code)
+		@t_code = test_code
+		if @t_code >= 0.95
+			@status = TRUE
+		end
 	end
-	
-	def fix_degenerated_fasta!(tranlaste_hash)
-		s = @seq_fasta
-		res = []
 
-		nts_of_a_line = s.split('')
+	def get_fasta(seq)
+		fasta = ">#{@seq_name}\n#{seq}"
+		return fasta
+	end
 
-		nts_of_a_line.map{
-			|e|
-			# puts "#{e} "
+	def write_info(output_files) # Output_files is a hash
+		if @save_fasta
+			output_files['seqs'].puts get_fasta(@seq_fasta)	
+		end
+		case @type
+		when OTHER
+			write_other(output_files[@type])
+		when CHIMERA
+			write_chimera(output_files[@type])
+		when MISASSEMBLED
+			write_misassembled(output_files[@type])
+		when UNKNOWN
+			write_unknown(output_files[@type])
+		when COMPLETE .. INTERNAL
+			write_prot_annot(output_files['db'])
+			write_prot_seq(output_files['prot'])
+			write_nt_seq(output_files['nts'])
+			write_align(output_files['align'])
+		when NCRNA
+			write_ncrna(output_files[@type])
+		when CODING
+			write_coding(output_files[@type])
+		else
+			if @type != FAILED
+				raise "#{@type} is an incorrect type"
+			end
+		end
+	end
 
-			if (e =~ /[RWMKSYHBDVN]/)
+	def all_warns
+		all = @warnings.join(' ')
+		return all
+	end
 
-				# puts "#{e} "
-				tranlaste_hash[e][1] += 1
-				# puts "#{e}  #{tranlaste_hash[e][1]}"
+	def write_other(file)
+		file.puts "#{@seq_name}\t#{@fasta_length}\t#{@hit.acc}\t#{@db_name}\t#{all_warns}"
+	end
 
-				e = tranlaste_hash[e][0][tranlaste_hash[e][1]%tranlaste_hash[e][0].length]
+	def write_chimera(file) #TODO : write 'SOLVED' tag
+		@hit.each do |h|
+			file.puts "#{@seq_name}\t#{@fasta_length}\t#{h.acc}\t#{@db_name}\t#{h.q_frame}\t#{h.e_val}\t#{h.ident}\t#{h.q_beg + 1}\t#{h.q_end + 1}\t#{h.s_beg + 1}\t#{h.s_end + 1}\t#{h.definition}"
+		end
+		file.puts
+	end
+
+	def write_misassembled(file)
+		file.puts "#{@seq_name}\t#{@fasta_length}\t#{@hit.acc}\t#{@db_name}"
+	end
+
+	def write_unknown(file)
+		# ħit is an array. 2 => q_frame, 1 ORF end, 0 ORF beg
+		if hit.class.to_s == 'Array'
+			orf_beg = @hit[0]
+			orf_end = @hit[1]
+			q_frame = @hit[2]		
+		else 
+			orf_beg = '-'
+			orf_end = '-'
+			q_frame = '-'
+		end
+		file.puts "#{@seq_name}\t#{@fasta_length}\t#{@t_code}\t#{all_warns}\t#{q_frame}\t#{orf_beg}\t#{orf_end}"
+	end
+
+	def write_prot_annot(file)
+		final_func_annot = Array.new(9, '-')
+		if !@functional_annotations.empty?
+			final_func_annot = @functional_annotations.values
+		end
+		file.puts "#{@seq_name}\t#{@fasta_length}\t#{@hit.acc}\t#{@db_name}\t#{prot_annot_calification}\t#{@hit.e_val}\t#{@hit.ident}\t#{@hit.full_subject_length}\t#{@seq_aa.length}\t#{all_warns}\t#{@hit.q_frame}\t#{@hit.q_beg + 1}\t#{@hit.q_end + 1}\t#{@hit.s_beg + 1}\t#{@hit.s_end + 1}\t#{@hit.definition}\t#{final_func_annot.join("\t")}"
+	end
+
+	def write_ncrna(file)
+		file.puts "#{@seq_name}\t#{@fasta_length}\t#{@hit.acc}\t#{@hit.e_val}\t#{@hit.ident}\t#{@hit.q_beg + 1}\t#{@hit.q_end + 1}\t#{@hit.s_beg + 1}\t#{@hit.s_end + 1}\t#{@hit.definition}"
+	end
+
+	def write_coding(file)
+		# ħit is an array. 2 => q_frame, 1 ORF end, 0 ORF beg 
+		calification = 'Putative'
+		if @status
+			calification = 'Sure'
+		end
+		file.puts "#{@seq_name}\t#{@fasta_length}\t#{calification}\t#{@t_code}\t#{@hit.last}\t#{@hit.first}\t#{@hit[1]}"
+	end
+
+	#Write complementary files
+	def write_prot_seq(file)
+		file.puts get_fasta(@seq_aa)
+	end
+
+	def write_align(file)
+		tabs = (seq_name.length/8).ceil
+		if tabs == 0
+			tabs = 1
+		end
+		second_tab = 0
+		if seq_name.length > 7
+			second_tab = 1
+		end
+		file.puts "#{@seq_name}#{"\t"*tabs}#{@hit.q_seq}\n#{@hit.acc}#{"\t"*(tabs+second_tab)}#{@hit.s_seq}"
+		file.puts
+	end
+
+	def write_nt_seq(file)
+		file.puts "#{@seq_name}\t#{@fasta_length}\t#{@seq_nt}"
+	end
+
+	def calification
+		type_description = nil
+		case @type
+			when FAILED
+				type_description = 'Failed'
+			when OTHER
+				type_description = 'Other'
+			when CHIMERA
+				type_description = 'Chimera'
+			when MISASSEMBLED
+				type_description = 'Misassembled'
+			when UNKNOWN
+				type_description = 'Unknown'
+			when COMPLETE
+				type_description = 'Complete'
+			when N_TERMINAL 
+				type_description = 'N_terminal'
+			when C_TERMINAL
+				type_description = 'C_terminal'
+			when INTERNAL
+				type_description = 'Internal'
+			when CODING
+				type_description = 'Coding'
+			when NCRNA
+				type_description = 'NcRNA'
+		end
+
+	end
+
+	def prot_annot_calification
+		info = "#{calification} "	
+		if @status
+			info << 'Sure'
+		else
+			info << 'Putative'
+		end
+		return info
+	end
+
+	def show_alignment(h, nts, show_nts, original_query_coordinates = nil)
+		puts "Prot id:\t#{h.acc}", "Alignment length:\t#{h.align_len} aa", "Subject   length:\t#{h.s_len} aa", "Query length:\t#{nts.length/3} aa"
+		puts prot_annot_calification
+		puts
+
+		aa_unigen = nts[h.q_frame - 1 .. nts.length-1].translate
+		index = contenidos_en_prot(h.q_seq, aa_unigen)
+
+		# View desplacements 5-prime/align/3-prime
+		subzone_align = nil
+		if !original_query_coordinates.nil?
+			subzone_align = {}
+			if h.q_beg > original_query_coordinates.first #alignment has transferred characters to 5 prime
+				subzone_align['beg'] = [original_query_coordinates.first, h.q_beg-3, 42] # -3 to exclude the last aa
+			elsif h.q_beg < original_query_coordinates.first
+				subzone_align['beg'] = [h.q_beg, original_query_coordinates.first-3, 46] #alignment has received characters from 5 prime
+			end
 
-				# puts "#{e}"
+			if h.q_end < original_query_coordinates.last #alignment has transferred characters to 3 prime
+				subzone_align['end'] = [h.q_end, original_query_coordinates.last, 42]
+			elsif h.q_end > original_query_coordinates.last
+				subzone_align['end'] = [original_query_coordinates.last, h.q_end, 43] #alignment has received characters from 3 prime
 			end
+		end
 
-			res.push e
+		# Print 5 prime
+		if index > 0 # 5 prime  exists
+			aa_align = aa_unigen[0 .. index-1].split('')
+			nt_align = nts[h.q_frame-1..h.q_beg-1]
+			print_alignment(aa_align, nt_align, 36, show_nts, subzone_align)
+			reduce_coordinates(subzone_align, aa_align, h)
+		end
 
-		}
+		# Print core alignment or protein
+		aa_align = h.q_seq.split('')
+		nt_align = nts[h.q_beg..h.q_end]
+		print_alignment(aa_align, nt_align, 32, show_nts, subzone_align)
+		reduce_coordinates(subzone_align, aa_align, h)
+
+		# Print 3 prime
+		gaps = h.q_seq.count('-')
+		three_prime_beg = index+h.q_seq.length-gaps
+		if aa_unigen.length > three_prime_beg # 3 prime  exists
+			aa_align = aa_unigen[three_prime_beg .. aa_unigen.length-1].split('')
+			fs = check_frame_shift(h)
+			nt_align = nts[h.q_end+1-fs..nts.length-1]
+			print_alignment(aa_align, nt_align, 33, show_nts, subzone_align)
+		end
 
-		@seq_fasta=res.compact.join
-		# @seq_fasta='dario'
 	end
-  
-	
-end
+
+
+	def print_alignment(aa_align, nt_align, color, show_nts, mark_subzone = nil)
+		original_color = color
+		c={	'GCT'=>'A','GCC'=>'A','GCA'=>'A','GCG'=>'A',
+			'CGT'=>'R','CGC'=>'R','CGA'=>'R','CGG'=>'R','AGA'=>'R','AGG'=>'R',
+			'AAT'=>'N','AAC'=>'N',
+			'GAT'=>'D','GAC'=>'D',
+			'TGT'=>'C','TGC'=>'C',
+			'CAA'=>'Q','CAG'=>'Q',
+			'GAA'=>'E','GAG'=>'E',
+			'GGT'=>'G','GGC'=>'G','GGA'=>'G','GGG'=>'G',
+			'CAT'=>'H','CAC'=>'H',
+			'ATT'=>'I','ATC'=>'I','ATA'=>'I',
+			'TTA'=>'L','TTG'=>'L','CTT'=>'L','CTC'=>'L','CTA'=>'L','CTG'=>'L',
+			'ATG'=>'M',
+			'AAA'=>'K','AAG'=>'K',
+			'TTT'=>'F','TTC'=>'F',
+			'CCT'=>'P','CCC'=>'P','CCA'=>'P','CCG'=>'P',
+			'TCT'=>'S','TCC'=>'S','TCA'=>'S','TCG'=>'S','AGT'=>'S','AGC'=>'S',
+			'ACT'=>'T','ACC'=>'T','ACA'=>'T','ACG'=>'T',
+			'TGG'=>'W',
+			'TAT'=>'Y','TAC'=>'Y',
+			'GTT'=>'V','GTC'=>'V','GTA'=>'V','GTG'=>'V',
+			'TAG'=>'*','TGA'=>'*','TAA'=>'*'}
+		
+		nt_line = ''
+		aa_line = ''
+		gaps = 0
+		count = 0
+		aa_align.each_with_index do |aa, n|
+			if aa == '-'
+				nt_line << '---'
+				gaps += 1
+			else
+				# Check aa with codon
+				codon_window = (n-gaps)*3
+				codon = nt_align[codon_window..codon_window+2]
+				nt_line << "#{codon}"
+				if aa.upcase != 'X' 
+					if codon.upcase.include?('N')
+						traslated_aa = '-'
+					else	
+						traslated_aa = c[codon]
+					end
+					if traslated_aa != '-' && traslated_aa != aa
+						puts "#{traslated_aa} #{aa}"
+						aa = '?'
+					end
+				end
+			end
+			if !mark_subzone.nil?
+				nts_coordenate = (n-gaps)*3
+				mark_subzone.values.each do |subzone|
+					if nts_coordenate >= subzone[0] && nts_coordenate <= subzone[1] #0 => first coordenate, 1 => second coordenate
+						color = subzone.last
+					end
+				end
+			end
+			space = nil
+			if show_nts
+				space = ' '
+			end
+			aa_line << "\e[#{color}m#{space}#{aa}#{space}\e[0m"
+			color = original_color
+			line_length = 60
+			if (n+1) % line_length == 0 || n+1 == aa_align.length
+				count = n + 1
+				print "#{count}\t"
+				puts aa_line
+				if show_nts
+					print "#{count*3}\t"
+					puts nt_line
+				end
+				aa_line = ''
+				nt_line = ''
+			end
+		end
+
+	end
+
+	def reduce_coordinates(subzone_align, aa_align, h)
+		if !subzone_align.nil?
+			aligned = 3 * aa_align.length + h.q_frame-1
+			subzone_align.values.each do |subzone|
+				subzone[0]-= aligned 
+				subzone[1]-= aligned 
+			end
+		end
+	end
+
+	def area_without_annotation?
+		if @hit.class == Array
+			hit = @hit.first
+		else
+			hit = @hit
+		end
+		upstream_annotation_space = hit.q_beg 
+		downstream_annotation_space = @fasta_length - hit.q_end
+		if upstream_annotation_space >= 150 || downstream_annotation_space >= 150
+			@area_without_annotation = TRUE
+		end
+		return @area_without_annotation
+	end
+
+	def clone
+		new_seq = self.dup
+		new_seq.clean_annotations
+		new_seq.clean_warnings
+		new_seq.clean_orfs
+		new_seq.clone_warnings(@warnings)
+		new_seq.clone_annotations(@annotations)
+		return new_seq
+	end
+
+	def clone_annotations(array_annotations)
+		array_annotations.map{|annotation| @annotations << annotation.dup}
+	end
+
+end