NVIDIA Parabricks

https://docs.nvidia.com/clara/parabricks/latest/
Admin
NVIDIA Parabricks is a GPU-accelerated genomics analysis software suite that provides fast variant...
Tokens:114,878
Snippets:968
Trust Score:10
Update:11 months ago
Show doc for...
Tokens:
Raw
### Download and Unpack Sample Data

Source: https://docs.nvidia.com/clara/parabricks/latest/Tutorials/CloudGuides/OCI

Downloads the Parabricks sample dataset using wget and then unpacks the tar.gz archive. This provides the necessary data to test the Parabricks installation.

```bash
$ wget -O parabricks_sample.tar.gz \
  https://s3.amazonaws.com/parabricks.sample/parabricks_sample.tar.gz
$ tar xzvf parabricks_sample.tar.gz
```

--------------------------------

### Download Example FASTQ Data using gsutil

Source: https://docs.nvidia.com/clara/parabricks/latest/Tutorials/How-Tos/WholeGenomeGermlineSmallVariants

Downloads example FASTQ files for whole-genome sequencing data using the gsutil command-line tool. These files are necessary for running the variant calling pipeline.

```bash
gsutil cp gs://brain-genomics-public/research/sequencing/fastq/hiseqx/wgs_pcr_free/30x/HG002.hiseqx.pcr-free.30x.R1.fastq.gz .
$ gsutil cp gs://brain-genomics-public/research/sequencing/fastq/hiseqx/wgs_pcr_free/30x/HG002.hiseqx.pcr-free.30x.R2.fastq.gz .
```

--------------------------------

### Clone Repository, Install, and Run Benchmarks

Source: https://docs.nvidia.com/clara/parabricks/latest/Tutorials/CloudGuides/BenchmarkingGuide

This script clones the complete-genomics-benchmarks repository, navigates into the directory, and then executes the installation and run scripts. It's the primary command to get the benchmarking process started quickly.

```shell
git clone git@github.com:clara-parabricks-workflows/complete-genomics-benchmarks.git
cd complete-genomics-benchmarks
./install.sh
./run.sh
```

--------------------------------

### Download Example FASTQ Data using wget

Source: https://docs.nvidia.com/clara/parabricks/latest/Tutorials/How-Tos/WholeGenomeGermlineSmallVariants

Downloads example FASTQ files for whole-genome sequencing data using the wget command. This is an alternative to gsutil for acquiring the necessary input files.

```bash
wget https://storage.googleapis.com/brain-genomics-public/research/sequencing/fastq/hiseqx/wgs_pcr_free/30x/HG002.hiseqx.pcr-free.30x.R1.fastq.gz
$ wget https://storage.googleapis.com/brain-genomics-public/research/sequencing/fastq/hiseqx/wgs_pcr_free/30x/HG002.hiseqx.pcr-free.30x.R2.fastq.gz
```

--------------------------------

### Download Parabricks Sample Data (Bash)

Source: https://docs.nvidia.com/clara/parabricks/latest/tutorials/cloudguides/gcp

Downloads a compressed archive containing sample data for testing Parabricks installation and hardware. This command uses wget to download the file to the current directory. The output shows the download progress and file size.

```bash
`wget -O parabricks_sample.tar.gz \
     "https://s3.amazonaws.com/parabricks.sample/parabricks_sample.tar.gz"`
```

--------------------------------

### Download Parabricks Sample Data

Source: https://docs.nvidia.com/clara/parabricks/latest/tutorials/cloudguides/aws

This command downloads a small sample dataset provided by Parabricks for installation and hardware testing. The data is downloaded as a compressed tar archive.

```bash
`wget -O parabricks_sample.tar.gz "https://s3.amazonaws.com/parabricks.sample/parabricks_sample.tar.gz"`
```

--------------------------------

### Download Parabricks Sample Data

Source: https://docs.nvidia.com/clara/parabricks/latest/Tutorials/CloudGuides/AWS

This command downloads a compressed tarball containing sample data for testing Parabricks installation and hardware. The data is fetched using wget from an S3 bucket.

```bash
wget -O parabricks_sample.tar.gz "https://s3.amazonaws.com/parabricks.sample/parabricks_sample.tar.gz"
```

--------------------------------

### Install and Run Parabricks Benchmarks

Source: https://docs.nvidia.com/clara/parabricks/latest/tutorials/CloudGuides/BenchmarkingGuide

Installs the necessary dependencies and runs the NVIDIA Parabricks benchmarking scripts for complete genomics data. Assumes the repository has already been cloned.

```shell
cd complete-genomics-benchmarks
./install.sh
./run.sh
```

--------------------------------

### Launch BaseCommand Container for Parabricks

Source: https://docs.nvidia.com/clara/parabricks/latest/gettingstarted/gettingthesoftware

