def run(self):
super(JobConsensus, self).run()
if not os.path.isdir(self.consensus_dir):
os.mkdir(self.consensus_dir)
#split into 1Mb chunks to reduce RAM usage
CHUNK_SIZE = 1000000
chunks_file = os.path.join(self.consensus_dir, "chunks.fasta")
chunks = aln.split_into_chunks(fp.read_sequence_dict(self.in_contigs),
CHUNK_SIZE)
fp.write_fasta_dict(chunks, chunks_file)
logger.info("Running Minimap2")
out_alignment = os.path.join(self.consensus_dir, "minimap.bam")
aln.make_alignment(chunks_file,
self.args.reads,
self.args.threads,
self.consensus_dir,
self.args.platform,
out_alignment,
reference_mode=True,
sam_output=True)
contigs_info = aln.get_contigs_info(chunks_file)
logger.info("Computing consensus")
consensus_fasta = cons.get_consensus(out_alignment, chunks_file,
contigs_info, self.args.threads,
self.args.platform)
#merge chunks back into single sequences
merged_fasta = aln.merge_chunks(consensus_fasta)
fp.write_fasta_dict(merged_fasta, self.out_consensus)
os.remove(chunks_file)
os.remove(out_alignment)
def polish(contig_seqs, read_seqs, work_dir, num_iters, num_threads,
error_mode, output_progress):
"""
High-level polisher interface
"""
logger_state = logger.disabled
if not output_progress:
logger.disabled = True
subs_matrix = os.path.join(
cfg.vals["pkg_root"], cfg.vals["err_modes"][error_mode]["subs_matrix"])
hopo_matrix = os.path.join(
cfg.vals["pkg_root"], cfg.vals["err_modes"][error_mode]["hopo_matrix"])
stats_file = os.path.join(work_dir, "contigs_stats.txt")
prev_assembly = contig_seqs
contig_lengths = None
coverage_stats = None
for i in xrange(num_iters):
logger.info("Polishing genome ({0}/{1})".format(i + 1, num_iters))
#split into 1Mb chunks to reduce RAM usage
#slightly vary chunk size between iterations
CHUNK_SIZE = 1000000 - (i % 2) * 100000
chunks_file = os.path.join(work_dir, "chunks_{0}.fasta".format(i + 1))
chunks = split_into_chunks(fp.read_sequence_dict(prev_assembly),
CHUNK_SIZE)
fp.write_fasta_dict(chunks, chunks_file)
####
logger.info("Running minimap2")
alignment_file = os.path.join(work_dir,
"minimap_{0}.sam".format(i + 1))
make_alignment(chunks_file,
read_seqs,
num_threads,
work_dir,
error_mode,
alignment_file,
reference_mode=True,
sam_output=True)
#####
logger.info("Separating alignment into bubbles")
contigs_info = get_contigs_info(chunks_file)
bubbles_file = os.path.join(work_dir,
"bubbles_{0}.fasta".format(i + 1))
coverage_stats, mean_aln_error = \
make_bubbles(alignment_file, contigs_info, chunks_file,
error_mode, num_threads,
bubbles_file)
logger.info("Alignment error rate: {0}".format(mean_aln_error))
consensus_out = os.path.join(work_dir,
"consensus_{0}.fasta".format(i + 1))
polished_file = os.path.join(work_dir,
"polished_{0}.fasta".format(i + 1))
if os.path.getsize(bubbles_file) == 0:
logger.info("No reads were aligned during polishing")
if not output_progress:
logger.disabled = logger_state
open(stats_file, "w").write("#seq_name\tlength\tcoverage\n")
open(polished_file, "w")
return polished_file, stats_file
#####
logger.info("Correcting bubbles")
_run_polish_bin(bubbles_file, subs_matrix, hopo_matrix, consensus_out,
num_threads, output_progress)
polished_fasta, polished_lengths = _compose_sequence(consensus_out)
merged_chunks = merge_chunks(polished_fasta)
fp.write_fasta_dict(merged_chunks, polished_file)
#Cleanup
os.remove(chunks_file)
os.remove(bubbles_file)
os.remove(consensus_out)
os.remove(alignment_file)
contig_lengths = polished_lengths
prev_assembly = polished_file
#merge information from chunks
contig_lengths = merge_chunks(contig_lengths, fold_function=sum)
coverage_stats = merge_chunks(coverage_stats,
fold_function=lambda l: sum(l) / len(l))
with open(stats_file, "w") as f:
f.write("#seq_name\tlength\tcoverage\n")
for ctg_id in contig_lengths:
f.write("{0}\t{1}\t{2}\n".format(ctg_id, contig_lengths[ctg_id],
coverage_stats[ctg_id]))
if not output_progress:
logger.disabled = logger_state
return prev_assembly, stats_file