Viromics Pipeline

Note that this workflow is continually being updated. If you want to use the below commands be sure to keep track of them locally.

Last updated: 25 April 2018

Important points to keep in mind:

• The below options are not necessarily best for your data; it is important to explore different options, especially at the read quality filtering stage.
• If you are confused about a particular step be sure to check out the pages under Metagenomic Resources on the right side-bar.
• You should check that only the FASTQs of interest are being specified at each step (e.g. with the ls command). If you are re-running commands multiple times or using optional steps the input filenames and/or folders could differ.
• The tool parallel comes up several times in this workflow. Be sure to check out our tutorial on this tool here.
• You can always run parallel with the --dry-run option to see what commands are being run to double-check they are doing what you want!

This workflow starts with raw paired-end MiSeq or NextSeq data in demultiplexed FASTQ format assumed to be located within a folder called raw_data

This pipeline was adapted from Anderson, C. L., Sullivan, M. B. & Fernando, S. C. Dietary energy drives the dynamic response of bovine rumen viral communities. Microbiome 5, 155 (2017).

1. (Optional) Concatenate multiple lanes of sequencing together (e.g. for NextSeq data). If you do this step remember to change raw_data to concat_data below.

concat_lanes.pl raw_data/* -o concat_data -p 4

2. Run fastqc to allow manual inspection of the quality of sequences.

mkdir fastqc_out
fastqc -t 4 raw_data/* -o fastqc_out/

3. Stitch paired-end reads together (summary of stitching results are written to "pear_summary_log.txt"). Note: it is important to check the % of reads assembled. It may be better to concatenate the forward and reverse reads together if the assembly % is too low (see step 6 of our MGS SOP for more information)

run_pear.pl -p 4 -o stitched_reads concat_data/*

If you don't stitch your reads together at this step you will need to unzip your FASTQ files before running the below command.

4. Use kneaddata to run pre-processing tools. First Trimmomatic is run to remove low quality sequences. Then Bowtie2 is run to screen out contaminant sequences. Below we are screening out reads that map to the human or PhiX genomes. Note kneadData is being run below on all FASTQ pairs with parallel, you can see our quick tutorial on this tool here. For a detailed breakdown of the options in the below command see this page. The forward and reverse reads will be specified by "_1" and "_2" in the output files, ignore the "R1" in each filename. Note that the \ characters at the end of each line are just to split the command over multiple lines to make it easier to read.

parallel -j 1 --link 'kneaddata -i {1} -i {2} -o kneaddata_out/ \
-db /home/shared/bowtiedb/GRCh38_PhiX --trimmomatic /usr/local/prg/Trimmomatic-0.36/ \
-t 4 --trimmomatic-options "SLIDINGWINDOW:4:20 MINLEN:50" \
--bowtie2-options "--very-sensitive --dovetail" --remove-intermediate-output' \
 ::: raw_data/*_R1.fastq ::: raw_data/*_R2.fastq

You can produce a logfile summarizing the kneadData output with this command:

kneaddata_read_count_table --input kneaddata_out --output kneaddata_read_counts.txt

5. Use metaSPAdes to cross-assemble all FASTQ files from step 4. You will have to first generate a yaml file with your fastq paired file names. See more on metaSPAdes usage here.

python metaspades.py --dataset your_yaml_file.yaml -t THREADS -m MAX MEMORY USAGE (GB) -k 21,33,55,77,99,127 -o assembled_viral_contigs

6. Use VirFinder to predict viral contigs. This is an R package that can be downloaded here.

## In R-Studio / R command line
VirFinder_result <- VF.pred("scaffolds.fasta")
VirFinder_result$qvalue <- VF.qvalue(VirFinder_result$pvalue)
write.table(VLP_MRN_april_17_VF_result, 
            "/path/to/your/wdir/VirFinder_result.txt", quote=FALSE, row.names=FALSE, col.names=TRUE, sep="\t")

7. Filter out contig names with a p-value greater than 0.05 and q-value greater than 0.1, and use reformat_fasta_edit.py to get desired contigs.

awk '$4 <= 0.05' VirFinder_result.txt > VirFinder_result_pval.txt

awk '$5 <= 0.1' VirFinder_result_pval.txt > VirFinder_result_pval_qval.txt

reformat_fasta_edit.py -f scaffolds.fasta --ids2keep VirFinder_result_pval_qval.txt > VirFinder_scaffolds.fasta

8. Use VirSorter to identify further viral contigs from your cross-assembled samples. We found that the CyVerse iteration of VirSorter worked best compared to the command line (Miniconda or docker) versions.

9. Concatenate VirFinder and VirSorter (found in Predicted_viral_sequences in VirSorter folder) contigs.

cat VirFinder_scaffolds.fasta VirSorter_scaffolds.fasta > VirFinder_VirSorter_scaffolds.fasta

9b. Filter the resulting concatenated file for redundancy with cd-hit

cd-hit -i VF_VS_contigs.fna -o VF_VS_contigs_cd_hit.fna -c 1.0 -T threads -M memory (in MB)

10. Use Metabat2 to bin viral contigs.

First, create BAM files by aligning the reads of each sample separately to the assembled metagenome (in this case, VirFinder_VirSorter_scaffolds.fasta).

bowtie2-build -f --threads 40 VirFinder_VirSorter_scaffolds.fasta VF_VS_contigs_ref

parallel -j 40 --link 'bowtie2 -q --sensitive-local -x VF_VS_contigs_ref -1 {1} -2 {2} -S {1.}.sam' ::: /home/casey/local/SPAdes-3.11.1/MRN-1-4-7-10-14-17-fastqs/*_1.fastq ::: /home/casey/local/SPAdes-3.11.1/MRN-1-4-7-10-14-17-fastqs/*_2.fastq

Convert SAM to BAM then sort BAMs (Tutorial here).

parallel -j 40 'samtools view -S -b {} > {.}.bam' ::: *sam

parallel -j 40 'samtools sort {} -o {.}.sorted.bam' ::: *bam

Generate a depth file from BAM files for input into Metabat

./jgi_summarize_bam_contig_depths --outputDepth depth.txt *.bam

Run metabat for binning. See here for metabat usage and options. Parameters used as described in Anderson et al., 2017, Microbiome.

metabat --inFile VF_VS_contigs.fna --outFile bins/VFVS_contigs --abdFile depth.txt --minContig=1500 --minClsSize=10000 -t 40 --unbinned

CheckM can be used to assess bin quality.

11. Determine abundances of viral populations (bins) by mapping sample reads to bins, using Bowtie2. Adapted from tutorial written by Jin Choi for EDAMAME2016.

Build bowtie database with bins

bowtie2-build -f --threads 40 <Comma separated list of bins from metabat> <reference-db-name>

Run Bowtie2. Use paired fastq files as input against database created in last step with bins.

parallel -j <THREADS> --link 'bowtie2 -q --sensitive-local -x <reference-db?> -1 {1} -2 {2} -S {1.}.sam' ::: path/to/QCed/fastq/*_1.fastq ::: path/to/QCed/fastq/*_2.fastq

Index reference contigs with samtools (in this case, the concatenated VirSorter and VirFinder contigs file <VF_VS_contigs.fna>).

samtools faidx VF_VS_contigs.fna

Convert SAM files to BAM, sort, then index BAM files for quicker downstream processsing, . See here for more on SAM/BAM.

parallel -j 40 'samtools import VF_VS_contigs.fna.fai {} {.}.bam' ::: *sam 

parallel -j 40 'samtools sort {} -o {.}.sorted.bam' ::: *bam

parallel -j 40 'samtools index {}' ::: *sorted.bam

Make summary of mapped read counts

parallel -j 40 'samtools idxstats {} > {.}.idxstats.txt' ::: *sorted.bam

Use scripts from Jin Choi to process these files into one table. Note that python2.7 must be used to run the below script. You can create a miniconda environment for python2.7 using the instructions here.

git clone https://github.com/metajinomics/mapping_tools.git
python mapping_tools/get_count_table.py *.idxstats.txt > counts.txt
less counts.txt

Create a mapping file that will map contig names to bins.

To get a file that links contig names to each bin, add header to this file:

echo “bin contig” > bins2contigs.txt

Parse out all the headerlines (lines starting with “>”) from each bin fasta, assuming they end in “fa”

grep -H “>” *fa >> bins2contigs.txt

Replace all instances of “.fa:>” in this file with spaces

sed -i ‘s/.fa:>/ /g’ bins2contigs.txt

In R, collapse contigs to bin names. counts.txt should be a file with contig names in the first column, and sample names in the following columns with read mapping abundances as rows. bins2contigs.txt should be a two-column file with bins in the first column and contigs in the next.

#Change to dataframe
counts <- as.data.frame(counts)
bins2contigs <- as.data.frame(bins2contigs)

#Set rownames as contigs in both dataframes
rownames(counts) <- counts$contig
rownames(bins2contigs) <- bins2contigs$contig
counts$bins <- bins2contigs[rownames(counts), "bins"]

# Remove first column
counts <- counts[, -1]
bin_abundances <- aggregate(. ~ bins, counts, sum)

#Export bin_abundances as text file. This resulting file can be analyzed like an OTU table. 
write.table(bin_abundances_new, "/home/casey/local/SPAdes-3.11.1/MRN-1-4-7-10-14-17-fastqs/sam_readmapping_VFVS/R/bin_abundances.txt", 
            quote=FALSE, row.names=FALSE, col.names=TRUE, sep="\t")

12. Normalize bin abundances based on length of bin and total number of reads in a given sample.

First, get length (in BP) of bins

parallel -j 40 'grep "^[ACGTN]" {} | tr -d "\n" | wc -m > {.}_length.txt' ::: *fa
cat *.txt > cat_text.txt
ls *txt > bin_names

In Excel or R, combine bin_names and cat_text to generate a 2-column table of bins and their respective length.

In R, divide rows of bin abundance table (bin_abundances) by bin length (using bin_lengths as a mapping file) and columns by column sums.

bin_abundances_rownamed <- bin_abundances
rownames(bin_abundances_rownamed) <- bin_abundances$bin
rownames(bin_lengths) <- bin_lengths$bin

bin_abundances_rownames <- bin_abundances_rownamed[as.character(bin_lengths$bin),]
bin_abundances_rownames <- bin_abundances_rownames[,-1]

bin_abundances_norm <- (bin_abundances_rownames/bin_lengths$Length)
bin_abundances_norm_colsum <- data.frame(sweep(bin_abundances_norm, 2, colSums(bin_abundances_norm), '/'))