This command demonstrates launching a BaseCommand container for running Parabricks on a single-GPU instance. It uses the `ngc batch run` command with specified instance type and the Parabricks germline tool command.

```bash
ngc batch run --name "parabricks-germline" \
    --instance dgxa100.80g.1.norm \
    --commandline "pbrun germline \

```

--------------------------------

### Run Parabricks Germline Pipeline

Source: https://docs.nvidia.com/clara/parabricks/latest/tutorials/cloudguides/azure

This command executes the Parabricks germline pipeline using a Docker container. It mounts the current directory, specifies GPU usage, and defines input/output files for the analysis. The command requires reference genomes and known variant VCF files.

```bash
$ docker run \
     --rm \
     --gpus all \
     --volume `pwd`:`pwd` \
     --workdir `pwd`/parabricks_sample \
     nvcr.io/nvidia/clara/clara-parabricks:4.5.1-1 \
     pbrun germline \
     --ref Ref/Homo_sapiens_assembly38.fasta \
     --in-fq Data/sample_1.fq.gz Data/sample_2.fq.gz \
     --knownSites Ref/Homo_sapiens_assembly38.known_indels.vcf.gz.tbi \
     --out-bam output.bam \
     --out-variants germline.vcf \
     --out-recal-file recal.txt
```

--------------------------------

### Download Parabricks Sample Data

Source: https://docs.nvidia.com/clara/parabricks/latest/Tutorials/CloudGuides/Azure

Downloads a compressed archive containing sample data provided by Parabricks. This data is used to test the installation and functionality of Parabricks after it has been set up.

```bash
$ wget -O parabricks_sample.tar.gz \
     "https://s3.amazonaws.com/parabricks.sample/parabricks_sample.tar.gz"
```

--------------------------------

### Pull NVIDIA Parabricks Docker Image

Source: https://docs.nvidia.com/clara/parabricks/latest/gettingstarted/gettingthesoftware

This command downloads the NVIDIA Parabricks Docker image from the NVIDIA Container Registry (NVCR). Ensure Docker is installed and configured on your system.

```bash
$ docker pull nvcr.io/nvidia/clara/clara-parabricks:4.5.1-1
```

--------------------------------

### Download Parabricks Sample Data

Source: https://docs.nvidia.com/clara/parabricks/latest/Tutorials/CloudGuides/DNANexus

This command downloads a compressed archive containing sample data for Parabricks, including FASTQ and reference files. Ensure you have `wget` installed and sufficient disk space. The downloaded archive needs to be uploaded to DNAnexus, with reference files zipped into a single folder.

```shell
wget -O parabricks_sample.tar.gz \
     "https://s3.amazonaws.com/parabricks.sample/parabricks_sample.tar.gz"
```

--------------------------------

### Germline Pipeline Usage Example

Source: https://docs.nvidia.com/clara/parabricks/latest/tutorials/cloudguides/aws

Example command for running the NVIDIA Parabricks germline pipeline. This pipeline is used for alignment and variant calling on whole genome data. Ensure Parabricks is installed and configured in your environment.

```bash
parabricks_germline \
    --input-file FASTQ_FILE \
    --output-file BAM_FILE \
    --ref-dict REF_DICT \
    --known-sites KNOWN_SITES \
    --sequence-type "WGS" \
    --region "chr1:1-1000000"
```

--------------------------------

### Download Example FASTQ Data using wget

Source: https://docs.nvidia.com/clara/parabricks/latest/tutorials/How-Tos/WholeGenomeGermlineSmallVariants

Provides an alternative method to download the HG002 FASTQ files using the wget utility if gsutil is not available. These files are essential input for the subsequent variant calling steps.

```bash
$ wget https://storage.googleapis.com/brain-genomics-public/research/sequencing/fastq/hiseqx/wgs_pcr_free/30x/HG002.hiseqx.pcr-free.30x.R1.fastq.gz
$ wget https://storage.googleapis.com/brain-genomics-public/research/sequencing/fastq/hiseqx/wgs_pcr_free/30x/HG002.hiseqx.pcr-free.30x.R2.fastq.gz
```

--------------------------------

### Install samtools

Source: https://docs.nvidia.com/clara/parabricks/latest/Documentation/ToolDocs/man_mutectcaller

Installs the samtools utility using apt-get, which is required for extracting sample names from BAM file headers. This command is typically run on a Debian-based Linux system.

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

--------------------------------

### Connect to GPU Instance via SSH

Source: https://docs.nvidia.com/clara/parabricks/latest/Tutorials/CloudGuides/OCI

Establishes an SSH connection to the GPU instance. Ensure your public key is set up correctly for authentication. This is the initial step to access the instance for software installation and testing.

```bash
$ ssh ubuntu@129.146.60.48
```

