After struggling with Canu version 1.6 to assemble a highly repetitive and large (1 Gbp) fungal genome in 2018 (doi: https://doi.org/10.1101/2020.03.18.996108) – (PBS-Pro grid options), I was expecting a similar process when I began a new fungal assembly recently.
I decided to test the latest version (2.0) with an 800 Mbp genome and 200X PacBio coverage. Using the same script that was used for assembling a dihaploid genome for myrtle rust (which took 4.5 months) this latest assembly took just over a week! Very excited to have such a quick turnaround.
The output looks promising with good busco results of over 94% complete gene models. Apart from the canu version and species difference another variable was the coverage available. Previously we had 70X starting coverage.With this success I decided to re-run the myrtle rust genome assembly and this time it took a week and the statistics are very similar to the original output.
I did not have to go into the shell scripts to resubmit jobs, as I had to for the first assembly. This time it ran relatively cleanly from the beginning to end.
Using Canu v1.6 this stage has taken 2 months so far with 351 jobs. There are 28 jobs still to run on the University of Sydney HPC, Artemis. Each job requires around 10GB memory, 4 cpus, and a progressive amount of walltime. Starting from only about 5 hours to about 150 hours of walltime for the last 100 jobs.
I have detailed this previously but the genome is predicted to be 1.3 or 1.4 Gbp and we started with 50-60X coverage of PacBio Sequel and RSII data.
The trimmedReads.fasta.gz output was 12G
canu script (NB the genome size was set to 1G for the script):
canu -p MR_1805a \
-d /scratch/directory/run-MR_1805a \
batOptions=”-dg 3 -db 3 -dr 1 -ca 500 -cp 50″ \
A previous assembly was begun 6 months ago using the same raw data and is still incomplete. The same script was run except for an additional parameter:
The trimmedReads.fasta.gz output from that assembly run was 17G
makeblastdb -dbtype prot -in sequence_name.fasta
This script will return three files:
You can then blastx your raw DNA reads against this database to pull out matches (with a custom script):
/project/directory/blast/launch_blast.py -1 RawReads_R1.fq -2 RawReads_R2.fq -b blastx -d /project/directory/blast/sequence_name.fasta
– before extracting matches based on significance (e-value, length, score). The extracted reads are then used to assemble the gene of interest ‘de novo’.
However, I recently tried running a script for blastx against newly made db files and kept returning the error:
BLAST Database error: No alias or index file found for protein database [/project/directory/sequence.fasta] in search path [/project/directory/::]
I was confused as this has been working up previously. After much wasted time I realised that I had changed my script to include the database name to:
makeblastdb -dbtype prot -in sequence_name.fasta -out sequence_name
This output db files named
NB: The name of the database files did not include the .fasta
Hence blastx could not find my files.
Canu v1.6 resources required for 1.4Gb genome assembly
Currently running an assembly with ~60X coverage based on the RSII and Sequel long read data.
Raw data is first converted to fasta and quiver/arrow using Dextract (Dazzler suite). Quiver is a type of fastq but not sure if it can be used as input to canu or Marvel assemblers. I used the .fasta files for assembly with canu.
Steps in running Canu
- Submit inital canu script to grid environment -this step runs Meryl – which runs a kmer analysis, outputs histograms of read length and coverage -also auto submits scripts for batch jobs to the grid for correction stage.
- After correction, canu auto submits a trimming batch job. This stage takes many resources and time!!!
-for the current job: 917 jobs within the array (these can be done in parrallel). Each job requires ~ 4 CPU, up to 16 gb ram and 60 – 70 hours walltime. The resources are difficult to schedule accurately because the first 10 or so jobs are often not resource hungry and will only take an hour or so. The resources required scale up dramatically and the last two hundred jobs can take as long as 80+ hours each.
- After trimming, canu autosubmits a unitigging batch job. This stage also takes many resources and time!!! Same resources as correction.
- Output a fasta assembly and statistics on the assembly.
If all goes well canu will run through all these process without interruption. However, my experience is that the resources need constant monitoring. Also, there is a bug in the shell script that it autosubmits that means if one job in the array fails, it cannot pick up from where is stopped. So individual jobs have to be re-run manually.
So to run the assembly on Canu you ideally need:
(900 X 4) 3600 dedicated CPUs(900 X 16) 14400 GB memory
With these UNREALISTIC resources you could have a genome in walltime: two and a half weeks. Realistically you will need to run jobs within the array in batches according to your resources available. To be clear here, Canu does a good job of the assembly and I applaud the authors of this software!! It is a clearly a very difficult problem to optimise the assembly process with our compute resources. I hope that teams are working on this very difficult issue or perhaps we have to hope that quantum computing is just around the corner…
The first assemblies I ran with Canu with half the coverage (30X) took aproximately 2 months. These assemblies autosubmitted batch jobs of around 300 for the trimming and unitigging stages.
The following grid options more or less worked for the previous assemblies. The walltime needed some adjustment as the array job progressed.
gridOptionsCORMHAP=”-l walltime=16:00:00″ \
gridOptionsCOROVL=”-l walltime=16:00:00″ \
gridOptionsCOR=”-l walltime=16:00:00″ \
gridOptionsOBTOVL=”-l walltime=56:00:00 -l mem=16g -l nodes=1:ppn=5″ \
gridOptionsUTGOVL=”-l walltime=56:00:00 -l mem=16g -l nodes=1:ppn=5″ \
PS. Marvel assembler is not looking very promising at this stage, although they claim to reduce resource requirement by an order of magnitude by softmasking prior to local alignment step. I may be able to make some adjustments to my script to help but currently, after 336 hours walltime 8 CPUs and 70 gb ram, the Daligner stage has only produced alignments (.las) for 29 out of 363 files.
Well, Canu seems to do a reasonable job of assembling long reads for larger organisms but it is laboriously slow!! Trimming and Unitigging stages can take several weeks each. I am now using the reduced list of reads (after mapping to the mitochondrial genome – which reduced reads by ~4%) with the Marvel assembler.
I have been working through the scripts as per the Schmidtea mediterranea example from this recent Nature publication by Grohme et al 2018.
So far so good. However the claim that by using repeat soft masking will reduce computational time by an order of magnitude is yet to be determined. Fingers crossed.
I have a draft mitochondrial genome from my organism. I now have a lot more PacBio data to assemble. I want to extract mitochondrial reads before assembling genomic reads in the hope that this will make the Canu assembly quicker.
Decided to try using bbmap.
#PBS -project name
#PBS -N bbmap
#PBS -l select=1:ncpus=2:mem=64GB
#PBS -l walltime=24:00:00
#PBS -e ./bbmap_error.txt
#PBS -o ./bbmap_output.txt
#PBS -M email@example.com
#PBS -m abe
module load bbmap
module load java
module load samtools
mapPacBio.sh in=174152_1.fasta outu=$BBMAP_OUT_DIR/unmapped_174152_1.fasta outm=$BBMAP_OUT_DIR/mapped_174152_1.fasta maxlen=6000
This has a facility to map long reads to your genome but it splits them into ~6000 bases and renames them something like:
It then outputs the mapped and unmapped reads as fasta files. My thoughts were to use the unmapped reads for assembly. However there are two issues.
- The parts need to be rejoined.
- bbmap seems to bin the whole ‘part’ based on mapping to the genome. ie. if only a portion of the 6000 bases map to the mitochondrial genome it puts it into the mapped bin.
Now wondering if this was the correct approach. There is new software from S. Koren (Canu author) which maps PacBio data.
I had some trepidation using this as it is only newly developed and may be poorly supported, however it is likely to be more suitable.
If any part of the read maps to the mitochondrial genome – the read should be derived from the mitochondrial genome. Therefore it is correct that the whole section is binned as mapped. My plan is:
- Extract headers from the mapped output.
- Use header list to extract reads from original read files.
- Use the reads (minus extracted mapped reads) to assemble the genome.
I thought I’d also just check the repetitive regions within the assembled genome. Found this amusing dialogue on Biostars and thought I’d repost the link.