# Pooling data in metagenome assembly

I have 12 human gut microbiome WGS Nextseq reads (151 bp paired end). What will be an effective strategy to assemble a metagenome?

Let us say I have already filtered the fastq for quality, adapter sequence and host contamination (human, in this case).

1) Should I concatenate all the R1 reads as one single R1 read and one Single R2 read?

cat Sample[1..12].R1 > Single_R1.fastq
cat Sample[1..12].R2 > Single_R2.fastq


and then use Diginorm to normalize the Single_R1.fastq and Single_R2.fastq. Subsequently, feed these fastq files into any metagenome assembler such as Megahit, MetaSPAdes?

Normalize the output by using CD-HIT or similar tool to remove duplicates and filter by contig length.

OR

2) Perform metagenome assembly for each of the samples individually after applying filtering, removing adapters and host contamination.

R1=(*_R1_001.filtered.fastq)
R2=(*_R2_001.filtered.fastq)
for ((i=0;i<=${#R1[@]};i++)); do /bin/metagenome-assembler -1 "${R1[i]}" -2 "${R2[i]}" -o${R1[i]%.*}.contigs.fa;
done


Followed by combining all the contigs.fa into one mega_contigs.fa

cat *.contigs.fa > Mega_contigs.fa


and use CD-HIT or similar tool to remove duplicates.

• I think assembling data separately is better idea, since there will more noise in combined signals of different individuals and also resource wise. However, I guess you should not just cat assemblies together, you want to avoid redundancy (discard what is shared between individuals), not entirely sure how to achieve that though. Jul 1, 2017 at 14:47

With metagenomes, there's several strategies and no one-size-fits-all. You can spend a lot of time playing with the data to try to get the "best assembly." But it depends on what you're trying to do, e.g. whether or not you are mostly interested in the highest abundant species or are interested in the less abundant ones too.

But to propose a strategy that seems reasonable and hasn't been mentioned yet, my initial thoughts are that since the gut microbiome isn't complex, you can likely get decent assemblies from each run separately. Then you can run a contig clustering algorithm (e.g. MetaBAT) to bin the contigs into genomes. Next compare the bins from the various assemblies (i.e. cluster the clusters).

It may or may not be worth the trouble to try to combine the related bins' contigs into a consensus (pan)genome sequence. If you want to, methods that have been used successfully include shredding the contigs into overlapping chunks and assembling with an OLC assembler. But if you're interested in KO:read-counts (for example), a consensus genome sequence isn't really required. Cross-mapping the unassembled reads can be useful too (i.e. a sample may have a low-abundance OTU that doesn't produce good contigs, but it can be associated with an OTU that is better assembled in another sample).

If you provide more detail on your goal, I can comment further.

If your goal is to bin the resulting contigs into genomes, then you should do option #1, pooling the reads and assembling into one set of contigs.

I also think pooling is the better option, followed by partitioning by coverage/taxonomy of contigs.

Maybe check out BlobTools, which helps with filtering read-pairs by taxonomy of contigs they contribute to and also does nice visualisations of assemblies.

Workflow B seems to be what you want.

Disclaimer: I am the developer of this tool.