--------------------------------

### Viewing First Line of BAM File with samtools

Source: https://docs.nvidia.com/clara/parabricks/latest/Tutorials/FQ2BAM_Tutorial

This example demonstrates how to use the 'samtools view' command to display the first line of a BAM file. This is useful for inspecting the header and sequence alignment information.

```bash
samtools view fq2bam_output.bam
```

--------------------------------

### Example BAM File Header Line

Source: https://docs.nvidia.com/clara/parabricks/latest/Tutorials/FQ2BAM_Tutorial

This snippet shows a typical header line from a BAM file generated by the 'fq2bam' command, including read group information, sequence alignment details, and various tags like MD, PG, NM, AS, and XS.

```text
HWI-D00127:570:HK3TJBCX2:1:1202:9643:76055  99      chr1    10027   26      24M5I86M        =       10178   231     ACCCTAACCCTAACCCTAACCCGACCCCGACCCCGACCCAAACCCAAACCCTAACCCTAACCCTAACCCTAACCCTAACCCTAACCCTACCCTAACCCTAACCCTAACCCTAACC     DDDDDHGHIIIIIHIIHHIHHHIHIIIIIIHDHHIHHHIHIHIIIIFHIEHHIIHHIIIIEHIIIIHHIHIIICHE@1FHH?1GEFE1111D11<FH11<FD11<<FFE111<11     MD:Z:22T5T0A4T5T41A27   PG:Z:MarkDuplicatesRG:Z:HK3TJBCX2.1     NM:i:11 AS:i:69 XS:i:72
```

--------------------------------

### Download Example FASTQ Data using gsutil

Source: https://docs.nvidia.com/clara/parabricks/latest/tutorials/How-Tos/WholeGenomeGermlineSmallVariants

Downloads the HG002 FASTQ files required for variant calling from a Google Cloud Storage bucket using the gsutil command-line tool. This is the first step in obtaining the necessary input data for the analysis pipeline.

```bash
$ gsutil cp gs://brain-genomics-public/research/sequencing/fastq/hiseqx/wgs_pcr_free/30x/HG002.hiseqx.pcr-free.30x.R1.fastq.gz .
$ gsutil cp gs://brain-genomics-public/research/sequencing/fastq/hiseqx/wgs_pcr_free/30x/HG002.hiseqx.pcr-free.30x.R2.fastq.gz .
```

--------------------------------

### Example VCF.gz Contig Header for prepon

Source: https://docs.nvidia.com/clara/parabricks/latest/documentation/tooldocs/man_prepon

Shows the required format for the Contig field in the header of a VCF.gz file when using the prepon tool. Each entry specifies the chromosome ID and its length, crucial for memory allocation by prepon.

```bash
##contig=<ID=chr1,length=248956422>
##contig=<ID=chr2,length=242193529>
##contig=<ID=chr3,length=198295559>
...
```

--------------------------------

### Extract Parabricks Sample Data (Bash)

Source: https://docs.nvidia.com/clara/parabricks/latest/tutorials/cloudguides/gcp

Extracts the contents of the downloaded 'parabricks_sample.tar.gz' archive. This command uses the 'tar' utility with options to extract, decompress (gzip), and preserve symbolic links. The output lists the files being extracted.

```bash
`tar xzvf parabricks_sample.tar.gz`
```

--------------------------------

### Run Parabricks fq2bam Tool via Docker

Source: https://docs.nvidia.com/clara/parabricks/latest/gettingstarted/gettingthesoftware

This command executes the Parabricks fq2bam tool within a Docker container. It mounts local directories for input/output, specifies GPU usage, and passes tool-specific arguments for reference genome and input/output files. Dependencies include Docker and the Parabricks Docker image.

```bash
docker run \
      --gpus all \
      --rm \
      --volume $(pwd):/workdir \
      --volume $(pwd):/outputdir \
    nvcr.io/nvidia/clara/clara-parabricks:4.5.1-1 \
    pbrun fq2bam \
      --ref /workdir/parabricks_sample/Ref/Homo_sapiens_assembly38.fasta \
      --in-fq /workdir/parabricks_sample/Data/sample_1.fq.gz /workdir/parabricks_sample/Data/sample_2.fq.gz \
      --out-bam /outputdir/fq2bam_output.bam
```

--------------------------------

### Run fq2bam Pipeline with NVIDIA Clara Parabricks

Source: https://docs.nvidia.com/clara/parabricks/latest/gettingstarted/bestperformance

This Docker command executes the fq2bam pipeline for converting FASTQ files to BAM format. It includes parameters for reference genome, input FASTQ files, output BAM, temporary directory, and known indel sites.

