> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.nvidia.com/clara/parabricks/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.nvidia.com/clara/parabricks/_mcp/server.

# mutectcaller

This tool is an accelerated version of the GATK somatic variant caller, Mutect2,
which takes aligned BAMs from the FQ2BAM tool, and outputs a VCF file. This can
take as input either a single (“tumor-only”) BAM, or a pair of BAMs
(“tumor-normal”) to provide a baseline to call somatic variants against.

The figure below shows the high-level functionality of mutectcaller. All dotted
boxes indicate optional data, with some constraints.

![](/clara/parabricks/_files/parabricks-clara.docs.buildwithfern.com/abd198a908c6dab0b1d3ae5e93df8903648dee6853977fef3b6a2aaff0e29a3c/assets/images/parabricks-web-graphics-1259949-r2-mutecaller.svg)

The names of the tumor sample (for the `--tumor-name` option) and the normal sample (for the `--normal-name` option)
can be extracted from the headers of their respective BAM files with samtools, which can be installed through apt-get:

```bash
$ sudo apt-get install samtools
```

Or you can build it from source codes by following the instructions in [samtools repo](https://github.com/samtools/samtools).

Once you have samtools installed on your system you can run this command to get the sample name (SM) field:

```bash
$ samtools view NA12878.bam -H | grep '@RG'
@RG ID:HJYFJ.4  SM:NA12878  LB:Pond-492093  PL:illumina PU:HJYFJCCXX160204.4.GCCGCAAC   CN:BI   DT:2016-02-04T00:00:00-0500
```

The sample name is the value after "`SM:`" (NA12878, in this example)

If there are multiple read group (@RG) lines and all of them have the same sample name you may safely
use the common sample name.  If there are multiple read group lines with multiple sample names,
choose one sample name as the input.  All reads with that sample name will be processed by
`mutectcaller` and all other reads will be ignored.  Currently only one sample name per BAM file is supported.

If there are no read group lines in the BAM header, or there is no sample name in the read group line, you will
need to add read group information to the BAM file.  This may be done by running this command:

```bash
$ samtools addreplacerg \
    -r "@RG\tID:sample_rg1\tLB:lib1\tPL:bar\tSM:sample_sm\tPU:sample_rg1" \
    original_file.bam \
    -o updated_file.bam \
    -O BAM
```

This will update the sample name of all reads in this BAM file to "sample\_sm", and you can pass "sample\_sm" as
the sample name of this BAM file.  Make sure you use the `updated_file.bam` as input to `mutectcaller`.

Refer to the [mutectcaller Reference](#options) section for a detailed listing of all available options.

## Quick Start

You can download the mutect sample dataset from [here](https://s3.amazonaws.com/parabricks.sample/mutect_sample.tar.gz).
Extract all files by running:

```sh
$ tar -xvzf mutect_sample.tar.gz 
mutect_sample/
mutect_sample/germline_resource.vcf.gz.tbi
mutect_sample/force_call.vcf.gz.tbi
mutect_sample/germline_resource.vcf.gz
mutect_sample/tumor.bam.bai
mutect_sample/GCA_000001405.15_GRCh38_no_alt_analysis_set.fa
mutect_sample/force_call.vcf.gz
mutect_sample/tumor.bam
mutect_sample/normal.bam.bai
mutect_sample/normal.bam
```

Inside the `mutect_sample` folder you will find the necessary input files including:

* One reference FASTA (GCA\_000001405.15\_GRCh38\_no\_alt\_analysis\_set.fa)
* One tumor BAM (tumor.bam)
* One normal BAM (normal.bam)
* One force\_calling.vcf.gz VCF file
* One germline\_resource.vcf.gz VCF file

with all necessary indexes.

```sh
# This command assumes all the inputs are in the current working directory and all the outputs go to the same place.
docker run --rm --gpus all --volume $(pwd):/workdir --volume $(pwd):/outputdir \
    --workdir /workdir \
    nvcr.io/nvidia/clara/clara-parabricks:4.7.1-1 \
    pbrun mutectcaller \
    --ref /workdir/${REFERENCE_FILE} \
    --tumor-name tumor_name_inside_bam_file \
    --in-tumor-bam /workdir/${INPUT_TUMOR_BAM} \
    --in-normal-bam /workdir/${INPUT_NORMAL_BAM} \
    --normal-name normal_name_inside_bam_file \
    --out-vcf /outputdir/${OUTPUT_VCF}
```

## Compatible GATK4 Command

The command below is the GATK4 counterpart of the Parabricks command above. The output
from this command will be identical to the output from the above command. Refer to the
[Output Comparison](/about-parabricks/comparison-with-baseline-tools) page for comparing the results.

```sh
$ gatk Mutect2 \
    -R <INPUT_DIR>/${REFERENCE_FILE} \
    --input <INPUT_DIR>/${INPUT_TUMOR_BAM} \
    --tumor-sample tumor_name_inside_bam_file \
    --input <INPUT_DIR>/${INPUT_NORMAL_BAM} \
    --normal-sample normal_name_inside_bam_file \
    --output <OUTPUT_DIR>/${OUTPUT_VCF}
```

## Mutect2 with Panel of Normals

Parabricks Mutect2 from version 3.7.0-1 has started supporting Panel of Normals to process variants. There are three steps involved:

* prepon
* running mutectcaller with the index generated by prepon
* postpon, updating the VCF with PON information

```sh
# The first command will generate input.pon that should be done once for the input.vcf.gz
# This command assumes all the inputs are in the current working directory and all the outputs go to the same place.
docker run --rm --gpus all --volume $(pwd):/workdir --volume $(pwd):/outputdir \
    --workdir /workdir \
    nvcr.io/nvidia/clara/clara-parabricks:4.7.1-1 \
    pbrun prepon --in-pon-file /workdir/${INPUT_PON_VCF}

# Run mutectcaller with the pon index
# This command assumes all the inputs are in the current working directory and all the outputs go to the same place.
docker run --rm --gpus all --volume $(pwd):/workdir --volume $(pwd):/outputdir \
    --workdir /workdir \
    nvcr.io/nvidia/clara/clara-parabricks:4.7.1-1 \
    pbrun mutectcaller \
    --ref /workdir/${REFERENCE_FILE} \
    --tumor-name tumor \
    --in-tumor-bam /workdir/${INPUT_TUMOR_BAM} \
    --in-normal-bam /workdir/${INPUT_NORMAL_BAM} \
    --pon /workdir/${INPUT_PON_VCF} \
    --normal-name normal \
    --out-vcf /outputdir/${OUTPUT_VCF}

# Add the annotation to the output.vcf generated above
# This command assumes all the inputs are in the current working directory and all the outputs go to the same place.
docker run --rm --gpus all --volume $(pwd):/workdir --volume $(pwd):/outputdir \
    --workdir /workdir \
    nvcr.io/nvidia/clara/clara-parabricks:4.7.1-1 \
    pbrun postpon \
  --in-vcf /workdir/${OUTPUT_VCF} \
  --in-pon-file /workdir/${INPUT_PON_FILE} \
  --out-vcf /outputdir/${OUTPUT_ANNOTATED_VCF}
```

## Source of Mismatches

While Parabricks MutectCaller does not lose any accuracy in functionality when compared with the GATK
MutectCaller, there are a few implementation differences that can result in slightly different output files.

* **Log10 implementation**

The `log10` operation is used to compute the haplotype penalty score. The Java implementation
`java.lang.Math.log10()` is slightly different from the C++ \`cmath library, giving rise to small
mismatches in computed scores.  Different haplotypes might be selected because of this.

* **AVX**

GATK calls Intel GKL (Genomics Kernel Library) which contains optimized versions of compute kernels
(e.g. Smith-Waterman, PairHMM) to run on Intel Architecture (AVX, AVX2, AVX-512, and multicore).
However, some SIMD intrinsics such as mm512\_mul\_ps\` can generate a slightly different output
when compared with the serial operations which our GPU implementation is based on.

* **HashMap, HashSet iteration**

GATK can give non-deterministic outputs because iterating over a Java `HashMap` or `HashSet` does not preserve
order.  Parabricks always gives deterministic output by using
a hash table that preserves the insertion order (similar to `LinkedHashMap` in Java).

## Options