minimap2 (Beta) - NVIDIA Docs

NVIDIA Docs Hub NVIDIA Clara Welcome to NVIDIA Parabricks v4.3.1 minimap2 (Beta)

NVIDIA Parabricks v4.3.1 Download PDF

Run a GPU-accelerated minimap2.

This tool aligns long read sequences against a large reference database using an accelerated KSW2 to convert FASTQ to BAM/CRAM.

Quick Start

Copy
Copied!

            
            # This command assumes all the inputs are in INPUT_DIR and all the outputs go to OUTPUT_DIR.
docker run --rm --gpus all --volume INPUT_DIR:/workdir --volume OUTPUT_DIR:/outputdir \
    --workdir /workdir \
    nvcr.io/nvidia/clara/clara-parabricks:4.3.1-1 \
pbrun minimap2 \
    --ref /workdir/${REFERENCE_FILE} \
    --in-fq /workdir/${INPUT_FASTQ} \
    --out-bam /outputdir/${OUTPUT_BAM}

Compatible CPU-based minimap2, GATK4 Commands

The commands below are the minimap2-v2.26 and GATK4 counterpart of the Clara Parabricks command above. The output from these commands will be identical to the output from the above command. See the Output Comparison page for comparing the results. You may need to increase the Java heap size based on your dataset, or decrease the number of --MAX_RECORDS_IN_RAM.

Copy
Copied!

            
            # Run minimap2 and pipe the output to create a sorted BAM.
$ minimap2 -ax map-pbmm2 \
    <INPUT_DIR>/${REFERENCE_FILE} \
    <INPUT_DIR>/${INPUT_FASTQ} | \
  gatk SortSam \
    --java-options -Xmx30g \
    --MAX_RECORDS_IN_RAM 5000000 \
    -I /dev/stdin \
    -O cpu.bam \
    --SORT_ORDER coordinate

Please note that two changes must be made to the baseline minimap2 code in order to match the results exactly:

Firstly, a new preset must be made in options.c in the mm_set_opt function that tries to replicate the preset of pbmm2 by setting these parameters as a new preset named “map-pbmm2":

Copy
Copied!

            
            io->k = 19;
io->w = 10;
io->batch_size = 0x7fffffffffffffffL; // always build a uni-part index
mo->flag |= MM_I_HPC;
mo->flag |= MM_F_CIGAR;
mo->flag |= MM_F_LONG_CIGAR;
mo->flag |= MM_F_EQX;
mo->flag |= MM_F_SOFTCLIP;
mo->flag |= MM_F_NO_PRINT_2ND;
mo->flag |= MM_F_HARD_MLEVEL;
mo->mask_level = 0;
mo->e2 = 1;
mo->zdrop = 400;
mo->a = 2;
mo->b = 5;
mo->q = 5;
mo->q2 = 56;
mo->e = 4;
mo->zdrop_inv = 50;
mo->bw = 2000;

Secondly, a fix must be made to the baseline KSW2 code to round the loop fission start and end points by changing them to st and en respectively. If the start point (st0) is a number below 16, but greater than 0, its scoring values will not be initialized correctly, but will still be used later when computing the actual alignment. This can be fixed by rounding the start and end points to multiples of 16.

To make this fix, change the following code in ksw2_extd2_sse.c:

Copy
Copied!

            
                    // loop fission: set scores first
        if (!(flag & KSW_EZ_GENERIC_SC)) {
            for (t = st0; t <= en0; t += 16) {
                __m128i sq, st, tmp, mask;
                sq = _mm_loadu_si128((__m128i*)&sf[t]);
                st = _mm_loadu_si128((__m128i*)&qrr[t]);
                mask = _mm_or_si128(_mm_cmpeq_epi8(sq, m1_), _mm_cmpeq_epi8(st, m1_));
                tmp = _mm_cmpeq_epi8(sq, st);
#ifdef __SSE4_1__
                tmp = _mm_blendv_epi8(sc_mis_, sc_mch_, tmp);
                tmp = _mm_blendv_epi8(tmp,     sc_N_,   mask);
#else
                tmp = _mm_or_si128(_mm_andnot_si128(tmp,  sc_mis_), _mm_and_si128(tmp,  sc_mch_));
                tmp = _mm_or_si128(_mm_andnot_si128(mask, tmp),     _mm_and_si128(mask, sc_N_));
#endif
                _mm_storeu_si128((__m128i*)((int8_t*)s + t), tmp);
            }
        } else {
            for (t = st0; t <= en0; ++t)
                ((uint8_t*)s)[t] = mat[sf[t] * m + qrr[t]];
        }

Fixed version that uses lf_start and lf_en:

Copy
Copied!

            
                    // loop fission: set scores first
        int lf_start = st, lf_en = en;
        if (!(flag & KSW_EZ_GENERIC_SC)) {
            for (t = lf_start; t <= lf_en; t += 16) {
                __m128i sq, st, tmp, mask;
                sq = _mm_loadu_si128((__m128i*)&sf[t]);
                st = _mm_loadu_si128((__m128i*)&qrr[t]);
                mask = _mm_or_si128(_mm_cmpeq_epi8(sq, m1_), _mm_cmpeq_epi8(st, m1_));
                tmp = _mm_cmpeq_epi8(sq, st);
#ifdef __SSE4_1__
                tmp = _mm_blendv_epi8(sc_mis_, sc_mch_, tmp);
                tmp = _mm_blendv_epi8(tmp,     sc_N_,   mask);
#else
                tmp = _mm_or_si128(_mm_andnot_si128(tmp,  sc_mis_), _mm_and_si128(tmp,  sc_mch_));
                tmp = _mm_or_si128(_mm_andnot_si128(mask, tmp),     _mm_and_si128(mask, sc_N_));
#endif
                _mm_storeu_si128((__m128i*)((int8_t*)s + t), tmp);
            }
        } else {
            for (t = lf_start; t <= lf_en; ++t)
                ((uint8_t*)s)[t] = mat[sf[t] * m + qrr[t]];
        }

minimap2 Reference

Align long read sequences against a large reference database to convert FASTQ to BAM/CRAM.

Input/Output file options

--ref REF
--index INDEX
--in-fq IN_FQ
--knownSites KNOWNSITES
--interval-file INTERVAL_FILE
--out-recal-file OUT_RECAL_FILE
--out-bam OUT_BAM
--out-duplicate-metrics OUT_DUPLICATE_METRICS
--out-qc-metrics-dir OUT_QC_METRICS_DIR

Tool Options:

--preset PRESET
--eqx
-L INTERVAL, --interval INTERVAL
-ip INTERVAL_PADDING, --interval-padding INTERVAL_PADDING
--standalone-bqsr
--read-group-sm READ_GROUP_SM
--read-group-lb READ_GROUP_LB
--read-group-pl READ_GROUP_PL
--read-group-id-prefix READ_GROUP_ID_PREFIX

Performance Options:

--num-threads NUM_THREADS
--gpuwrite
--gpuwrite-deflate-algo GPUWRITE_DEFLATE_ALGO
--gpusort
--use-gds
--low-memory

Common options:

--logfile LOGFILE
--tmp-dir TMP_DIR
--with-petagene-dir WITH_PETAGENE_DIR
--keep-tmp
--no-seccomp-override
--version

GPU options:

--num-gpus NUM_GPUS

Previous markdup

Next mutectcaller