```bash
$ docker run --rm --gpus all --volume $(pwd):/workdir --volume $(pwd):/outputdir \
    --workdir /workdir --env TCMALLOC_MAX_TOTAL_THREAD_CACHE_BYTES=268435456 \
    nvcr.io/nvidia/clara/clara-parabricks:4.5.1-1 \
    pbrun fq2bam \
    --ref /workdir/Homo_sapiens_assembly38.fasta \
    --in-fq /workdir/fastq1.gz /workdir/fastq2.gz \
    --out-bam /outputdir/fq2bam_output.bam \
    --tmp-dir /workdir \
    --bwa-cpu-thread-pool 16 \
    --out-recal-file recal.txt \
    --knownSites /workdir/hg.known_indels.vcf \
    --gpusort \
    --gpuwrite
```

--------------------------------

### Run fq2bam Pipeline for Optimal Performance

Source: https://docs.nvidia.com/clara/parabricks/latest/GettingStarted/BestPerformance

This command optimizes the fq2bam pipeline for performance, particularly during sorting, duplicate marking, and compression phases. It leverages `--gpusort` and `--gpuwrite` for GPU acceleration and allows experimentation with `--bwa-nstreams` and `--bwa-cpu-thread-pool` for further tuning.

```bash
docker run --rm --gpus all --volume $(pwd):/workdir --volume $(pwd):/outputdir \
    --workdir /workdir --env TCMALLOC_MAX_TOTAL_THREAD_CACHE_BYTES=268435456 \
    nvcr.io/nvidia/clara/clara-parabricks:4.6.0-1 \
    pbrun fq2bam \
    --ref /workdir/Homo_sapiens_assembly38.fasta \
    --in-fq /workdir/fastq1.gz /workdir/fastq2.gz \
    --out-bam /outputdir/fq2bam_output.bam \
    --tmp-dir /workdir \
    --bwa-cpu-thread-pool 16 \
    --out-recal-file recal.txt \
    --knownSites /workdir/hg.known_indels.vcf \
    --gpusort \
    --gpuwrite
```

--------------------------------

### Run make_examples using Docker (NVIDIA Parabricks)

Source: https://docs.nvidia.com/clara/parabricks/latest/Tutorials/DVTraining

This command executes the 'make_examples' step using Docker, processing reference, BAM, VCF, and BED files into a format usable by subsequent training steps. It assumes input files are in the current directory and outputs are directed to the same location. Dependencies include Docker with GPU support and the specified NVIDIA container image.

```docker
docker run --rm --gpus all --volume $(pwd):/workdir --volume $(pwd):/outputdir \
    --workdir /workdir \
    nvcr.io/nvidia/clara/deepvariant_train:4.3.2-1 \
    pbrun make_examples \
    --ref /workdir/${REFERENCE_FILE} \
    --reads /workdir/${INPUT_BAM} \
    --truth-variants /workdir/${TRUTH_VCF} \
    --confident-regions /workdir/${TRUTH_BED} \
    --examples /outputdir/${TFRECORD_FILE} \
    --disable-use-window-selector-model \
    --channel-insert-size
```

--------------------------------

### Extract Sample Dataset with tar

Source: https://docs.nvidia.com/clara/parabricks/latest/Documentation/ToolDocs/man_mutectcaller

Extracts the mutect sample dataset, which includes reference FASTA, BAM files, VCF files, and their indexes, necessary for running the mutectcaller quick start example.

```bash
tar -xvzf mutect_sample.tar.gz

```

--------------------------------

### Run NVIDIA Clara Parabricks prepon using Docker

Source: https://docs.nvidia.com/clara/parabricks/latest/documentation/tooldocs/man_prepon

This Docker command executes the prepon tool from NVIDIA Clara Parabricks. It mounts the current directory for input and output, specifies the container image, sets the working directory, and calls the prepon command with the input PON file. Ensure input files are in the current directory.

```shell
docker run --rm --gpus all --volume $(pwd):/workdir --volume $(pwd):/outputdir \
    --workdir /workdir \
    nvcr.io/nvidia/clara/clara-parabricks:4.5.1-1 \
    pbrun prepon \
    --in-pon-file /workdir/${INPUT_PON_VCF}
```

--------------------------------

### Specify GPUs with NVIDIA_VISIBLE_DEVICES

Source: https://docs.nvidia.com/clara/parabricks/latest/GettingStarted/BestPerformance

This command demonstrates how to specify which GPUs to use for a Parabricks tool by setting the NVIDIA_VISIBLE_DEVICES environment variable. It uses `pbrun fq2bam` as an example, selecting the second (GPU #1) and fourth (GPU #3) GPUs.

```bash
$ NVIDIA_VISIBLE_DEVICES="1,3" pbrun fq2bam --num-gpus 2 --ref Ref.fa --in-fq S1_1.fastq.gz --in-fq S1_2.fastq.gz
```

--------------------------------

### Run make_examples using Docker and Parallel (DeepVariant Baseline)

Source: https://docs.nvidia.com/clara/parabricks/latest/Tutorials/DVTraining

This command demonstrates a baseline for running the 'make_examples' step using Docker and GNU Parallel for distributed processing. It processes input data for training or validation sets, generating TFRecord files. This approach is suitable for handling multiple shards and can be adapted by specifying input/output directories and the DeepVariant version.

```shell
( seq 0 $((N_SHARDS-1)) |\
    parallel --halt 2 --line-buffer \
        sudo docker run --volume <INPUT_DIR>:/workdir --volume <OUTPUT_DIR>:/outputdir \
        google/deepvariant:"${BIN_VERSION}" \
/opt/deepvariant/bin/make_examples \
--mode training \
--ref "/workdir/${REF}" \
--reads "/workdir/${INPUT_BAM}" \
--examples "/outputdir/validation_set.with_label.tfrecord@${N_SHARDS}.gz" \
--truth_variants "/workdir/${TRUTH_VCF" \
--confident_regions "/workdir/${TRUTH_BED}" \
--task {} \
--channels "insert_size" )
```

--------------------------------

### Pull NVIDIA Clara Parabricks Docker Image (Bash)

Source: https://docs.nvidia.com/clara/parabricks/latest/tutorials/cloudguides/gcp

Pulls a specific version of the NVIDIA Clara Parabricks Docker image from the NVIDIA Container Registry (NVIDIA CR). This command requires Docker to be installed and configured. The output shows the download progress and confirmation upon completion.

```bash
`docker pull nvcr.io/nvidia/clara/clara-parabricks:4.5.1-1`
```

--------------------------------

### Run Parabricks fq2bam Tool with Docker

Source: https://docs.nvidia.com/clara/parabricks/latest/GettingStarted/GettingTheSoftware

This command executes the Parabricks `fq2bam` tool (BWA-MEM + GATK) within a Docker container. It mounts local directories for input/output, specifies GPU usage, and passes tool-specific arguments. Ensure sample data and reference FASTA are available at the specified paths.

```bash
docker run \
      --gpus all \
      --rm \
      --volume $(pwd):/workdir \
      --volume $(pwd):/outputdir \
    nvcr.io/nvidia/clara/clara-parabricks:4.6.0-1 \
    pbrun fq2bam \
      --ref /workdir/parabricks_sample/Ref/Homo_sapiens_assembly38.fasta \
      --in-fq /workdir/parabricks_sample/Data/sample_1.fq.gz /workdir/parabricks_sample/Data/sample_2.fq.gz \
      --out-bam /outputdir/fq2bam_output.bam
```

--------------------------------

### Fix KSW2 loop fission scoring (C)

Source: https://docs.nvidia.com/clara/parabricks/latest/Documentation/ToolDocs/man_minimap2

This C code demonstrates a fix in KSW2's loop fission logic within 'ksw2_extd2_sse.c'. It modifies how start and end points are handled to ensure correct scoring initialization, especially when start points are less than 16 but greater than 0. The fix involves rounding to multiples of 16.

```c
// 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]];
}

```

--------------------------------

### Run FQ-to-BAM Pipeline using DNAnexus CLI

Source: https://docs.nvidia.com/clara/parabricks/latest/tutorials/CloudGuides/DNANexus

This command executes the FQ-to-BAM pipeline using the DNAnexus CLI. It requires the project ID and file IDs for the reference and FASTQ files as input. The output will appear in the Monitor tab of the specified project.

```bash
$ dx run fq2bam \
   -iref=<project-id:reference-file-id> \
   -iin_fq=<project-id:fastq1-file-id> \
   -iin_fq=<project-id:fastq2-file-id>
```

--------------------------------

### Run FQ2BAM Tool with Docker - NVIDIA Parabricks

Source: https://docs.nvidia.com/clara/parabricks/latest/tutorials/fq2bam_tutorial

This code snippet shows how to execute the FQ2BAM tool using a Docker container. It mounts the current directory for input and output, specifies the reference genome, input FASTQ files, and the output BAM file. This command is designed for aligning paired-end FASTQ data and includes options for GPU acceleration.

```bash
$ docker run \
      --gpus all \
      --rm \
      --volume $(pwd):/workdir \
      --volume $(pwd):/outputdir \
    nvcr.io/nvidia/clara/clara-parabricks:4.5.1-1 \
    pbrun fq2bam \
      --ref /workdir/parabricks_sample/Ref/Homo_sapiens_assembly38.fasta \
      --in-fq /workdir/parabricks_sample/Data/sample_1.fq.gz /workdir/parabricks_sample/Data/sample_2.fq.gz \
      --out-bam /outputdir/fq2bam_output.bam
```

--------------------------------

### Pull Parabricks Docker Image

Source: https://docs.nvidia.com/clara/parabricks/latest/tutorials/cloudguides/aws

This command downloads the latest NVIDIA Parabricks Docker image from the NVIDIA GPU Cloud (NGC). Ensure you have Docker installed and configured on your instance.

```bash
`$ docker pull nvcr.io/nvidia/clara/clara-parabricks:4.5.1-1`
```

--------------------------------

### Verify Docker and GPU Status

Source: https://docs.nvidia.com/clara/parabricks/latest/Tutorials/CloudGuides/OCI

Checks if Docker is installed and accessible in the system's PATH, and verifies the status of the GPU card using 'nvidia-smi'. These commands are crucial for ensuring the environment is correctly configured for Parabricks.

```bash
$ which docker
$ nvidia-smi
```

--------------------------------

### Pull NVIDIA Parabricks Docker Image

Source: https://docs.nvidia.com/clara/parabricks/latest/GettingStarted/GettingTheSoftware

This command downloads the specified version of the NVIDIA Parabricks Docker image from the NVIDIA Container Registry. Ensure Docker is installed and configured on your system.

```bash
$ docker pull nvcr.io/nvidia/clara/clara-parabricks:4.6.0-1
```

--------------------------------

### Run applybqsr with Docker | NVIDIA Parabricks

Source: https://docs.nvidia.com/clara/parabricks/latest/Documentation/ToolDocs/man_applybqsr

This command executes the NVIDIA Parabricks applybqsr tool using Docker. It assumes input files are in the current directory and outputs are directed to the same location. The command mounts local directories to the container for input and output, sets the working directory, and specifies the Parabricks Docker image. It requires reference, input BAM, input recalibration file, and output BAM file paths as arguments.

```docker
docker run --rm --gpus all --volume $(pwd):/workdir --volume $(pwd):/outputdir \
    --workdir /workdir \
    nvcr.io/nvidia/clara/clara-parabricks:4.6.0-1 \
    pbrun applybqsr \
    --ref /workdir/${REFERENCE_FILE} \
    --in-bam /workdir/${INPUT_BAM} \
    --in-recal-file /workdir/${INPUT_RECAL_FILE}  \
    --out-bam /outputdir/${OUTPUT_BAM}
```

--------------------------------

### Download and Index Reference Genome and Known Sites (Parabricks)

Source: https://docs.nvidia.com/clara/parabricks/latest/tutorials/how-tos/somaticcalling

This snippet demonstrates how to download and index reference genome files and known variant sites, which are crucial for variant calling. It utilizes `pbrun` commands for indexing.

```bash
# Downloading reference genome and known sites (example using ftp.ncbi.nih.gov)
# wget https://ftp.ncbi.nlm.nih.gov/snp/archive/b155/VCF/GCF_000001405.39.gz
# wget https://ftp.1000genomes.ebi.ac.uk/vol1/ftp/technical/reference/GRCh38_reference_genome/other_mapping_resources/ALL.wgs.1000G_phase3.GRCh38.ncbi_remapper.20150424.shapeit2_indels.vcf.gz
# wget https://ftp.1000genomes.ebi.ac.uk/vol1/ftp/technical/reference/GRCh38_reference_genome/other_mapping_resources/Mills_and_1000G_gold_standard.indels.b38.primary_assembly.vcf.gz

# Indexing the reference genome using pbrun
pbrun index --ref <reference_genome.fasta> --outdir <output_directory>

# Indexing known sites VCF files
pbrun index --ref <known_sites.vcf.gz> --outdir <output_directory>
```

--------------------------------

### Run Germline Pipeline with Optimal Performance Settings

Source: https://docs.nvidia.com/clara/parabricks/latest/GettingStarted/BestPerformance

This Docker command is recommended for achieving the best performance for the Germline Pipeline. It includes optimized settings for input/output, temporary directories, and multi-threading, suitable for H100 DGX systems.

```bash
_# 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 \
    --env TCMALLOC_MAX_TOTAL_THREAD_CACHE_BYTES=268435456 \
    nvcr.io/nvidia/clara/clara-parabricks:4.6.0-1 \
    pbrun germline \
    --ref /workdir/Homo_sapiens_assembly38.fasta \
    --in-fq /workdir/fastq1.gz /workdir/fastq2.gz \
    --out-bam /outputdir/fq2bam_output.bam \
    --tmp-dir /workdir \
    --bwa-cpu-thread-pool 16 \
    --out-variants /outputdir/out.vcf \
    --run-partition \
    --read-from-tmp-dir \
    --gpusort \
    --gpuwrite \
    --keep-tmp
```

--------------------------------

### Download and Index Reference Genome and Known Sites

Source: https://docs.nvidia.com/clara/parabricks/latest/tutorials/how-tos/WholeGenomeGermlineSmallVariants

This section covers downloading the GRCh38 reference genome, unzipping it, and creating necessary indices using samtools and bwa. It also includes downloading VCF files for known indel sites, crucial for BQSR reports.

```bash
$ wget ftp://ftp.ncbi.nlm.nih.gov/genomes/all/GCA/000/001/405/GCA_000001405.15_GRCh38/seqs_for_alignment_pipelines.ucsc_ids/GCA_000001405.15_GRCh38_no_alt_analysis_set.fna.gz

_## Unzip and index the reference_
$ gunzip GCA_000001405.15_GRCh38_no_alt_analysis_set.fna.gz

_## Create an FAI index_
$ samtools faidx GCA_000001405.15_GRCh38_no_alt_analysis_set.fna

_## Create the BWA indices_
$ bwa index GCA_000001405.15_GRCh38_no_alt_analysis_set.fna

$ wget https://storage.googleapis.com/genomics-public-data/resources/broad/hg38/v0/Mills_and_1000G_gold_standard.indels.hg38.vcf.gz
$ wget https://storage.googleapis.com/genomics-public-data/resources/broad/hg38/v0/Mills_and_1000G_gold_standard.indels.hg38.vcf.gz.tbi
```

--------------------------------

### Run Deepvariant Germline Pipeline with NVIDIA Clara Parabricks

Source: https://docs.nvidia.com/clara/parabricks/latest/gettingstarted/bestperformance

This command executes the Deepvariant Germline pipeline using Docker. It mounts the current directory as work and output directories, utilizes all available GPUs, and configures several performance-related parameters.

```bash
$ docker run --rm --gpus all --volume $(pwd):/workdir --volume $(pwd):/outputdir \
    --workdir /workdir \
    --env TCMALLOC_MAX_TOTAL_THREAD_CACHE_BYTES=268435456 \
    nvcr.io/nvidia/clara/clara-parabricks:4.5.1-1 \
    pbrun deepvariant_germline \
    --ref /workdir/Homo_sapiens_assembly38.fasta \
    --in-fq /workdir/fastq1.gz /workdir/fastq2.gz \
    --out-bam /outputdir/fq2bam_output.bam \
    --tmp-dir /workdir \
    --bwa-cpu-thread-pool 16 \
    --out-variants /outputdir/out.vcf \
    --run-partition \
    --read-from-tmp-dir \
    --num-streams-per-gpu 4 \
    --gpusort \
    --gpuwrite \
    --keep-tmp
```

--------------------------------

### Check Available Disk Space

Source: https://docs.nvidia.com/clara/parabricks/latest/Tutorials/CloudGuides/OCI

Uses the 'lsblk' command to verify if the instance has at least 25GB of available storage. Adequate disk space is necessary for downloading datasets and intermediate processing files.

```bash
$ lsblk
```

--------------------------------

### Run Deepvariant Germline Pipeline with Optimal Performance Settings

Source: https://docs.nvidia.com/clara/parabricks/latest/GettingStarted/BestPerformance

This Docker command is recommended for achieving the best performance for the Deepvariant Germline Pipeline. It includes optimized settings for input/output, temporary directories, and multi-threading, suitable for H100 DGX systems.

```bash
_# 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 \
    --env TCMALLOC_MAX_TOTAL_THREAD_CACHE_BYTES=268435456 \
    nvcr.io/nvidia/clara/clara-parabricks:4.6.0-1 \
    pbrun deepvariant_germline \
    --ref /workdir/Homo_sapiens_assembly38.fasta \
    --in-fq /workdir/fastq1.gz /workdir/fastq2.gz \
    --out-bam /outputdir/fq2bam_output.bam \
    --tmp-dir /workdir \
    --bwa-cpu-thread-pool 16 \
    --out-variants /outputdir/out.vcf \
    --run-partition \
    --read-from-tmp-dir \
    --gpusort \
    --gpuwrite \
    --keep-tmp
```

--------------------------------

### Run postpon Docker Command

Source: https://docs.nvidia.com/clara/parabricks/latest/documentation/tooldocs/man_postpon

This command executes the 'postpon' tool within a Docker container. It requires input VCF, PON VCF, and an output VCF file path. The command maps local directories to the container for input and output, and utilizes all available GPUs.

```bash
# 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.5.1-1 \
    pbrun postpon \
    --in-vcf /workdir/${INPUT_VCF} \
    --in-pon-file /workdir/${INPUT_PON_VCF} \
    --out-vcf /outputdir/${OUTPUT_VCF}
```

--------------------------------

### Run applybqsr with Docker (Parabricks)

Source: https://docs.nvidia.com/clara/parabricks/latest/documentation/tooldocs/man_applybqsr

This Docker command executes the `applybqsr` tool from NVIDIA Clara Parabricks. It requires input BAM, reference, and recalibration files, outputting a modified BAM file. Ensure all input files are in the current working directory or mapped correctly via volumes.

```bash
docker run --rm --gpus all --volume $(pwd):/workdir --volume $(pwd):/outputdir \
    --workdir /workdir \
    nvcr.io/nvidia/clara/clara-parabricks:4.5.1-1 \
    pbrun applybqsr \
    --ref /workdir/${REFERENCE_FILE} \
    --in-bam /workdir/${INPUT_BAM} \
    --in-recal-file /workdir/${INPUT_RECAL_FILE}  \
    --out-bam /outputdir/${OUTPUT_BAM}
```

--------------------------------

### Compare VCF Files using GATK Concordance

Source: https://docs.nvidia.com/clara/parabricks/latest/ComparisonsToBaselineTools

This command uses the GATK Concordance tool to compare two VCF files: an evaluation file and a truth file. The results, including sensitivity and specificity for SNPs and INDELs, are saved to a specified summary file. Ensure GATK is installed and accessible in your environment.

```bash
$ gatk Concordance \
    --evaluation result_gpu.vcf \
    --truth result_cpu.vcf \
    --summary out.txt
```

--------------------------------

### Run HaplotypeCaller with Docker - Shell

Source: https://docs.nvidia.com/clara/parabricks/latest/Tutorials/HaplotypeCaller_Tutorial

This command executes the Parabricks HaplotypeCaller using Docker. It mounts the current directory for input/output and utilizes all available GPUs. The tool takes a reference FASTA file and an input BAM file to produce a VCF output.

```shell
docker run \
      --gpus all \
      --rm \
      --volume $(pwd):/workdir \
      --volume $(pwd):/outputdir \
    nvcr.io/nvidia/clara/clara-parabricks:4.6.0-1 \
    pbrun haplotypecaller \
      --ref /workdir/parabricks_sample/Ref/Homo_sapiens_assembly38.fasta \
      --in-bam /workdir/fq2bam_output.bam \
      --out-variants /outputdir/variants.vcf
```

--------------------------------

### Run HaplotypeCaller Pipeline with NVIDIA Clara Parabricks

Source: https://docs.nvidia.com/clara/parabricks/latest/gettingstarted/bestperformance

This Docker command executes the HaplotypeCaller pipeline for variant discovery using NVIDIA Clara Parabricks. It requires a reference genome and an input BAM file, with options to control threads and ignore alternative contigs.

```bash
$ docker run --rm --gpus all --volume $(pwd):/workdir --volume $(pwd):/outputdir \
    --workdir /workdir --env TCMALLOC_MAX_TOTAL_THREAD_CACHE_BYTES=268435456 \
    nvcr.io/nvidia/clara/clara-parabricks:4.5.1-1 \
    pbrun haplotypecaller \
    --ref /workdir/Homo_sapiens_assembly38.fasta \
    --in-bam /outputdir/fq2bam_output.bam \
    --out-variants /outputdir/out.vcf \
    --num-htvc-threads 8 \
    --no-alt-contigs \#This flag will ignore all outputs after chrM \
    --run-partition
```

--------------------------------

### Run Clara Parabricks fq2bam with GPUDirect Storage

Source: https://docs.nvidia.com/clara/parabricks/latest/gettingstarted/bestperformance

This script demonstrates using GPUDirect Storage (GDS) with NVIDIA Clara Parabricks for the `fq2bam` pipeline. It downloads and executes a GDS run container script, enabling GDS and MOFED, and mapping volumes for input/output. The command processes FASTQ files into a BAM file with GPU sorting and writing, utilizing GDS for improved bandwidth.

```bash
# Using GDS with the convenience docker wrapper.
$ wget https://raw.githubusercontent.com/NVIDIA/MagnumIO/main/gds/docker/gds-run-container
$ chmod +x gds-run-container
$ ./gds-run-container run \
    --rm \
    --gpus all \
    --enable-mofed \
    --enable-gds \
    --volume INPUT_DIR:/workdir \
    --volume OUTPUT_DIR:/outputdir \
    --workdir /workdir \
    --env TCMALLOC_MAX_TOTAL_THREAD_CACHE_BYTES=268435456 \
    nvcr.io/nvidia/clara/clara-parabricks:4.5.1-1 \
    pbrun fq2bam \
        --ref /workdir/Homo_sapiens_assembly38.fasta \
        --in-fq /workdir/fastq1.gz /workdir/fastq2.gz \
        --out-bam /outputdir/fq2bam_output.bam \
        --tmp-dir /workdir \
        --out-recal-file recal.txt \
        --knownSites /workdir/hg.known_indels.vcf \
        --gpusort \
        --gpuwrite \
        --use-gds
```
Tokens:
Raw